better would it be if Position object can handle LLH as input format!!!\n x, y, z = gnss.llh2xyz(np.deg2rad(dset.lat), np.deg2rad(dset.lon), dset.height)\n return np.stack((x, y, z), axis=1)","def transform_from_latlon(lat, lon):\n from affine import Affine\n lat = np.asarray(lat)\n lon = np.asarray(lon)\n trans = Affine.translation(lon[0], lat[0])\n scale = Affine.scale(lon[1] - lon[0], lat[1] - lat[0])\n return trans * scale","def get_lon_lat(df, nombre, ruido=False):\n from pyproj import transform\n\n lat, lon = [], []\n for index, row in tqdm(df.iterrows()):\n lati, loni = [], []\n try:\n for pt in list(row[\"geometry\"].exterior.coords):\n lati.append(pt[1])\n loni.append(pt[0])\n except Exception as e:\n try:\n row.geometry = row.geometry.map(lambda x: x.convex_hull)\n for pt in list(row[\"geometry\"].exterior.coords):\n lati.append(pt[1])\n loni.append(pt[0])\n except Exception as e:\n try:\n lati.append(df.iloc[index].geometry.centroid.y)\n loni.append(df.iloc[index].geometry.centroid.x)\n except Exception as e:\n if not ruido:\n continue\n else:\n print(e)\n print(df.iloc[index].geometry.centroid)\n lat.append(sum(lati) / len(lati))\n lon.append(sum(loni) / len(loni))\n latnew, lonnew = [], []\n for la, lo in zip(lat, lon):\n o, a = transform(inProj, outProj, lo, la)\n if o != float(\"inf\") and a != float(\"inf\"):\n latnew.append(a)\n lonnew.append(o)\n return {nombre: {\"lon\": lonnew, \"lat\": latnew}}"],"string":"[\n \"def create_pseudo_epsg4326_coordinates(self):\\n self.create_3d_coord_on_sphere(on_sphere=True)\\n self.df_attributes['lat'] = 180*(pi/2 - np.arccos(self.df_attributes['coord_z']))/pi\\n self.df_attributes['lon'] = 180*np.arctan2(self.df_attributes['coord_y'], self.df_attributes['coord_x'])/pi\",\n \"def lonlat_from_utm(eastings, northings, zone, ellipsoid='WGS84', datum='WGS84', parallel=False):\\n\\n eastings = to_list(eastings)\\n northings = to_list(northings)\\n zone = to_list(zone)\\n\\n inverse = True\\n\\n npos = len(eastings)\\n if npos != len(northings):\\n raise ValueError('Supplied eastings and northings are not the same size.')\\n\\n # If we've been given a single zone and multiple coordinates, make a\\n # list of zones so we can do things easily in parallel.\\n if len(zone) != npos:\\n zone = zone * npos\\n\\n # Do this in parallel unless we only have a small number of positions or\\n # we've been told not to.\\n if npos > 1 and parallel:\\n pool = multiprocessing.Pool()\\n arguments = zip(eastings, northings, zone,\\n [ellipsoid] * npos,\\n [datum] * npos,\\n [inverse] * npos)\\n results = pool.map(__convert, arguments)\\n results = np.asarray(results)\\n lon, lat = results[:, 0], results[:, 1]\\n pool.close()\\n elif npos > 1 and not parallel:\\n lon, lat = [], []\\n for pos in zip(eastings, northings, zone, [ellipsoid] * npos, [datum] * npos, [inverse] * npos):\\n result = __convert(pos)\\n lon.append(result[0])\\n lat.append(result[1])\\n else:\\n # The eastings, northings and zone will all be lists here, For\\n # cross-python2/python3 support, we can't just * them, so assume\\n # the first value in the list is what we want.\\n lon, lat = __convert((eastings[0], northings[0], zone[0], ellipsoid, datum, inverse))\\n\\n return np.asarray(lon), np.asarray(lat)\",\n \"def convert_from_latlon_to_utm(points=None,\\r\\n latitudes=None,\\r\\n longitudes=None,\\r\\n false_easting=None,\\r\\n false_northing=None):\\r\\n\\r\\n old_geo = Geo_reference() \\r\\n utm_points = []\\r\\n if points == None:\\r\\n assert len(latitudes) == len(longitudes)\\r\\n points = map(None, latitudes, longitudes)\\r\\n \\r\\n for point in points:\\r\\n \\r\\n zone, easting, northing = redfearn(float(point[0]),\\r\\n float(point[1]),\\r\\n false_easting=false_easting,\\r\\n false_northing=false_northing)\\r\\n new_geo = Geo_reference(zone)\\r\\n old_geo.reconcile_zones(new_geo) \\r\\n utm_points.append([easting, northing])\\r\\n\\r\\n return utm_points, old_geo.get_zone()\",\n \"def TransformUTMToDD(self, coordinates):\\n conversion_status = True\\n decimal_degrees_coordinates = []\\n\\n zone_number = 0\\n zone_letter = \\\"\\\"\\n easting = 0.0\\n northing = 0.0\\n\\n self._logger.debug(\\n \\\"Performing UTM to DD transformation on coordinates %s.\\\", coordinates)\\n\\n matched = re.match(self._utm_pattern, coordinates[0])\\n if matched:\\n try:\\n (zone_number, zone_letter, easting, northing) = matched.groups()\\n except Exception, e:\\n conversion_status = False\\n self._logger.error(\\n \\\"UTM coordinates %s not in proper format, %s.\\\", coordinates, e)\\n\\n x = float(easting) - CoordinateTransform.EASTING_ADJ_FACTOR\\n y = float(northing)\\n\\n zone_number = int(zone_number)\\n longitude_origin_adjustment = ((zone_number * 6) - 183)\\n\\n if (\\n (zone_letter in [\\\"A\\\", \\\"B\\\", \\\"I\\\", \\\"O\\\", \\\"Y\\\", \\\"Z\\\"]) or\\n (zone_number not in xrange(1, 61)) or\\n ((zone_letter in [\\\"X\\\"]) and (zone_number in [32, 34, 36]))\\n ):\\n conversion_status = False\\n self._logger.error(\\\"Invalid grid Zone information entered %s.\\\",\\n coordinates)\\n\\n if zone_letter < \\\"N\\\":\\n y -= CoordinateTransform.NORTHING_ADJ_FACTOR\\n\\n # meridional_arc and mu are used in calculating n1, t1, c1, r1 and d1 values\\n meridional_arc = float(y/CoordinateTransform.K0)\\n mu = (meridional_arc /\\n (CoordinateTransform.EARTH_RADIUS *\\n (1 - (CoordinateTransform.ECC_SQUARED/4) -\\n (3 * math.pow(CoordinateTransform.ECC_SQUARED, 2)/64) -\\n (5 * math.pow(CoordinateTransform.ECC_SQUARED, 3)/256))))\\n\\n # fp is footprint_latitude\\n h1 = 3 * self._e1/2\\n h2 = 27 * math.pow(self._e1, 3)/32\\n h3 = 21 * math.pow(self._e1, 2)/16\\n h4 = 55 * math.pow(self._e1, 4)/32\\n h5 = 151 * math.pow(self._e1, 3)/96\\n h6 = 1097 * math.pow(self._e1, 4)/512\\n\\n x1 = ((h1 - h2) * math.sin(2 * mu))\\n x2 = ((h3 - h4) * math.sin(4 * mu))\\n x3 = (h5 * math.sin(6 * mu))\\n x4 = (h6 * math.sin(8 * mu))\\n fp = mu + x1 + x2 + x3 + x4\\n\\n n1 = (CoordinateTransform.EARTH_RADIUS/\\n math.sqrt(1- (CoordinateTransform.ECC_SQUARED *\\n math.pow(math.sin(fp), 2))))\\n t1 = math.pow(math.tan(fp), 2)\\n c1 = self._e1_prime * math.pow(math.cos(fp), 2)\\n r1 = (CoordinateTransform.EARTH_RADIUS * (\\n (1 - CoordinateTransform.ECC_SQUARED)/math.pow(\\n 1- (CoordinateTransform.ECC_SQUARED *\\n math.pow(math.sin(fp), 2)), 1.5)))\\n d1 = x/(n1 * CoordinateTransform.K0)\\n\\n # q1, q2, q3 and q4 are used in calculating the latitude\\n\\n q1 = n1 * math.tan(fp)/r1\\n q2 = (math.pow(d1, 2)/2)\\n q3 = (5 + (3 * t1) + (10 * c1) - (4 * math.pow(c1, 2)) -\\n (9 * self._e1_prime)) * math.pow(d1, 4)/24\\n q4 = (61 + (90 * t1) + (298 * c1) + (45 * math.pow(t1, 2)) -\\n (3 * math.pow(c1, 2)) - (252 * self._e1_prime)) * math.pow(d1, 6)/720\\n\\n # q5, q6 and q7 are used in calculating the longitude\\n\\n q5 = d1\\n q6 = (1 + (2 * t1) + c1) * math.pow(d1, 3)/6\\n q7 = (5 -(2 * c1) + (28 * t1)-(3 * math.pow(c1, 2)) + (8 * self._e1_prime) +\\n (24 * math.pow(t1, 2))) * math.pow(d1, 5)/120\\n\\n latitude = ((fp - (q1 * (q2 - q3 + q4))) * 180.0/math.pi)\\n longitude = longitude_origin_adjustment + (\\n (q5 - q6 + q7)/math.cos(fp)) * 180.0/math.pi\\n\\n if conversion_status:\\n decimal_degrees_coordinates.append(latitude)\\n decimal_degrees_coordinates.append(longitude)\\n\\n return (conversion_status, decimal_degrees_coordinates)\",\n \"def LLtoUTM( Lat, Long, ReferenceEllipsoid=23):\\r\\n a = _ellipsoid[ReferenceEllipsoid][_EquatorialRadius]\\r\\n eccSquared = _ellipsoid[ReferenceEllipsoid][_eccentricitySquared]\\r\\n k0 = 0.9996\\r\\n\\r\\n#Make sure the longitude is between -180.00 .. 179.9\\r\\n LongTemp = (Long+180)-int((Long+180)/360)*360-180 # -180.00 .. 179.9\\r\\n\\r\\n LatRad = Lat*_deg2rad\\r\\n LongRad = LongTemp*_deg2rad\\r\\n\\r\\n ZoneNumber = int((LongTemp + 180)/6) + 1\\r\\n\\r\\n if Lat >= 56.0 and Lat < 64.0 and LongTemp >= 3.0 and LongTemp < 12.0:\\r\\n ZoneNumber = 32\\r\\n\\r\\n # Special zones for Svalbard\\r\\n if Lat >= 72.0 and Lat < 84.0:\\r\\n if LongTemp >= 0.0 and LongTemp < 9.0:ZoneNumber = 31\\r\\n elif LongTemp >= 9.0 and LongTemp < 21.0: ZoneNumber = 33\\r\\n elif LongTemp >= 21.0 and LongTemp < 33.0: ZoneNumber = 35\\r\\n elif LongTemp >= 33.0 and LongTemp < 42.0: ZoneNumber = 37\\r\\n\\r\\n LongOrigin = (ZoneNumber - 1)*6 - 180 + 3 #+3 puts origin in middle of zone\\r\\n LongOriginRad = LongOrigin * _deg2rad\\r\\n\\r\\n #compute the UTM Zone from the latitude and longitude\\r\\n UTMZone = \\\"%d%c\\\" % (ZoneNumber, _UTMLetterDesignator(Lat))\\r\\n\\r\\n eccPrimeSquared = (eccSquared)/(1-eccSquared)\\r\\n N = a/sqrt(1-eccSquared*sin(LatRad)*sin(LatRad))\\r\\n T = tan(LatRad)*tan(LatRad)\\r\\n C = eccPrimeSquared*cos(LatRad)*cos(LatRad)\\r\\n A = cos(LatRad)*(LongRad-LongOriginRad)\\r\\n\\r\\n M = a*((1\\r\\n - eccSquared/4\\r\\n - 3*eccSquared*eccSquared/64\\r\\n - 5*eccSquared*eccSquared*eccSquared/256)*LatRad\\r\\n - (3*eccSquared/8\\r\\n + 3*eccSquared*eccSquared/32\\r\\n + 45*eccSquared*eccSquared*eccSquared/1024)*sin(2*LatRad)\\r\\n + (15*eccSquared*eccSquared/256 + 45*eccSquared*eccSquared*eccSquared/1024)*sin(4*LatRad)\\r\\n - (35*eccSquared*eccSquared*eccSquared/3072)*sin(6*LatRad))\\r\\n\\r\\n UTMEasting = (k0*N*(A+(1-T+C)*A*A*A/6\\r\\n + (5-18*T+T*T+72*C-58*eccPrimeSquared)*A*A*A*A*A/120)\\r\\n + 500000.0)\\r\\n\\r\\n UTMNorthing = (k0*(M+N*tan(LatRad)*(A*A/2+(5-T+9*C+4*C*C)*A*A*A*A/24\\r\\n + (61\\r\\n -58*T\\r\\n +T*T\\r\\n +600*C\\r\\n -330*eccPrimeSquared)*A*A*A*A*A*A/720)))\\r\\n\\r\\n if Lat < 0:\\r\\n UTMNorthing = UTMNorthing + 10000000.0; #10000000 meter offset for southern hemisphere\\r\\n #UTMZone was originally returned here. I don't know what the\\r\\n #letter at the end was for.\\r\\n #print \\\"UTMZone\\\", UTMZone \\r\\n return (ZoneNumber, UTMEasting, UTMNorthing)\",\n \"def UTMtoLL(northing, easting, zone, isSouthernHemisphere=True,\\r\\n ReferenceEllipsoid=23):\\r\\n k0 = 0.9996\\r\\n a = _ellipsoid[ReferenceEllipsoid][_EquatorialRadius]\\r\\n eccSquared = _ellipsoid[ReferenceEllipsoid][_eccentricitySquared]\\r\\n e1 = (1-sqrt(1-eccSquared))/(1+sqrt(1-eccSquared))\\r\\n\\r\\n x = easting - 500000.0 #remove 500,000 meter offset for longitude\\r\\n y = northing\\r\\n\\r\\n ZoneNumber = int(zone)\\r\\n if isSouthernHemisphere:\\r\\n y -= 10000000.0 # remove 10,000,000 meter offset used\\r\\n # for southern hemisphere\\r\\n\\r\\n LongOrigin = (ZoneNumber - 1)*6 - 180 + 3 # +3 puts origin in middle of zone\\r\\n\\r\\n eccPrimeSquared = (eccSquared)/(1-eccSquared)\\r\\n\\r\\n M = y / k0\\r\\n mu = M/(a*(1-eccSquared/4-3*eccSquared*eccSquared/64-5*eccSquared*eccSquared*eccSquared/256))\\r\\n\\r\\n phi1Rad = (mu + (3*e1/2-27*e1*e1*e1/32)*sin(2*mu)\\r\\n + (21*e1*e1/16-55*e1*e1*e1*e1/32)*sin(4*mu)\\r\\n +(151*e1*e1*e1/96)*sin(6*mu))\\r\\n phi1 = phi1Rad*_rad2deg;\\r\\n\\r\\n N1 = a/sqrt(1-eccSquared*sin(phi1Rad)*sin(phi1Rad))\\r\\n T1 = tan(phi1Rad)*tan(phi1Rad)\\r\\n C1 = eccPrimeSquared*cos(phi1Rad)*cos(phi1Rad)\\r\\n R1 = a*(1-eccSquared)/pow(1-eccSquared*sin(phi1Rad)*sin(phi1Rad), 1.5)\\r\\n D = x/(N1*k0)\\r\\n\\r\\n Lat = phi1Rad - (N1*tan(phi1Rad)/R1)*(D*D/2-(5+3*T1+10*C1-4*C1*C1-9*eccPrimeSquared)*D*D*D*D/24\\r\\n +(61+90*T1+298*C1+45*T1*T1-252*eccPrimeSquared-3*C1*C1)*D*D*D*D*D*D/720)\\r\\n Lat = Lat * _rad2deg\\r\\n\\r\\n Long = (D-(1+2*T1+C1)*D*D*D/6+(5-2*C1+28*T1-3*C1*C1+8*eccPrimeSquared+24*T1*T1)\\r\\n *D*D*D*D*D/120)/cos(phi1Rad)\\r\\n Long = LongOrigin + Long * _rad2deg\\r\\n return (Lat, Long)\",\n \"def LLtoUTM(ReferenceEllipsoid, Lat, Long, zone = None):\\n\\n a = _ellipsoid[ReferenceEllipsoid][_EquatorialRadius]\\n eccSquared = _ellipsoid[ReferenceEllipsoid][_eccentricitySquared]\\n k0 = 0.9996\\n\\n #Make sure the longitude is between -180.00 .. 179.9\\n LongTemp = (Long+180)-int((Long+180)/360)*360-180 # -180.00 .. 179.9\\n\\n LatRad = Lat*_deg2rad\\n LongRad = LongTemp*_deg2rad\\n\\n if zone is None:\\n ZoneNumber = int((LongTemp + 180)/6) + 1\\n else:\\n ZoneNumber = zone\\n\\n if Lat >= 56.0 and Lat < 64.0 and LongTemp >= 3.0 and LongTemp < 12.0:\\n ZoneNumber = 32\\n\\n # Special zones for Svalbard\\n if Lat >= 72.0 and Lat < 84.0:\\n if LongTemp >= 0.0 and LongTemp < 9.0:ZoneNumber = 31\\n elif LongTemp >= 9.0 and LongTemp < 21.0: ZoneNumber = 33\\n elif LongTemp >= 21.0 and LongTemp < 33.0: ZoneNumber = 35\\n elif LongTemp >= 33.0 and LongTemp < 42.0: ZoneNumber = 37\\n\\n LongOrigin = (ZoneNumber - 1)*6 - 180 + 3 #+3 puts origin in middle of zone\\n LongOriginRad = LongOrigin * _deg2rad\\n\\n #compute the UTM Zone from the latitude and longitude\\n UTMZone = \\\"%d%c\\\" % (ZoneNumber, _UTMLetterDesignator(Lat))\\n\\n eccPrimeSquared = (eccSquared)/(1-eccSquared)\\n N = a/sqrt(1-eccSquared*sin(LatRad)*sin(LatRad))\\n T = tan(LatRad)*tan(LatRad)\\n C = eccPrimeSquared*cos(LatRad)*cos(LatRad)\\n A = cos(LatRad)*(LongRad-LongOriginRad)\\n\\n M = a*((1\\n - eccSquared/4\\n - 3*eccSquared*eccSquared/64\\n - 5*eccSquared*eccSquared*eccSquared/256)*LatRad\\n - (3*eccSquared/8\\n + 3*eccSquared*eccSquared/32\\n + 45*eccSquared*eccSquared*eccSquared/1024)*sin(2*LatRad)\\n + (15*eccSquared*eccSquared/256 + 45*eccSquared*eccSquared*eccSquared/1024)*sin(4*LatRad)\\n - (35*eccSquared*eccSquared*eccSquared/3072)*sin(6*LatRad))\\n\\n UTMEasting = (k0*N*(A+(1-T+C)*A*A*A/6\\n + (5-18*T+T*T+72*C-58*eccPrimeSquared)*A*A*A*A*A/120)\\n + 500000.0)\\n\\n UTMNorthing = (k0*(M+N*tan(LatRad)*(A*A/2+(5-T+9*C+4*C*C)*A*A*A*A/24\\n + (61\\n -58*T\\n +T*T\\n +600*C\\n -330*eccPrimeSquared)*A*A*A*A*A*A/720)))\\n if Lat < 0:\\n UTMNorthing = UTMNorthing + 10000000.0; #10000000 meter offset for southern hemisphere\\n return (UTMZone, UTMEasting, UTMNorthing)\",\n \"def rowcol_to_latlon(rowcol_str):\\n\\n # Vectors for code in file name\\n latspace = np.linspace(-90,90,46)\\n lonspace = np.linspace(-180,180,73)\\n lat = latspace[int(rowcol_str[0:2])-1]\\n lon = lonspace[int(rowcol_str[2:])-1]\\n return (lat,lon)\",\n \"def lonlat2xy(s_lon, s_lat): # x: easting, y: northing\\r\\n # convert decimals to seconds...\\r\\n s_lon = dec2sec(s_lon)\\r\\n s_lat = dec2sec(s_lat)\\r\\n\\r\\n ## Auxiliary values \\r\\n # i.e. differences of latitude and longitude relative to Bern in the unit [10000'']\\r\\n s_lng_aux = (s_lon - 26782.5)/10000.\\r\\n s_lat_aux = (s_lat - 169028.66)/10000.\\r\\n \\r\\n # easting\\r\\n s_x = (600072.37 \\r\\n + 211455.93*s_lng_aux \\r\\n - 10938.51*s_lng_aux*s_lat_aux \\r\\n - 0.36*s_lng_aux*(s_lat_aux**2) \\r\\n - 44.54*(s_lng_aux**3))\\r\\n \\r\\n # northing\\r\\n s_y = (200147.07 \\r\\n + 308807.95*s_lat_aux \\r\\n + 3745.25*(s_lng_aux**2) \\r\\n + 76.63*(s_lat_aux**2) \\r\\n - 194.56*(s_lng_aux**2)*s_lat_aux \\r\\n + 119.79*(s_lat_aux**3))\\r\\n\\r\\n return s_x, s_y\",\n \"def utm_from_lonlat(lon, lat, zone=None, ellipsoid='WGS84', datum='WGS84', parallel=False):\\n lon = to_list(lon)\\n lat = to_list(lat)\\n\\n # Fix zone arrays/lists/tuple/strings.\\n if isinstance(zone, str):\\n zone = to_list(zone)\\n elif isinstance(zone, np.ndarray):\\n zone = zone.tolist()\\n\\n # For the spherical case, if we haven't been given zones, find them.\\n if not zone:\\n zone = []\\n try:\\n for lonlat in zip(lon, lat):\\n zone_number = _get_zone_number(*lonlat)\\n zone_letter = _get_zone_letter(lonlat[-1])\\n if zone_number and zone_letter:\\n zone.append('{:d}{}'.format(zone_number, zone_letter))\\n else:\\n raise ValueError('Invalid zone letter: are your latitudes north or south of 84 and -80 respectively?')\\n except TypeError:\\n zone_number = _get_zone_number(lon, lat)\\n zone_letter = _get_zone_letter(lat)\\n if zone_number and zone_letter:\\n zone.append('{:d}{}'.format(zone_number, zone_letter))\\n else:\\n raise ValueError('Invalid zone letter: are your latitudes north or south of 84 and -80 respectively?')\\n\\n zone = to_list(zone)\\n inverse = False\\n\\n try:\\n npos = len(lon)\\n if npos != len(lon):\\n raise ValueError('Supplied latitudes and longitudes are not the same size.')\\n except TypeError:\\n npos = 1\\n\\n # If we've been given a single zone and multiple coordinates, make a\\n # list of zones so we can do things easily in parallel.\\n try:\\n if len(zone) != npos:\\n zone = zone * npos\\n except TypeError:\\n # Leave zone as is.\\n pass\\n\\n # Do this in parallel unless we only have a single position or we've been\\n # told not to.\\n if npos > 1 and parallel:\\n pool = multiprocessing.Pool()\\n arguments = zip(lon, lat, zone,\\n [ellipsoid] * npos,\\n [datum] * npos,\\n [inverse] * npos)\\n results = pool.map(__convert, arguments)\\n results = np.asarray(results)\\n eastings, northings = results[:, 0], results[:, 1]\\n pool.close()\\n elif npos > 1 and not parallel:\\n eastings, northings = [], []\\n for pos in zip(lon, lat, zone, [ellipsoid] * npos, [datum] * npos, [inverse] * npos):\\n result = __convert(pos)\\n eastings.append(result[0])\\n northings.append(result[1])\\n else:\\n # The lon, lat and zone will all be lists here, For\\n # cross-python2/python3 support, we can't just * them, so assume\\n # the first value in the list is what we want.\\n try:\\n eastings, northings = __convert((lon[0], lat[0], zone[0], ellipsoid, datum, inverse))\\n except IndexError:\\n eastings, northings = __convert((lon, lat, zone, ellipsoid, datum, inverse))\\n\\n eastings = to_list(eastings)\\n northings = to_list(northings)\\n\\n return np.asarray(eastings), np.asarray(northings), np.asarray(zone)\",\n \"def UTMZone(x,y):\\n\\n #take longitudinal coordinate and add 180, then divide by 6 and round up\\n lon = int(np.ceil((x + 180)/6))\\n \\n #determine whether y is in the Northern or Southern Hemisphere\\n if y > 0:\\n code = 326\\n else:\\n code = 327\\n \\n #return epsg of the utm zone\\n epsg = int(str(code)+str(lon))\\n return epsg\",\n \"def lonlat_to_eastnorth (lon, lat):\\n\\t# TODO: allow for different resolution?\\n\\t# TODO: allow for different formating?\\n\\t\\n\\t## Preconditions & preparation:\\n\\tlon = radians (lon)\\n\\tlat = radians (lat)\\n\\t# see explanation above\\n\\ta, b = OSGB36.a, OSGB36.b\\n\\tF0 = OSGB36.F0 \\n\\te2 = OSGB36.e2 \\n\\tn, n2, n3 = OSGB36.n, OSGB36.n2, OSGB36.n3\\n\\tlon0 = ORIGIN_LON\\n\\tlat0 = ORIGIN_LAT\\n\\t\\n\\t## MAIN:\\n\\tcoslat = cos (lat)\\n\\tsinlat = sin (lat)\\n\\ttanlat = tan (lat)\\n\\n\\tv = a * F0 * pow (1 - (e2 * sinlat**2), -0.5)\\n\\trho = a * F0 * (1 - e2) * pow (1 - e2 * sinlat**2, -1.5)\\n\\teta2 = (v / rho) - 1\\n\\n\\tMa = (1 + n + (5/4)*n2 + (5/4)*n3) * (lat-lat0)\\n\\tMb = (3*n + 3*n2 + (21/8)*n3) * sin (lat-lat0) * cos (lat+lat0)\\n\\tMc = ((15/8)*n2 + (15/8)*n3) * sin (2*(lat-lat0)) * cos (2*(lat+lat0))\\n\\tMd = (35/24)*n3 * sin (3*(lat-lat0)) * cos (3*(lat+lat0))\\n\\tM = b * F0 * (Ma - Mb + Mc - Md)\\n\\n\\tcos3lat = coslat**3\\n\\tcos5lat = coslat**5\\n\\ttan2lat = tanlat**2\\n\\ttan4lat = tan2lat**2\\n\\n\\tI = M + ORIGIN_NORTHING\\n\\tII = (v/2)*sinlat*coslat\\n\\tIII = (v/24)*sinlat*cos3lat*(5-tan2lat+9*eta2)\\n\\tIIIA = (v/720)*sinlat*cos5lat*(61-58*tan2lat+tan4lat)\\n\\tIV = v*coslat\\n\\tV = (v/6)*cos3lat*(v/rho-tan2lat)\\n\\tVI = (v/120) * cos5lat * (5 - 18*tan2lat + tan4lat + 14*eta2 - 58*tan2lat*eta2)\\n\\tdelta_lon = lon-lon0\\n\\n\\teast = ORIGIN_EASTING + IV*delta_lon + V*delta_lon**3 + VI*delta_lon**5\\n\\tnorth = I + II*delta_lon**2 + III*delta_lon**4 + IIIA*delta_lon**6\\n\\t\\n\\treturn east, north\",\n \"def calculate_UTM_crs(coords):\\n if len(coords) == 2:\\n longitude, latitude = coords\\n elif len(coords) == 4:\\n longitude = statistics.mean([coords[0], coords[2]])\\n latitude = statistics.mean([coords[1], coords[3]])\\n\\n utm_zone = utm_getZone(longitude)\\n\\n utm_isNorthern(latitude)\\n\\n if utm_isNorthern(latitude):\\n direction_indicator = \\\"+north\\\"\\n else:\\n direction_indicator = \\\"+south\\\"\\n\\n utm_crs = \\\"+proj=utm +zone={} {} +ellps=WGS84 +datum=WGS84 +units=m +no_defs\\\".format(utm_zone,\\n direction_indicator)\\n\\n return utm_crs\",\n \"def zone2use(el_df):\\n \\n # First, check for any utm zones provided by the user in the emission location file\\n utmzones_df = el_df[\\\"utmzone\\\"].loc[el_df[\\\"location_type\\\"] == \\\"U\\\"]\\n \\n if utmzones_df.shape[0] > 0:\\n # there are some; find the smallest one\\n utmzones_df['utmzone'] = utmzones_df.apply(lambda row: UTM.getZone(row))\\n utmzones_df['utmband'] = utmzones_df.apply(lambda row: UTM.getBand(row))\\n min_utmzu = int(np.nan_to_num(utmzones_df['utmzone']).min(axis=0))\\n min_utmbu = utmzones_df['utmband'].min()\\n else:\\n min_utmzu = 0\\n min_utmbu = \\\"Z\\\"\\n\\n # Next, compute utm zones from any user provided longitudes and find smallest\\n lon_df = el_df[[\\\"lon\\\"]].loc[el_df[\\\"location_type\\\"] == \\\"L\\\"]\\n if lon_df.shape[0] > 0:\\n lon_df[\\\"z\\\"] = ((lon_df[\\\"lon\\\"]+180)/6 + 1).astype(int)\\n min_utmzl = int(np.nan_to_num(lon_df[\\\"z\\\"]).min(axis=0))\\n else:\\n min_utmzl = 0\\n \\n lat_df = el_df[[\\\"lat\\\"]].loc[el_df[\\\"location_type\\\"] == \\\"L\\\"]\\n if lat_df.shape[0] > 0 and lat_df[\\\"lat\\\"].min() < 0:\\n min_utmbl = \\\"S\\\"\\n else:\\n min_utmbl = \\\"N\\\"\\n\\n if min_utmzu == 0:\\n utmzone = min_utmzl\\n else:\\n if min_utmzl == 0:\\n utmzone = min_utmzu\\n else:\\n utmzone = min(min_utmzu, min_utmzl)\\n\\n hemi = min(min_utmbu, min_utmbl)\\n \\n if utmzone == 0:\\n emessage = \\\"Error! UTM zone is 0\\\"\\n Logger.logMessage(emessage)\\n raise Exception(emessage)\\n if hemi == \\\"Z\\\":\\n emessage = \\\"Error! Hemisphere of UTM zone could not be determined.\\\"\\n Logger.logMessage(emessage)\\n raise Exception(emessage)\\n\\n return utmzone, hemi\",\n \"def __test(inLat, inLong, inZone=False):\\n e, n, z = utm_from_lonlat(inLong, inLat, inZone)\\n lon, lat = lonlat_from_utm(e, n, z)\\n\\n return z, e, n, lon, lat\",\n \"def desiredENU2geo(self, x_L, y_L, z):\\n\\t\\tx = cos(self.local_rot)*x_L - sin(self.local_rot)*y_L\\n\\t\\ty = sin(self.local_rot)*x_L + cos(self.local_rot)*y_L\\n\\n\\t\\tlat0 = self.origin[0]\\n\\t\\tlon0 = self.origin[1]\\n\\n\\t\\tlat, lon, alt = pm.enu2geodetic(x, y, z, lat0, lon0, self.h0)\\n\\t\\treturn lat, lon, alt\",\n \"def get_lat_lon():\\r\\n\\r\\n # Columns: dt,AverageTemperature,AverageTemperatureUncertainty,City,Country,Latitude,Longitude\\r\\n temperatures = pd.read_csv(\\\"GlobalLandTemperatures/GlobalLandTemperaturesByCity.csv\\\")\\r\\n\\r\\n Latitude = temperatures['Latitude']\\r\\n Longitude = temperatures['Longitude']\\r\\n City = temperatures['City']\\r\\n Country = temperatures['Country']\\r\\n\\r\\n lat_array = []\\r\\n long_array = []\\r\\n cities_array = []\\r\\n countries_array = []\\r\\n tuples = []\\r\\n for i, j, city, country in zip(Latitude, Longitude, City, Country):\\r\\n if (i, j) not in tuples:\\r\\n tuples.append((i, j))\\r\\n lat_array.append(float(i[:-1]))\\r\\n long_array.append(float(j[:-1]))\\r\\n cities_array.append(city)\\r\\n countries_array.append(country)\\r\\n\\r\\n return lat_array, long_array, cities_array, countries_array\",\n \"def GPSlatlon2XY(data_sheet, origin, theta):\\n\\n\\tlon = np.array([[data_sheet.cell(row = i, column = 1).value] for i in range(2, data_sheet.max_row+1)]).reshape(data_sheet.max_row-1, )\\n\\tlat = np.array([[data_sheet.cell(row = i, column = 2).value] for i in range(2, data_sheet.max_row+1)]).reshape(data_sheet.max_row-1, )\\n\\n\\tlon_u = np.array([[data_sheet.cell(row = i, column = 5).value] for i in range(2, data_sheet.max_row+1)]).reshape(data_sheet.max_row-1, )\\n\\tlat_u = np.array([[data_sheet.cell(row = i, column = 6).value] for i in range(2, data_sheet.max_row+1)]).reshape(data_sheet.max_row-1, )\\n\\tUz = np.array([[data_sheet.cell(row = i, column = 4).value] for i in range(2, data_sheet.max_row+1)]).reshape(data_sheet.max_row-1, )\\n\\n\\tlon_in_km = (lon - origin[0])*111*np.cos(lat*np.pi/180)\\n\\tlat_in_km = (lat - origin[1])*111\\n\\t\\n\\trho_u = np.sqrt(np.power(lon_u,2) + np.power(lat_u,2))\\n\\ttheta_new_u = np.arctan2(lat_u,lon_u) - theta\\n\\n\\trho = np.sqrt(np.power(lon_in_km,2) + np.power(lat_in_km,2))\\n\\ttheta_new = np.arctan2(lat_in_km,lon_in_km) - theta\\n\\n\\tX, Y = rho*np.cos(theta_new), rho*np.sin(theta_new)\\n\\tUx, Uy = rho_u*np.cos(theta_new_u), rho_u*np.sin(theta_new_u)\\n\\n\\treturn 1e3*X, 1e3*Y, 1e-3*Ux, 1e-3*Uy, 1e-3*Uz\",\n \"def british_national_grid_to_lonlat(eastings, northings):\\n\\n # E, N are the British national grid coordinates - eastings and northings\\n\\n # The Airy 180 semi-major and semi-minor axes used for OSGB36 (m)\\n a, b = 6377563.396, 6356256.909\\n # Scale factor on the central meridian\\n F0 = 0.9996012717\\n # Latitude of true origin (radians)\\n lat0 = np.deg2rad(49)\\n # Longtitude of true origin and central meridian (radians)\\n lon0 = np.deg2rad(-2)\\n # Northing & easting of true origin (m)\\n N0, E0 = -100000, 400000\\n # eccentricity squared\\n e2 = 1 - (b*b)/(a*a)\\n n = (a-b)/(a+b)\\n\\n # Iterate through the pairs of values in eastings and northings.\\n lonlist, latlist = [], []\\n for xy in zip(eastings, northings):\\n\\n E = xy[0]\\n N = xy[1]\\n\\n # Initialise the iterative variables\\n lat, M = lat0, 0\\n\\n while N - N0 - M >= 0.00001: # Accurate to 0.01mm\\n lat = (N - N0 - M)/(a * F0) + lat\\n M1 = (1 + n + (5./4) * n**2 + (5./4) * n**3) * (lat-lat0)\\n M2 = (3*n + 3 * n**2 + (21./8)*n**3) * np.sin(lat-lat0) * \\\\\\n np.cos(lat+lat0)\\n M3 = ((15./8) * n**2 + (15./8)*n**3) * np.sin(2*(lat-lat0)) * \\\\\\n np.cos(2 * (lat+lat0))\\n M4 = (35./24)*n**3 * np.sin(3*(lat-lat0)) * np.cos(3*(lat+lat0))\\n # meridional arc\\n M = b * F0 * (M1 - M2 + M3 - M4)\\n\\n # transverse radius of curvature\\n nu = a * F0 / np.sqrt(1-e2 * np.sin(lat)**2)\\n\\n # meridional radius of curvature\\n rho = a * F0 * (1-e2) * (1-e2 * np.sin(lat)**2)**(-1.5)\\n eta2 = nu / rho-1\\n\\n secLat = 1./np.cos(lat)\\n VII = np.tan(lat) / (2 * rho * nu)\\n VIII = np.tan(lat) / (24 * rho * nu**3) * (5 + 3 * np.tan(lat)**2 +\\n eta2 - 9 * np.tan(lat)**2 * eta2)\\n IX = np.tan(lat) / (720 * rho * nu**5) * (61 + 90 * np.tan(lat)**2 +\\n 45 * np.tan(lat)**4)\\n X = secLat / nu\\n XI = secLat / (6 * nu**3) * (nu / rho + 2 * np.tan(lat)**2)\\n XII = secLat / (120 * nu**5) * (5 + 28 * np.tan(lat)**2 + 24 *\\n np.tan(lat)**4)\\n XIIA = secLat / (5040 * nu**7) * (61 + 662 * np.tan(lat)**2 + 1320 *\\n np.tan(lat)**4 + 720 * np.tan(lat)**6)\\n dE = E-E0\\n\\n # These are on the wrong ellipsoid currently: Airy1830. (Denoted by _1)\\n lat_1 = lat - VII * dE**2 + VIII * dE**4 - IX * dE**6\\n lon_1 = lon0 + X * dE - XI * dE**3 + XII * dE**5 - XIIA * dE**7\\n\\n # Want to convert to the GRS80 ellipsoid.\\n # First convert to cartesian from spherical polar coordinates\\n H = 0 # Third spherical coord.\\n x_1 = (nu / F0 + H) * np.cos(lat_1) * np.cos(lon_1)\\n y_1 = (nu / F0 + H) * np.cos(lat_1) * np.sin(lon_1)\\n z_1 = ((1-e2) * nu / F0 + H) * np.sin(lat_1)\\n\\n # Perform Helmut transform (to go between Airy 1830 (_1) and GRS80 (_2))\\n s = -20.4894 * 10**-6 # The scale factor -1\\n # The translations along x,y,z axes respectively\\n tx, ty, tz = 446.448, -125.157, + 542.060\\n # The rotations along x,y,z respectively, in seconds\\n rxs, rys, rzs = 0.1502, 0.2470, 0.8421\\n # And in radians\\n rx = rxs * np.pi / (180 * 3600.)\\n ry = rys * np.pi / (180 * 3600.)\\n rz = rzs * np.pi / (180 * 3600.)\\n\\n x_2 = tx + (1 + s) * x_1 + (-rz) * y_1 + (ry) * z_1\\n y_2 = ty + (rz) * x_1 + (1 + s) * y_1 + (-rx) * z_1\\n z_2 = tz + (-ry) * x_1 + (rx) * y_1 + (1 + s) * z_1\\n\\n # Back to spherical polar coordinates from cartesian\\n # Need some of the characteristics of the new ellipsoid\\n\\n # The GSR80 semi-major and semi-minor axes used for WGS84(m)\\n a_2, b_2 = 6378137.000, 6356752.3141\\n # The eccentricity of the GRS80 ellipsoid\\n e2_2 = 1 - (b_2 * b_2) / (a_2 * a_2)\\n p = np.sqrt(x_2**2 + y_2**2)\\n\\n # Lat is obtained by an iterative proceedure:\\n lat = np.arctan2(z_2, (p * (1-e2_2))) # Initial value\\n latold = 2 * np.pi\\n while abs(lat - latold) > 10**-16:\\n lat, latold = latold, lat\\n nu_2 = a_2 / np.sqrt(1-e2_2 * np.sin(latold)**2)\\n lat = np.arctan2(z_2 + e2_2 * nu_2 * np.sin(latold), p)\\n\\n # Lon and height are then pretty easy\\n lon = np.arctan2(y_2, x_2)\\n H = p / np.cos(lat) - nu_2\\n\\n # Convert to degrees\\n latlist.append(np.rad2deg(lat))\\n lonlist.append(np.rad2deg(lon))\\n\\n # Convert to NumPy arrays.\\n lon = np.asarray(lonlist)\\n lat = np.asarray(latlist)\\n\\n # Job's a good'n.\\n return lon, lat\",\n \"def convert(coords):\\n lat = coords[:4]\\n lon = coords[4:]\\n\\n lat = lat[:2] + \\\".\\\" + lat[2:]\\n\\n if int(lon[0]) > 5:\\n lon = \\\"-\\\" + lon[:2] + \\\".\\\" + lon[2:]\\n else:\\n lon = \\\"-1\\\" + lon[:2] + \\\".\\\" + lon[2:]\\n\\n return (float(lat), float(lon))\",\n \"def zonecoord_to_eastnorth (coord_str):\\n\\t## Preconditions:\\n\\tlen_str = len (coord_str)\\n\\tassert (len_str % 2 == 0)\\n\\t## Main:\\n\\t# calc size & resolution of numeric portion, split\\n\\trez = len_str / 2\\n\\tosgb_easting = coord_str[:rez]\\n\\tosgb_northing = coord_str[rez:]\\n\\t# what is each digit (in metres)\\n\\trez_unit = 10.0**(5-rez)\\n\\treturn int (osgb_easting) * rez_unit, int (osgb_northing) * rez_unit\",\n \"def nad83(self, coordinates, reverse=False):\\n payload = {\\n 'format': 'json',\\n 's_srs': 4326,\\n 't_srs': 3401,\\n 'x': coordinates[1],\\n 'y': coordinates[0]\\n }\\n if reverse:\\n payload['s_srs'], payload['t_srs'] = payload['t_srs'], payload['s_srs']\\n payload['x'], payload['y'] = payload['y'], payload['x']\\n\\n url = 'http://epsg.io/trans'\\n r = requests.get(url, params=payload)\\n try:\\n data = r.json()\\n except ValueError:\\n data = dict(y='0', x='0')\\n\\n value = (float(data['y']), float(data['x']))\\n return value\",\n \"def geo_transform(self):\\n pass\",\n \"def lat_lons(self):\",\n \"def row_to_lat(self, row):\\n return self.max_absolute_lat - row * self.lat_step\",\n \"def get_latlon():\\n\\t\\n iss.compute() # Get the lat/long values from ephem\\n long_value = [float(i) for i in str(iss.sublong).split(\\\":\\\")]\\n if long_value[0] < 0:\\n long_value[0] = abs(long_value[0])\\n cam.exif_tags['GPS.GPSLongitudeRef'] = \\\"W\\\"\\n else:\\n cam.exif_tags['GPS.GPSLongitudeRef'] = \\\"E\\\"\\n cam.exif_tags['GPS.GPSLongitude'] = '%d/1,%d/1,%d/10' % (long_value[0], long_value[1], long_value[2]*10)\\n lat_value = [float(i) for i in str(iss.sublat).split(\\\":\\\")]\\n if lat_value[0] < 0:\\n lat_value[0] = abs(lat_value[0])\\n cam.exif_tags['GPS.GPSLatitudeRef'] = \\\"S\\\"\\n else:\\n cam.exif_tags['GPS.GPSLatitudeRef'] = \\\"N\\\"\\n cam.exif_tags['GPS.GPSLatitude'] = '%d/1,%d/1,%d/10' % (lat_value[0], lat_value[1], lat_value[2]*10)\\n return (iss.sublat / degree, iss.sublong / degree)\",\n \"def process_coords():\\n split_coords = row[\\\"map_coord\\\"].split(',')\\n map_x, map_y = [int(i) for i in split_coords]\\n map_x_normed = ((map_x*2) / self.MINIMAP_DIM) - 1\\n map_y_normed = -(((map_y*2) / self.MINIMAP_DIM) - 1)\\n return map_x_normed, map_y_normed\",\n \"def geoConvertTBXY(center, tbxy):\\n\\tif tbxy != \\\"\\\":\\n\\t\\ttbxy_parts = tbxy.partition(\\\":\\\")\\n\\n\\t\\tif center == \\\"STCC\\\":\\n\\t\\t\\treturn db.GeoPt(\\n\\t\\t\\t\\tlat = float(tbxy_parts[2]) * 0.00000274 +\\t 33.172,\\n\\t\\t\\t\\tlon = float(tbxy_parts[0]) * 0.0000035 - 144.966\\n\\t\\t\\t)\\n\\t\\telif center == \\\"SLCC\\\":\\n\\t\\t\\treturn db.GeoPt(\\n\\t\\t\\t\\tlat = float(tbxy_parts[2]) * 0.00000275 +\\t 30.054,\\n\\t\\t\\t\\tlon = float(tbxy_parts[0]) * 0.00000329 - 126.589\\n\\t\\t\\t)\\n\\t\\telif center == \\\"FRCC\\\":\\n\\t\\t\\treturn db.GeoPt(\\n\\t\\t\\t\\tlat = float(tbxy_parts[2]) * 0.00000274 +\\t 30.84,\\n\\t\\t\\t\\tlon = float(tbxy_parts[0]) * 0.00000335 - 141\\n\\t\\t\\t)\\n\\n\\treturn None\",\n \"def convert(self, lat, lon):\\r\\n a = self.a\\r\\n b = self.b\\r\\n long0 = self.long0\\r\\n k0 = self.k0\\r\\n dx = self.dx\\r\\n\\r\\n e = (1 - b ** 2 / a ** 2) ** 0.5\\r\\n e2 = e ** 2 / (1 - e ** 2)\\r\\n n = (a - b) / (a + b)\\r\\n nu = a / (1 - (e ** 2) * (sin(lat) ** 2)) ** 0.5\\r\\n p = lon - long0\\r\\n\\r\\n A = a * (1 - n + (5 / 4.0) * (n ** 2 - n ** 3) + (81 / 64.0)*(n ** 4 - n ** 5))\\r\\n B = (3 * a * n / 2.0) * (1 - n + (7 / 8.0) * (n ** 2 - n ** 3) + (55 / 64.0) * (n ** 4 - n ** 5))\\r\\n C = (15 * a * (n ** 2) / 16.0) * (1 - n + (3 / 4.0) * (n ** 2 - n ** 3))\\r\\n D = (35 * a * (n ** 3) / 48.0) * (1 - n + (11 / 16.0) * (n ** 2 - n ** 3))\\r\\n E = (315 * a * (n ** 4) / 51.0) * (1 - n)\\r\\n\\r\\n S = A * lat - B * sin(2 * lat) + C * sin(4 * lat) - D * sin(6 * lat) + E * sin(8 * lat)\\r\\n\\r\\n K1 = S * k0\\r\\n K2 = k0 * nu * sin(2 * lat)/4.0\\r\\n K3 = (k0 * nu * sin(lat) * (cos(lat) ** 3) / 24.0) * \\\\\\r\\n (5 - tan(lat) ** 2 + 9 * e2 * (cos(lat) ** 2) + 4 * (e2 ** 2) * (cos(lat) ** 4))\\r\\n\\r\\n y = K1 + K2 * (p ** 2) + K3 * (p ** 4)\\r\\n\\r\\n K4 = k0 * nu * cos(lat)\\r\\n K5 = (k0 * nu * (cos(lat) ** 3) / 6.0) * (1 - tan(lat) ** 2 + e2 * (cos(lat) ** 2))\\r\\n\\r\\n x = K4 * p + K5 * (p ** 3) + dx\\r\\n return x, y\",\n \"def parse_lon_lat(grid, lon, lat):\\n if lat is None:\\n lat = grid.origin_latitude[\\\"data\\\"][0]\\n if lon is None:\\n lon = grid.origin_longitude[\\\"data\\\"][0]\\n return lon, lat\",\n \"def get_location(self):\\n # h = b'\\\\r\\\\nAT-MSGEO\\\\r\\\\r\\\\n-MSGEO: -3936,3464,-3612,7402d50c\\\\r\\\\n\\\\r\\\\n'\\n # an example of the string returned from the AT-MSGEO used for testing.\\n h = self.acquire_response(b'AT-MSGEO')\\n if isinstance(h, bytes):\\n h = h.decode('utf-8')\\n h = h.strip()\\n h = h.split(':')\\n h = h[1].split(',')\\n x = int(h[0])*1000 # Convert coordinates to meters.\\n y = int(h[1])*1000\\n z = int(h[2])*1000\\n else:\\n print('Location not available')\\n\\n # 'geocent' refers to the geo-centered frame that the co-ordinates are returned in\\n inProj = Proj(proj='geocent', ellps='WGS84', datum='WGS84')\\n\\n # 'latlong' is the frame to be converted to\\n outProj = Proj(proj='latlong', ellps='WGS84', datum='WGS84')\\n\\n # Convert X, Y, Z to latitude, longitude and altitude\\n long, lat, alt = transform(inProj, outProj, x, y, z, radians=False)\\n # l = [str(long), str(lat), str(alt)]\\n return long, lat, alt\",\n \"def GPSlatlon2XY_time(lat_u, lon_u, theta):\\n\\n\\trho_u = np.sqrt(np.power(lon_u, 2) + np.power(lat_u, 2))\\n\\ttheta_new_u = np.arctan2(lat_u, lon_u) - theta\\n\\n\\tUx, Uy = rho_u * np.cos(theta_new_u), rho_u * np.sin(theta_new_u)\\n\\n\\treturn Ux, Uy\",\n \"def project_normalize_coordinates(node_feats, transformer=None, crs=None):\\n # get home node:\\n home_node = node_feats.iloc[\\n (node_feats[\\\"in_degree\\\"] + node_feats[\\\"out_degree\\\"]).argmax()\\n ]\\n home_center = home_node[\\\"center\\\"]\\n\\n @to_series\\n def get_projected_displacement(x, y, home_center):\\n if (x_min < x < x_max) and (y_min < y < y_max):\\n proj_x, proj_y = transformer.transform(x, y)\\n home_x, home_y = transformer.transform(home_center.x, home_center.y)\\n return (proj_x - home_x, proj_y - home_y)\\n else: # fall back to haversine\\n return get_haversine_displacement.__wrapped__(x, y, home_center)\\n\\n if transformer is not None:\\n # get bounds\\n x_min, y_min, x_max, y_max = crs.area_of_use.bounds\\n normed_coords = node_feats[\\\"center\\\"].apply(\\n get_projected_displacement, args=[home_center]\\n )\\n else:\\n normed_coords = node_feats[\\\"center\\\"].apply(\\n get_haversine_displacement, args=[home_center]\\n )\\n\\n # add_distance\\n normed_coords[\\\"distance\\\"] = normed_coords.apply(\\n lambda x: np.sqrt(x[0] ** 2 + x[1] ** 2), axis=1\\n )\\n # TODO: add as a TEST! compare haversine dist to fake-projected coordinates\\n # print(normed_coords[\\\"distance\\\"])\\n # test_distance = node_feats[\\\"center\\\"].apply(\\n # lambda point: ti.geogr.point_distances.haversine_dist(\\n # point.x, point.y, home_center.x, home_center.y\\n # )[0]\\n # )\\n # print(\\n # pd.merge(\\n # normed_coords, test_distance, left_index=True, right_index=True\\n # )\\n # )\\n\\n return pd.merge(\\n node_feats, normed_coords, left_index=True, right_index=True\\n )\",\n \"def get_coordinates(table, replace_columns=False, remove_nans=False):\\n assert \\\"zip code\\\" in table.labels or ((\\\"city\\\" in table.labels or \\\"county\\\" in table.labels) and \\\"state\\\" in table.labels)\\n ref = Table.read_table(pkg_resources.resource_filename(__name__, \\\"geodata/geocode_states.csv\\\"))\\n\\n index_name = \\\"\\\".join(table.labels) # Ensures that index can't possibly be one of the preexisting columns\\n index_name += \\\" \\\"\\n \\n table = table.with_columns(index_name, np.arange(table.num_rows))\\n lat = np.array([np.nan] * table.num_rows)\\n lon = np.array([np.nan] * table.num_rows)\\n unassigned = set(range(table.num_rows)) \\n while len(unassigned) > 0:\\n index = unassigned.pop()\\n row = table.take(index).take(0)\\n if \\\"zip code\\\" in table.labels:\\n select = table.where(\\\"zip code\\\", row[\\\"zip code\\\"][0]).column(index_name)\\n unassigned -= set(select)\\n try:\\n ref_lat, ref_lon = ref.where(\\\"zip\\\", int(row[\\\"zip code\\\"][0])).select(\\\"lat\\\", \\\"lon\\\").row(0)\\n lat[select] = ref_lat\\n lon[select] = ref_lon\\n except IndexError:\\n pass\\n else:\\n state_select = table.where(\\\"state\\\", row[\\\"state\\\"][0]).column(index_name)\\n county_select = table.where(\\\"county\\\", row[\\\"county\\\"][0]).column(index_name) if \\\"county\\\" in table.labels else np.arange(table.num_rows)\\n city_select = table.where(\\\"city\\\", row[\\\"city\\\"][0]).column(index_name) if \\\"city\\\" in table.labels else np.arange(table.num_rows)\\n select = set.intersection(set(state_select), set(county_select), set(city_select))\\n unassigned -= select\\n select = list(select)\\n try:\\n matched_ref = ref.where(\\\"state\\\", row[\\\"state\\\"][0])\\n if \\\"county\\\" in table.labels:\\n matched_ref = matched_ref.where(\\\"county\\\", row[\\\"county\\\"][0].lower())\\n if \\\"city\\\" in table.labels:\\n matched_ref = matched_ref.where(\\\"city\\\", row[\\\"city\\\"][0].lower())\\n ref_lat, ref_lon = matched_ref.select(\\\"lat\\\", \\\"lon\\\").row(0)\\n lat[select] = ref_lat\\n lon[select] = ref_lon\\n except IndexError:\\n pass\\n table = table.with_columns(\\\"lat\\\", lat, \\\"lon\\\", lon)\\n table = table.drop(index_name)\\n if replace_columns:\\n for label in [\\\"county\\\", \\\"city\\\", \\\"zip code\\\", \\\"state\\\"]:\\n try:\\n table = table.drop(label)\\n except KeyError:\\n pass\\n if remove_nans: \\n table = table.where(\\\"lat\\\", are.below(float(\\\"inf\\\"))) # NaNs are not considered to be smaller than infinity\\n return table\",\n \"def lat_lng(row):\\r\\n lat = row[\\\"latitude\\\"]\\r\\n lng = row[\\\"longitude\\\"]\\r\\n n = int(lat/GRANULARITY)\\r\\n nlat_start = n * GRANULARITY\\r\\n nlat_end = nlat_start + GRANULARITY\\r\\n nlg=int(lng/GRANULARITY)\\r\\n nlng_start = nlg * GRANULARITY\\r\\n nlng_end = nlng_start + GRANULARITY\\r\\n latlng=[(nlat_start,nlng_start), (nlat_start,nlng_end), (nlat_end,nlng_end), (nlat_end,nlng_start)]\\r\\n return latlng\",\n \"def createCoordTuples(data):\\n data['xy'] = None\\n for i, row in data.iterrows():\\n data['xy'][i] = [np.round(row['geometry'].x, decimals=5), np.round(row['geometry'].y, decimals=5)]\\n return data\",\n \"def convertLatLon(latCell, lonCell):\\n cell_lats = np.array([])\\n cell_lons = np.array([])\\n for lat in latCell:\\n cell_lats = np.append(cell_lats, lat * (180 / np.pi)) \\n for lon in lonCell:\\n cell_lons = np.append(cell_lons, lon * (180 / np.pi)) \\n\\n return cell_lats, cell_lons\",\n \"def location_input():\\n \\n # location for OPV greenhouse at UA CEAC in Tucson, AZ\\n \\n latitude = 32.28 # OPV greenhouse latitude (deg)\\n longitude = -110.94 # OPV greenhouse longitude (deg)\\n timezone = -7 # Tucson, AZ timezone (UTC)\\n elevation = 718 # OPV greenhouse elevation (m)\\n \\n return latitude, longitude, timezone, elevation\",\n \"def convertCoord(lon, lat, inEPSG, outEPSG):\\n from pyproj import Proj, transform\\n inProj = Proj(init='epsg:'+str(inEPSG))\\n outProj = Proj(init='epsg:'+str(outEPSG))\\n x, y = transform(inProj, outProj, lon, lat)\\n return x, y\\n # epsg:4326 WGS84\\n # epsg:2950 MTM8\\n # epsg:6622 Quebec Lambert\",\n \"def map_coordinates(self,geometry):\\n\\t\\tg = self.geomatrix\\n\\t\\tdef project_coord(x,y,z=None):\\n\\t\\t\\tx = g[0] + g[1] * x + g[2] * y\\n\\t\\t\\ty = g[3] + g[4] * x + g[5] * y\\n\\t\\t\\tif z is None:\\n\\t\\t\\t\\treturn x,y\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn x,y,z\\n\\t\\treturn transform(project_coord, geometry)\",\n \"def coords_from_cell(cell, lon = [-8.73, -8.50], lat = [41.10, 41.25], N = 100, M = 75):\\n lon_step = (lon[1] - lon[0]) / N \\n lat_step = (lat[1] - lat[0]) / M\\n \\n middle_lon = lon[0] + cell[0] * lon_step + lon_step / 2\\n middle_lat = lat[0] + cell[1] * lat_step + lat_step / 2\\n \\n return [middle_lon, middle_lat]\",\n \"def coords_to_gps(self,coords):\\n return ((self.max_lat - (self.lat_step * (0.5+coords[0]))),(self.min_lon + (self.lon_step * (0.5+coords[1]))))\",\n \"def gen_gps_to_coords(lat,lon,rows,cols,min_lat,max_lat,min_lon,max_lon):\\n\\n if (lat <= min_lat or lat >= max_lat or lon <= min_lon or lon >= max_lon):\\n return (-1,-1)\\n\\n lat_step = abs(max_lat-min_lat)/rows\\n lon_step = abs(max_lon-min_lon)/cols\\n\\n lat_spot = int((max_lat-lat)/lat_step)\\n lon_spot = int((lon-min_lon)/lon_step)\\n #print \\\"lat: %f lon: %f lat_spot: %f lon_spot: %f\\\" % (lat,lon,lat_spot,lon_spot)\\n return (lat_spot,lon_spot)\",\n \"def map_coord_transformer(df, proj_string, lat_column_name, long_column_name):\\n logging.info('Generating coordinate reference systems... ')\\n #generate coordinate reference system objects for details of how this works \\n from_crs = pyproj.CRS.from_string(proj_string)\\n from_proj = pyproj.Proj(from_crs)\\n gps_proj = pyproj.Proj('epsg:4326')\\n original_coordinates_to_latlong_obj = pyproj.Transformer.from_proj(from_proj, gps_proj)\\n logging.info('Defining transformation functions...')\\n def original_coordinates_to_latlong(adf):\\n (lat,long) = original_coordinates_to_latlong_obj.transform(adf[lat_column_name], adf[long_column_name])\\n return lat, long\\n \\n #apply converter to generate series\\n logging.info('Converting coordinates...')\\n latlong_series = df.apply(original_coordinates_to_latlong, axis=1)\\n \\n #get calculated values and put back into df.\\n logging.info('Splitting series...')\\n lat_series = latlong_series.copy().apply(lambda x: x[0])\\n long_series = latlong_series.copy().apply(lambda x: x[1])\\n \\n #return the values as \\n logging.info('Preparing to return calc_lat and calc_long...')\\n df.loc[:,'calc_lat'] = lat_series.copy()\\n df.loc[:,'calc_long'] = long_series.copy()\\n \\n return df\",\n \"def split_stn_coords(U, stn):\\n if stn == 101:\\n return U[9], U[10], U[11], 9\\n elif stn == 337:\\n return U[12], U[13], U[14], 12\\n elif stn == 394:\\n return U[15], U[16], U[17], 15\",\n \"def _normalize_location(lat: float, lon: float):\\n latitude = \\\"{0:.3f}\\\".format(round(lat, 3))\\n longitude = \\\"{0:.3f}\\\".format(round(lon, 3))\\n return latitude + \\\":\\\" + longitude\",\n \"def ll2xyz(lon_pt,lat_pt):\\n\\n xPt = np.cos(lat_pt) * np.cos(lon_pt)\\n yPt = np.cos(lat_pt) * np.sin(lon_pt)\\n zPt = np.sin(lat_pt)\\n return [xPt,yPt,zPt]\",\n \"def to_lnglat(r):\\n \\n x, y = r['x_coordinate'], r['y_coordinate']\\n if np.isnan(x) or np.isnan(y):\\n return None, None\\n return projection(x, y, inverse = True)\",\n \"def parsenwspt(text):\\n lat = int(text[0:4]) / 100\\n lon = int(text[4:])\\n if lon < 1000:\\n lon += 10000\\n return (lon / -100, lat)\",\n \"def calcLatLon(northing, easting):\\n from math import asin, atan2, cos, log, pow, sin, sqrt\\n\\n # CONSUS Albers variables (EPSG: 5070)\\n RE_NAD83 = 6378137.0\\n E_NAD83 = 0.0818187034 # Eccentricity\\n D2R = 0.01745329251 # Pi/180\\n standardParallel1 = 43.\\n standardParallel2 = 47.\\n centralMeridian = -114.\\n originLat = 30\\n originLon = 0\\n\\n m1 = cos(standardParallel1 * D2R) / \\\\\\n sqrt(1.0 - pow((E_NAD83 * sin(standardParallel1 * D2R)), 2.0))\\n m2 = cos(standardParallel2 * D2R) / \\\\\\n sqrt(1.0 - pow((E_NAD83 * sin(standardParallel2 * D2R)), 2.0))\\n\\n def calcPhi(i):\\n sinPhi = sin(i * D2R)\\n return (1.0 - pow(E_NAD83, 2.0)) * \\\\\\n ((sinPhi/(1.0 - pow((E_NAD83 * sinPhi), 2.0))) -\\n 1.0/(2.0 * E_NAD83) *\\n log((1.0 - E_NAD83 * sinPhi)/(1.0 + E_NAD83 * sinPhi)))\\n\\n q0 = calcPhi(originLat)\\n q1 = calcPhi(standardParallel1)\\n q2 = calcPhi(standardParallel2)\\n nc = (pow(m1, 2.0) - pow(m2, 2.0)) / (q2 - q1)\\n C = pow(m1, 2.0) + nc * q1\\n rho0 = RE_NAD83 * sqrt(C - nc * q0) / nc\\n rho = sqrt(pow(easting, 2.0) + pow((rho0 - northing), 2.0))\\n q = (C - pow((rho * nc / RE_NAD83), 2.0)) / nc\\n beta = asin(q / (1.0 - log((1.0 - E_NAD83) / (1.0 + E_NAD83)) *\\n (1.0 - pow(E_NAD83, 2.0))/(2.0 * E_NAD83)))\\n a = 1.0 / 3.0 * pow(E_NAD83, 2.0) + 31.0 / 180.0 * \\\\\\n pow(E_NAD83, 4.0) + 517.0 / 5040.0 * pow(E_NAD83, 6.0)\\n b = 23.0/360.0 * pow(E_NAD83, 4.0) + 251.0 / 3780.0 * pow(E_NAD83, 6.0)\\n c = 761.0/45360.0 * pow(E_NAD83, 6.0)\\n theta = atan2(easting, (rho0 - northing))\\n\\n lat = (beta + a * sin(2.0 * beta) + b * sin(4.0 * beta) +\\n c * sin(6.0 * beta))/D2R\\n lon = centralMeridian + (theta / D2R) / nc\\n coords = [lat, lon]\\n\\n return coords\",\n \"def find_stn(ref_lon, ref_lat, tlon, tlat):\\n\\n # find the indices of the 4 model grid points around the location\\n Ilist, Jlist = find_stn_idx(ref_lon, ref_lat, tlon, tlat)\\n\\n # get the 4 model grid points longitudes and latitudes\\n lonlist = []\\n latlist = []\\n for i in Ilist:\\n for j in Jlist:\\n lonlist.append(tlon[i,j])\\n latlist.append(tlat[i,j])\\n\\n # convert Python lists to numpy arrays\\n lonlist = N.array(lonlist)\\n latlist = N.array(latlist)\\n\\n return lonlist, latlist\",\n \"def noaa_station_data_from_row(row):\\n if len(row) < 12:\\n return None\\n latitude = parselatlon_noaa(row[7], 'N', 'S')\\n if latitude is None:\\n return None\\n longitude = parselatlon_noaa(row[8], 'E', 'W')\\n if longitude is None:\\n return None\\n\\n height = _int_from_string(row[11])\\n return {LATITUDE:latitude, LONGITUDE:longitude, ELEVATION:height}\",\n \"def latlons(self):\\n\\t\\t\\n\\t\\t# First check we have a grid feature type\\n\\t\\tif self.featuretype in ['Grid', 'GridSeries']:\\n\\n\\t\\t\\tlatvar = self.latitude_variable\\n\\t\\t\\tlonvar = self.longitude_variable\\n\\n\\t\\t\\tlatdims = self.coordinates_mapping['latitude']['map']\\n\\t\\t\\tlondims = self.coordinates_mapping['longitude']['map']\\n\\n\\t\\t\\t# Create latitude and longitude subset slices from the field subset slices\\n\\t\\t\\tlat_subset = []\\n\\t\\t\\tfor dim in latdims:\\n\\t\\t\\t\\tlat_subset.append(self._subset[dim])\\n\\t\\t\\t\\n\\t\\t\\tlon_subset = []\\n\\t\\t\\tfor dim in londims:\\n\\t\\t\\t\\tlon_subset.append(self._subset[dim])\\n\\n\\t\\t\\t# Then check if latitude and longitude variables are 1D\\n\\t\\t\\tif len(latvar.shape) == 1 and len(lonvar.shape) == 1:\\n\\t\\t\\t\\tlatvar_2d = latvar[lat_subset].reshape((-1,1)).repeat(lonvar.shape[0], axis=1)\\n\\t\\t\\t\\tlonvar_2d = lonvar[lon_subset].reshape((-1,1)).transpose().repeat(latvar.shape[0], axis=0)\\n\\t\\t\\t\\treturn (latvar_2d, lonvar_2d)\\n\\t\\t\\t\\n\\t\\t\\t# for 2D variables its easy, just return the variable data\\n\\t\\t\\telif len(latvar.shape) >= 2 and len(lonvar.shape) >= 2:\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# Handle the WRF case where lat/lon variables are 3D with time as first dimension\\n\\t\\t\\t\\tif len(latvar.shape) == 3 and len(lonvar.shape) == 3:\\n\\t\\t\\t\\t\\treturn (latvar[0,lat_subset], lonvar[0,lon_subset])\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\treturn (latvar[lat_subset], lonvar[lon_subset])\\n\\t\\t\\t\\n\\t\\t\\t# otherwise, we can't do it!\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn (None, None)\\n\\t\\t\\n\\t\\telif self.featuretype == 'PointSeries':\\n\\t\\t\\treturn (self.latitude_variable[:], self.longitude_variable[:])\",\n \"def makeUpCoords(numb):\\n # bounds of UK in EPSG:4326\\n minLat=49.96\\n maxLat=60.84\\n minLon=-7.5\\n maxLon=1.78\\n # generate array of random numbers\\n lon=np.random.rand(numb)*(maxLon-minLon)+minLon\\n lat=np.random.rand(numb)*(maxLat-minLat)+minLat\\n return(lon,lat)\",\n \"def oszone_to_eastnorth (ossquare):\\n\\t## Preconditions:\\n\\tassert (len (ossquare) == 2)\\n\\t## Main:\\n\\t# find the 500km square\\n\\tmainsq = ossquare[0]\\n\\tif (mainsq is 'S'):\\n\\t\\tx, y = 0, 0\\n\\telif (mainsq is 'T'):\\n\\t\\tx, y = 1, 0\\n\\telif (mainsq is 'N'):\\n\\t\\tx, y = 0, 1\\n\\telif (mainsq is 'O'):\\n\\t\\tx, y = 1, 1\\n\\telif (mainsq is 'H'):\\n\\t\\tx, y = 0, 2\\n\\telif (mainsq is 'J'):\\n\\t\\tx, y = 1, 2\\n\\telse:\\n\\t\\tassert (False), \\\"'%s' is not an OSGB 500km square\\\" % mainsq\\n\\teasting = x * 500\\n\\tnorthing = y * 500\\n\\t\\n\\t# find the 100km offset & add\\n\\tgrid = \\\"VWXYZQRSTULMNOPFGHJKABCDE\\\"\\n\\tminorsq = mainsq = ossquare[1]\\n\\tassert (minorsq in grid), \\\"'%s' is not an OSGB 100km square\\\" % minorsq\\n\\tposn = grid.find (minorsq)\\n\\teasting += (posn % 5) * 100\\n\\tnorthing += (posn / 5) * 100\\n\\treturn easting * 1000, northing * 1000\",\n \"def csv_azmdist2latlon(self):\\n global input_data\\n err_msg = ''\\n # Create temporary vector layer to store oytput points\\n v_lyr_name = tmp_layer_name() # Get layer name\\n self.create_tmp_layer(v_lyr_name)\\n # Set layer to active\\n v_lyr = QgsVectorLayer('Point?crs=epsg:4326', v_lyr_name, 'memory')\\n v_lyr = self.iface.activeLayer()\\n # Enabale edititing\\n v_lyr.startEditing()\\n v_prov = v_lyr.dataProvider()\\n feat = QgsFeature()\\n \\n out_csv_field_names = ['P_NAME', 'AZM_BRNG', 'DIST', 'LAT_DMS', 'LON_DMS', 'NOTES']\\n with open(input_data.f_in, 'r') as in_csv:\\n with open(input_data.f_out, 'w') as out_csv:\\n reader = csv.DictReader(in_csv, delimiter = ';')\\n writer = csv.DictWriter(out_csv, fieldnames = out_csv_field_names, delimiter = ';')\\n for row in reader:\\n try: # Try to read line according to field names\\n azm_dist_valid, err_msg = validate_azm_dist(row['AZM_BRNG'], row['DIST'])\\n if azm_dist_valid: # azimuth or brng and distance are valid\\n # Correct azimuth by magnetic variation\\n azm = float(row['AZM_BRNG']) + input_data.r_mag\\n if azm < 0:\\n azm += 360\\n elif azm > 360:\\n azm -= 360\\n # Calculate second point latitude and longitude in decimal degress \\n ep_lat_dd, ep_lon_dd = vincenty_direct_solution(input_data.r_lat, input_data.r_lon, azm, float(row['DIST']), WGS84_A, WGS84_B, WGS84_F)\\n # Convert to DMS format with hemisphere indicator as prefix\\n ep_lat_dms = dd2dms_shdp(ep_lat_dd, C_LAT)\\n ep_lon_dms = dd2dms_shdp(ep_lon_dd, C_LON)\\n # Write result to output file\\n writer.writerow({'P_NAME': row['P_NAME'],\\n 'AZM_BRNG': row['AZM_BRNG'],\\n 'DIST': row['DIST'],\\n 'LAT_DMS' : ep_lat_dms,\\n 'LON_DMS' : ep_lon_dms,\\n 'NOTES' : ''})\\n # Write result to temporary layer\\n end_point = QgsPoint(ep_lon_dd, ep_lat_dd)\\n feat.setGeometry(QgsGeometry.fromPoint(end_point))\\n feat.setAttributes([0, row['P_NAME'], ep_lat_dms, ep_lon_dms])\\n v_prov.addFeatures([feat])\\n v_lyr.commitChanges()\\n else: # azimuth or brng or distance is not valid write err_msg to NOTES\\n writer.writerow({'P_NAME': row['P_NAME'],\\n 'AZM_BRNG': row['AZM_BRNG'],\\n 'DIST': row['DIST'],\\n 'LAT_DMS' : '',\\n 'LON_DMS' : '',\\n 'NOTES' : err_msg})\\n except: # Row of csv does not match to field names in header\\n writer.writerow({'P_NAME': row['P_NAME'],\\n 'AZM_BRNG': row['AZM_BRNG'],\\n 'DIST': row['DIST'],\\n 'LAT_DMS' : '',\\n 'LON_DMS' : '',\\n 'NOTES' : 'Wrong CSV line'})\\n \\n v_lyr.updateExtents() \\n return\",\n \"def project_xy_to_latlng(x, y):\\n if x and y: # neither are blank\\n d = {}\\n latlng = NYSP1983_PROJ(int(x), int(y), inverse=True)\\n d['longitude'], d['latitude'] = [round(c, 5) for c in latlng] # round em\\n return d\\n else:\\n return {'longitude': None, 'latitude': None}\",\n \"def get_lat_long(self, postcodes):\\n # Fix evil postcodes\\n postcodes = clean_postcodes(postcodes)\\n\\n postcode_df = self.postcode_df\\n postcode_df = postcode_df.fillna('np.nan')\\n postcode_df = postcode_df.set_index('Postcode')\\n index_data = postcode_df.loc[postcodes]\\n lat = np.array(index_data['Latitude']).T\\n lng = np.array(index_data['Longitude']).T\\n\\n return np.vstack((lat, lng)).transpose()\",\n \"def northing(self):\\r\\n x, y = self.lonlat2xy(self.longitude, self.latitude)\\r\\n return y\",\n \"def add_latlon(df):\\n LLs = [num2deg(x,y,z) for x,y,z in zip(df['x'],df['y'],df['z'])]\\n LLdf = pd.DataFrame.from_records(LLs,columns = ['latitude','longitude'])\\n return pd.concat([df.reset_index(drop=True),LLdf],axis = 1)\",\n \"def get_ecmwf_lat_lon(nc_file):\\n from netCDF4 import Dataset\\n \\n fh = Dataset(nc_file, mode='r')\\n\\n latitude_ecmwf = fh.variables['latitude_ecmwf'][:]\\n longitude_ecmwf = fh.variables['longitude_ecmwf'][:]\\n\\n lonmesh_ecmwf,latmesh_ecmwf = np.meshgrid(longitude_ecmwf,latitude_ecmwf)\\n\\n print('latitude_ecmwf: ', latitude_ecmwf.shape)\\n print('longitude_ecmwf: ', longitude_ecmwf.shape)\\n \\n return latitude_ecmwf, longitude_ecmwf, latmesh_ecmwf, lonmesh_ecmwf;\",\n \"def _getlats(self):\\n lats = 90. - np.degrees(self.zeros)\\n return lats\",\n \"def gps_to_coords(self,lat,lon):\\n\\n if (lat <= self.min_lat or lat >= self.max_lat or lon <= self.min_lon or lon >= self.max_lon):\\n return (-1,-1)\\n\\n lat_spot = int((self.max_lat-lat)/self.lat_step)\\n lon_spot = int((lon-self.min_lon)/self.lon_step)\\n #print \\\"lat: %f lon: %f lat_spot: %f lon_spot: %f\\\" % (lat,lon,lat_spot,lon_spot)\\n return (lat_spot,lon_spot)\",\n \"def wgs84_to_mercator(df, lon, lat):\\n k = 6378137\\n df[\\\"x\\\"] = df[lon] * (k * np.pi/180.0)\\n df[\\\"y\\\"] = np.log(np.tan((90 + df[lat]) * np.pi/360.0)) * k\\n return df\",\n \"def cartesian_to_geographical(coordinate_triples):\\n if len(coordinate_triples.shape) == 1:\\n x = coordinate_triples[0]\\n y = coordinate_triples[1]\\n z = coordinate_triples[2]\\n elif len(coordinate_triples.shape) == 2:\\n assert coordinate_triples.shape[1] == 3\\n x = coordinate_triples[:, 0]\\n y = coordinate_triples[:, 1]\\n z = coordinate_triples[:, 2]\\n radius = np.sqrt(x**2 + y**2 + z**2)\\n longitudes = np.arctan2(y, x)\\n latitudes = np.arcsin(z/radius)\\n return (latitudes, longitudes)\",\n \"def _getXYZ ( lon, lat ):\\n d2r = pi / 180.\\n rlon, rlat = ( d2r * lon, d2r * lat )\\n x = cos(rlat) * cos(rlon)\\n y = cos(rlat) * sin(rlon)\\n z = sin(rlat)\\n return (x,y,z)\",\n \"def get_coordinates(addresses, boroughs):\\n latitude = []\\n longitude = []\\n for address, borough in zip(addresses, boroughs):\\n try:\\n g = geocoder.osm('{}, {}, New York'.format(address, borough)).json\\n latitude.append(g['lat'])\\n longitude.append(g['lng'])\\n except:\\n latitude.append(None)\\n longitude.append(None)\\n\\n return np.array(latitude).T, np.array(longitude).T\",\n \"def convert_to_utm(self, lat, lon):\\n\\t\\ttry:\\n\\t\\t\\treturn utm.from_latlon(lat, lon)\\n\\t\\texcept e as Exception:\\n\\t\\t\\tprint(\\\"Error converting lat/lon to utm: {}\\\".format(e))\\n\\t\\t\\treturn None\",\n \"def transform_utm_to_wgs(row):\\n return pd.Series(pyproj.transform(utm12n, wgs84, row['xutm'], row['yutm']))\",\n \"def _get_latitude(self, latitude, hemisphere):\\n if not isinstance(latitude, float):\\n latitude = float(latitude)\\n if hemisphere.lower() == \\\"n\\\":\\n return latitude\\n if hemisphere.lower() == \\\"s\\\":\\n return -1 * latitude\",\n \"def calcStationCoords(station, gridSquares):\\n\\n # calculate coordinates and precision\\n gridRef = station[\\\"gridReference\\\"]\\n gridCode = gridRef[:2]\\n station[\\\"precision\\\"] = 10 ** (5 - len(gridRef[2:])/2) # Units: meters\\n station[\\\"easting\\\"] = (\\n gridSquares[gridCode][0] + int(gridRef[2:len(gridRef[2:])/2 + 2]) *\\n station[\\\"precision\\\"]\\n )\\n station[\\\"northing\\\"] = (\\n gridSquares[gridCode][1] + int(gridRef[len(gridRef[2:])/2 + 2:]) *\\n station[\\\"precision\\\"]\\n )\\n\\n return station\",\n \"def geo2cell(geofile, posfile):\",\n \"def normalize_simple(line):\\n first = find_next_comma_newline(line,0)\\n #print \\\"first: %d\\\" % first\\n second = find_next_comma_newline(line,first+1)\\n #print \\\"second: %d\\\" % second\\n third = find_next_comma_newline(line,second+1)\\n #print \\\"third: %d\\\" % third\\n if third == -1:\\n lon = float(line[second+1:])\\n else:\\n lon = float(line[second+1:third])\\n return int(line[0:first]),float(line[first+1:second]),lon\",\n \"def convertView2Geo(self, x, y):\\n\\n # x_pix is from left map edge, y_pix from top map edge\\n x_pix = x + self.view_offset_x\\n y_pix = y + self.view_offset_y\\n\\n lon = self.map_llon + x_pix/self.ppd_x\\n lat = self.map_tlat - y_pix/self.ppd_y\\n\\n return (lon, lat)\",\n \"def process_latlon(self):\\n data = self.unixtext.replace(\\\"\\\\n\\\", \\\" \\\")\\n search = LAT_LON_PREFIX.search(data)\\n if search is None:\\n return None\\n pos = search.start()\\n newdata = data[pos+9:]\\n # Go find our next non-digit, non-space character, if we find it, we\\n # should truncate our string, this could be improved, I suspect\\n search = re.search(r\\\"[^\\\\s0-9]\\\", newdata)\\n if search is not None:\\n pos2 = search.start()\\n newdata = newdata[:pos2]\\n\\n poly = str2polygon(newdata)\\n if poly is None:\\n return None\\n\\n # check 0, PGUM polygons are east longitude akrherz/pyIEM#74\\n if self.tp.source == 'PGUM':\\n newpts = [[0 - pt[0], pt[1]] for pt in poly.exterior.coords]\\n poly = Polygon(newpts)\\n\\n # check 1, is the polygon valid?\\n if not poly.is_valid:\\n self.tp.warnings.append(\\n (\\\"LAT...LON polygon is invalid!\\\\n%s\\\") % (poly.exterior.xy,))\\n return\\n # check 2, is the exterior ring of the polygon clockwise?\\n if poly.exterior.is_ccw:\\n self.tp.warnings.append(\\n (\\\"LAT...LON polygon exterior is CCW, reversing\\\\n%s\\\"\\n ) % (poly.exterior.xy,))\\n poly = Polygon(zip(poly.exterior.xy[0][::-1],\\n poly.exterior.xy[1][::-1]))\\n self.giswkt = 'SRID=4326;%s' % (dumps(MultiPolygon([poly]),\\n rounding_precision=6),)\\n return poly\",\n \"def calcPosition (lat, lon):\\n nauticalMilePerLat = 60.00721\\n nauticalMilePerLongitude = 60.10793\\n rad = math.pi / 180.0\\n milesPerNauticalMile = 1.15078\\n \\n y = lat * nauticalMilePerLat\\n x = math.cos(lat * rad) * lon * nauticalMilePerLongitude\\n\\n return x * milesPerNauticalMile * 1609.344, y * milesPerNauticalMile * 1609.344\",\n \"def get_near_cities_from_user_coordinates(user_coordinates):\\n data = pandas.read_csv('city_coordinates.tsv', sep='\\\\t')\\n cities = data['city_ascii']\\n latitudes, longitudes = data['lat'], data['lng']\\n distance_list = []\\n for city, lat, lng in zip(cities, latitudes, longitudes):\\n try:\\n distance = geodesic((lat, lng), user_coordinates).km\\n distance_list.append(((lat, lng), city, distance))\\n except Exception:\\n continue\\n distance_list_sorted = sorted(distance_list, key=lambda x: x[-1])\\n return [elem[-2] for elem in distance_list_sorted[:100]]\",\n \"def lunar_longitude(cls, tee):\\n return cls.true_position(tee, cls.SIDEREAL_MONTH, 32/360, cls.ANOMALISTIC_MONTH, 1/96)\",\n \"def geo2desiredENU(self, lat, lon, h):\\n\\t\\tlat0 = self.origin[0]\\n\\t\\tlon0 = self.origin[1]\\n\\t\\tx,y,z = pm.geodetic2enu(lat, lon, h, lat0, lon0, self.h0)\\n\\n\\t\\tx_L = cos(self.local_rot)*x + sin(self.local_rot)*y\\n\\t\\ty_L = -1*sin(self.local_rot)*x + cos(self.local_rot)*y\\n\\n\\t\\tz = self.curr_z_enu - self.GND_ALT\\n\\t\\treturn x_L, y_L, z\",\n \"def nancay():\\n return coord.EarthLocation(lat=47.376511*u.deg, lon=2.1924002*u.deg)\",\n \"def fn2lonlat(filename):\\n tokens = filename.split(\\\"/\\\")[-1].rsplit(\\\".\\\", 1)[0].split(\\\"x\\\")\\n return [0 - float(tokens[0]), float(tokens[1])]\",\n \"def transform_coordinates(coords):\\n # WGS 84 reference coordinate system parameters\\n A = 6378.137 # major axis [km]\\n E2 = 6.69437999014e-3 # eccentricity squared\\n\\n coords = prepare_coords(coords)\\n\\n # convert to radiants\\n lat_rad = np.radians(coords[:, 0])\\n lon_rad = np.radians(coords[:, 1])\\n\\n # convert to cartesian coordinates\\n r_n = A / (np.sqrt(1 - E2 * (np.sin(lat_rad) ** 2)))\\n x = r_n * np.cos(lat_rad) * np.cos(lon_rad)\\n y = r_n * np.cos(lat_rad) * np.sin(lon_rad)\\n z = r_n * (1 - E2) * np.sin(lat_rad)\\n\\n return np.column_stack((x, y, z))\",\n \"def lnglat_to_meters(longitude, latitude):\\n if isinstance(longitude, (list, tuple)):\\n longitude = numpy.array(longitude)\\n if isinstance(latitude, (list, tuple)):\\n latitude = numpy.array(latitude)\\n\\n origin_shift = numpy.pi * 6378137\\n easting = longitude * origin_shift / 180.0\\n northing = numpy.log(numpy.tan((90 + latitude) * numpy.pi / 360.0)) * origin_shift / numpy.pi\\n return (easting, northing)\",\n \"def get_lonlat(self, row, col):\\n\\n if self.ndim != 2:\\n raise DimensionError(('operation undefined '\\n 'for %sD geometry ') % self.ndim)\\n elif self.lons is None or self.lats is None:\\n raise ValueError('lon/lat values are not defined')\\n return self.lons[row, col], self.lats[row, col]\",\n \"def _fixupPosition(self, position):\\n if \\\"latitudeI\\\" in position:\\n position[\\\"latitude\\\"] = position[\\\"latitudeI\\\"] * 1e-7\\n if \\\"longitudeI\\\" in position:\\n position[\\\"longitude\\\"] = position[\\\"longitudeI\\\"] * 1e-7\",\n \"def get_latlon_point(self, row, col):\\n p1 = Proj(self.src.crs)\\n window = rasterio.windows.Window(col, row, 1, 1)\\n trnsfrm = self.src.window_transform(window)\\n T1 = trnsfrm * Affine.translation(0.5, 0.5)\\n p2 = Proj(proj='latlong', datum='WGS84')\\n x, y = self.src.xy(row, col)\\n lon, lat = transform(p1, p2, x, y)\\n return lat, lon\",\n \"def CreateTargetGeoMap(latS, latN, lonW, lonE, latlen, lonlen):\\n\\n lat_grid = np.linspace(latS, latN, latlen)\\n lon_grid = np.linspace(lonW, lonE, lonlen)\\n\\n return lat_grid,lon_grid\",\n \"def get_rain_grid_coords(directory=\\\"rain_grid_coordinates\\\"):\\n lon, lat = [pd.DataFrame([re.findall('..\\\\......', row[0]) for idx,\\n row in pd.read_table(sys.path[0]+f\\\"/{directory}/{file}_center.txt\\\",\\n header=None).iterrows()]) for file in ['lambda', 'phi']]\\n coords = pd.DataFrame(columns={\\\"LAT\\\", \\\"LON\\\"})\\n coords[\\\"LAT\\\"] = np.round(pd.Series([item for sublist in lat.values.tolist() for item in sublist]).astype(float), 4)\\n coords[\\\"LON\\\"] = np.round(pd.Series([item for sublist in lon.values.tolist() for item in sublist]).astype(float), 4)\\n coords[\\\"CELL_ID\\\"] = coords.index.values\\n return coords\",\n \"def test_lat_lon_to_tile(self):\\n\\n lat = 48\\n lon = 37.7\\n z = 10\\n\\n tile_calculated = geomath.lat_lon_to_tile(lat,lon,z)\\n tile_known = (619,355,10)\\n\\n # make sure the tiles are the same\\n self.assertEqual(tile_calculated,tile_known)\",\n \"def cartesian2Geo(julian_date, x, y, z):\\n\\n\\n # Calculate LLA\\n lat, r_LST, ele = ecef2LatLonAlt(x, y, z)\\n\\n # Calculate proper longitude from the given JD\\n lon, _ = LST2LongitudeEast(julian_date, np.degrees(r_LST))\\n\\n # Convert longitude to radians\\n lon = np.radians(lon)\\n\\n\\n return np.degrees(lat), np.degrees(lon), ele\",\n \"def coordinates_to_locations(coordinates):\\n np_coords = np.array(coordinates)\\n longs, lats = transform(Proj(init=EPSG_IN), Proj(init=EPSG_OUT), np_coords[:, 0], np_coords[:, 1])\\n length = len(lats)\\n result = []\\n for i in range(length):\\n loc = Location(lats[i], longs[i])\\n raw_location = extract_raw_simple_coordinates(coordinates[i])\\n loc.set_raw_coordinates_simplified(raw_location[0],raw_location[1])\\n result.append(loc)\\n\\n return result\",\n \"def pixelloc_to_geoloc(row, col, loff, coff):\\n row = np.atleast_1d(row)\\n col = np.atleast_1d(col)\\n\\n assert row.shape == col.shape\\n\\n lat, lon = _nav.pixelloc_to_geoloc(row, col, loff, coff)\\n\\n if lat.size == lon.size == 1:\\n # Return scalars\\n return lat[0], lon[0]\\n else:\\n return lat, lon\",\n \"def point2wgs84_9603(self, datum):\\n \\\"\\\"\\\"\\n h is the height above the ellipsoid. This is the height value that is \\n delivered by GPS satellite observations but is not the gravity-related height \\n value which is normally used for national mapping and levelling operations. The\\n gravity-related height (H) is usually the height above mean sea level or an \\n alternative level reference for the country. If one starts with a gravity-related \\n height H, it will be necessary to convert it to an ellipsoid height (h) before \\n using the above transformation formulas. See section 4.11.1. For the WGS 84 \\n ellipsoid the difference between ellipsoid and mean sea level can vary between \\n values of -100m in the Sri Lanka area to +80m in the North Atlantic.)\\n \\\"\\\"\\\"\\n h=0\\n # a is the semi-major axis of the ellipsoid of the given datum.\\n a = datum.axis\\n\\n # f is the flattening of the ellipsoid of the given datum \\n # (get_flattening actually returns the inverse flattening).\\n f = 1.0/datum.flattening\\n \\n # dx, dy, dz are the x, y, z offset parameters for the given datum transformation\\n # to WGS84\\n dx = datum.dx\\n dy = datum.dy\\n dz = datum.dz\\n \\n # latr, lngr are the latitude and longitude in radians\\n latr = math.radians(self.lat)\\n lngr = math.radians(self.lng)\\n\\n # e is the eccentricity of the ellipsoid\\n e_squared = f*(2-f)\\n\\n # nu is the prime vertical radius of curvature at latr\\n nu = a/math.pow((1-e_squared*sqr(math.sin(latr))),0.5)\\n\\n X = (nu+h)*math.cos(latr)*math.cos(vlambda)\\n Y = (nu+h)*math.cos(latr)*math.sin(vlambda)\\n Z = ((1 - math.pow(e,2))*nu + h)*math.sin(phi)\\n\\n Xwgs84 = X+dx\\n Ywgs84 = Y+dy\\n Zwgs84 = Z+dz\\n\\n epsilon = e_squared/(1-e_squared)\\n b = a*(1-f)\\n p = math.pow(sqr(Xwgs84)+sqr(Ywgs84),0.5)\\n q = math.atan2((Zwgs84*a),(p*b))\\n\\n latrwgs84 = math.atan2( (Zwgs84 + epsilon*b*math.pow(math.sin(q)),3)), \\\\\\n (p - e_squared*a*math.pow(math.cos(q),3) )\\n lngrwgs84 = math.atan2(Ywgs84, Xwgs84)\\n hwgs84 = (p/math.cos(latrwgs84))-nu\\n newlng = lng180(math.degrees(lngrwgs84))\\n newlat = math.degrees(latrwgs84)\\n return Point(float(truncate(newlng,DEGREE_DIGITS)), float(truncate(newlat,DEGREE_DIGITS)))\",\n \"def project(self, (lng, lat)):\\n x = lng * DEG_TO_RAD\\n lat = max(min(MAX_LATITUDE, lat), -MAX_LATITUDE)\\n y = lat * DEG_TO_RAD\\n y = math.log(math.tan((math.pi / 4) + (y / 2)))\\n return (x*EARTH_RADIUS, y*EARTH_RADIUS)\",\n \"def coords_trans(map, coords, up_lift=True):\\n if len(coords) < 3:\\n coords = np.append(coords, [0])\\n pass\\n\\n exact_location = carla.Location(x=coords[0], y=coords[1], z=coords[2])\\n waypoint = map.get_waypoint(exact_location) # carla.waypoint\\n road_center_location = waypoint.transform.location\\n\\n if up_lift == True:\\n exact_location.z += 1.0\\n road_center_location.z += 1.0\\n\\n return exact_location, waypoint, road_center_location\",\n \"def cr2lonlat_for_geotif(path):\\n old_cs, new_cs, gta, local_vars = _create_xform(path)\\n transform = osr.CoordinateTransformation(old_cs, new_cs)\\n\\n def composite(c, r):\\n \\\"\\\"\\\"xform from (c, r) to (lon, lat)\\\"\\\"\\\"\\n x, y = gta * (c, r)\\n lat, lon = transform.TransformPoint(x, y)[:2]\\n if not -90 <= lat <= 90:\\n raise ValueError('illegal lat value, did you switch coordinates')\\n return lon, lat\\n \\n return composite\",\n \"def _extract_location_xyz(self, log):\\n\\n if \\\"location\\\" in log:\\n x = log[\\\"location\\\"][\\\"latitude\\\"]\\n y = log[\\\"location\\\"][\\\"longitude\\\"]\\n z = log[\\\"location\\\"][\\\"altitude\\\"]\\n else:\\n self.logger.debug(\\\"NaN case\\\")\\n x = \\\"NaN\\\" # matlab Nan?\\n y = \\\"NaN\\\"\\n z = \\\"NaN\\\"\\n pass\\n return str(x) + \\\",\\\" + str(y) + \\\",\\\" + str(z)\",\n \"def _get_site_pos(dset):\\n # TODO hjegei: Workaround -> better would it be if Position object can handle LLH as input format!!!\\n x, y, z = gnss.llh2xyz(np.deg2rad(dset.lat), np.deg2rad(dset.lon), dset.height)\\n return np.stack((x, y, z), axis=1)\",\n \"def transform_from_latlon(lat, lon):\\n from affine import Affine\\n lat = np.asarray(lat)\\n lon = np.asarray(lon)\\n trans = Affine.translation(lon[0], lat[0])\\n scale = Affine.scale(lon[1] - lon[0], lat[1] - lat[0])\\n return trans * scale\",\n \"def get_lon_lat(df, nombre, ruido=False):\\n from pyproj import transform\\n\\n lat, lon = [], []\\n for index, row in tqdm(df.iterrows()):\\n lati, loni = [], []\\n try:\\n for pt in list(row[\\\"geometry\\\"].exterior.coords):\\n lati.append(pt[1])\\n loni.append(pt[0])\\n except Exception as e:\\n try:\\n row.geometry = row.geometry.map(lambda x: x.convex_hull)\\n for pt in list(row[\\\"geometry\\\"].exterior.coords):\\n lati.append(pt[1])\\n loni.append(pt[0])\\n except Exception as e:\\n try:\\n lati.append(df.iloc[index].geometry.centroid.y)\\n loni.append(df.iloc[index].geometry.centroid.x)\\n except Exception as e:\\n if not ruido:\\n continue\\n else:\\n print(e)\\n print(df.iloc[index].geometry.centroid)\\n lat.append(sum(lati) / len(lati))\\n lon.append(sum(loni) / len(loni))\\n latnew, lonnew = [], []\\n for la, lo in zip(lat, lon):\\n o, a = transform(inProj, outProj, lo, la)\\n if o != float(\\\"inf\\\") and a != float(\\\"inf\\\"):\\n latnew.append(a)\\n lonnew.append(o)\\n return {nombre: {\\\"lon\\\": lonnew, \\\"lat\\\": latnew}}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6428161","0.63630664","0.63455874","0.6290571","0.62546146","0.62182456","0.6173703","0.616266","0.61362135","0.6058876","0.60567707","0.6025662","0.5944653","0.5914385","0.5914179","0.5903728","0.5840953","0.5805078","0.57799006","0.5759482","0.5756983","0.57522357","0.5744789","0.5735501","0.57275176","0.5725048","0.57149935","0.57080173","0.5703541","0.5695174","0.56647784","0.5645471","0.564286","0.5637938","0.5632647","0.5626208","0.56168437","0.56044114","0.5603518","0.5594503","0.5583486","0.55806255","0.557618","0.55756736","0.55671084","0.5556054","0.5546488","0.5537605","0.55163","0.5513004","0.55056596","0.5501348","0.5489229","0.5477959","0.54767114","0.5476362","0.546256","0.5451617","0.5450375","0.54466677","0.54454416","0.5443531","0.5434458","0.5425091","0.54225725","0.5419113","0.5418988","0.5407333","0.5389768","0.5387131","0.5383527","0.53759885","0.53687567","0.5368501","0.53657705","0.5356349","0.5349488","0.5348877","0.5343891","0.53345275","0.53267634","0.5321849","0.5319546","0.53193426","0.53106993","0.52949244","0.5293606","0.5292076","0.52917945","0.5277626","0.52707195","0.5269846","0.5268678","0.52681744","0.5267684","0.5261063","0.52591974","0.52544034","0.52442634","0.52431256"],"string":"[\n \"0.6428161\",\n \"0.63630664\",\n \"0.63455874\",\n \"0.6290571\",\n \"0.62546146\",\n \"0.62182456\",\n \"0.6173703\",\n \"0.616266\",\n \"0.61362135\",\n \"0.6058876\",\n \"0.60567707\",\n \"0.6025662\",\n \"0.5944653\",\n \"0.5914385\",\n \"0.5914179\",\n \"0.5903728\",\n \"0.5840953\",\n \"0.5805078\",\n \"0.57799006\",\n \"0.5759482\",\n \"0.5756983\",\n \"0.57522357\",\n \"0.5744789\",\n \"0.5735501\",\n \"0.57275176\",\n \"0.5725048\",\n \"0.57149935\",\n \"0.57080173\",\n \"0.5703541\",\n \"0.5695174\",\n \"0.56647784\",\n \"0.5645471\",\n \"0.564286\",\n \"0.5637938\",\n \"0.5632647\",\n \"0.5626208\",\n \"0.56168437\",\n \"0.56044114\",\n \"0.5603518\",\n \"0.5594503\",\n \"0.5583486\",\n \"0.55806255\",\n \"0.557618\",\n \"0.55756736\",\n \"0.55671084\",\n \"0.5556054\",\n \"0.5546488\",\n \"0.5537605\",\n \"0.55163\",\n \"0.5513004\",\n \"0.55056596\",\n \"0.5501348\",\n \"0.5489229\",\n \"0.5477959\",\n \"0.54767114\",\n \"0.5476362\",\n \"0.546256\",\n \"0.5451617\",\n \"0.5450375\",\n \"0.54466677\",\n \"0.54454416\",\n \"0.5443531\",\n \"0.5434458\",\n \"0.5425091\",\n \"0.54225725\",\n \"0.5419113\",\n \"0.5418988\",\n \"0.5407333\",\n \"0.5389768\",\n \"0.5387131\",\n \"0.5383527\",\n \"0.53759885\",\n \"0.53687567\",\n \"0.5368501\",\n \"0.53657705\",\n \"0.5356349\",\n \"0.5349488\",\n \"0.5348877\",\n \"0.5343891\",\n \"0.53345275\",\n \"0.53267634\",\n \"0.5321849\",\n \"0.5319546\",\n \"0.53193426\",\n \"0.53106993\",\n \"0.52949244\",\n \"0.5293606\",\n \"0.5292076\",\n \"0.52917945\",\n \"0.5277626\",\n \"0.52707195\",\n \"0.5269846\",\n \"0.5268678\",\n \"0.52681744\",\n \"0.5267684\",\n \"0.5261063\",\n \"0.52591974\",\n \"0.52544034\",\n \"0.52442634\",\n \"0.52431256\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5855182"},"document_rank":{"kind":"string","value":"16"}}},{"rowIdx":5488,"cells":{"query":{"kind":"string","value":"Adds a shortcut between input and residual block and merges them with \"sum\""},"document":{"kind":"string","value":"def _shortcut(input, residual):\n # Expand channels of shortcut to match residual.\n # Stride appropriately to match residual (width, height)\n # Should be int if network architecture is correctly configured.\n input_shape = K.int_shape(input)\n residual_shape = K.int_shape(residual)\n stride_width = int(round(input_shape[2] / residual_shape[2]))\n stride_height = int(round(input_shape[3] / residual_shape[3]))\n stride_depth = int(round(input_shape[4] / residual_shape[4]))\n equal_channels = input_shape[1] == residual_shape[1]\n\n shortcut = input\n # 1 X 1 conv if shape is different. Else identity.\n if stride_width > 1 or stride_height > 1 or stride_depth > 1 or not equal_channels:\n shortcut = Convolution3D(residual_shape[1], 1, 1, 1, subsample=(stride_width, stride_height, stride_depth), border_mode = \"valid\", init=\"he_normal\",W_regularizer=l2(0.0001))(input)\n\n return shortcut"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def residual_block(layer, filters):\n shortcut = layer\n layer = Conv2D(filters=filters, kernel_size=(3, 3),\n strides=(1, 1), padding=\"same\")(layer)\n layer = LeakyReLU(alpha=LEAKY_RELU_ALPHA)(layer)\n layer = Conv2D(filters=filters, kernel_size=(3, 3),\n strides=(1, 1), padding=\"same\")(layer)\n\n layer = Add()([layer, shortcut])\n layer = LeakyReLU(alpha=LEAKY_RELU_ALPHA)(layer)\n return layer","def _output_add(block_x, orig_x):\n stride = orig_x.shape[-2] // block_x.shape[-2]\n strides = (stride, stride)\n if block_x.shape[-1] != orig_x.shape[-1]:\n orig_x = nn.avg_pool(orig_x, strides, strides)\n channels_to_add = block_x.shape[-1] - orig_x.shape[-1]\n orig_x = jnp.pad(orig_x, [(0, 0), (0, 0), (0, 0), (0, channels_to_add)])\n return block_x + orig_x","def residual_block(layer_input, filters):\n d = Conv2D(filters, kernel_size=3, strides=1, padding='same')(layer_input)\n d = Activation('relu')(d)\n d = BatchNormalization(momentum=0.8)(d)\n d = Conv2D(filters, kernel_size=3, strides=1, padding='same')(d)\n d = BatchNormalization(momentum=0.8)(d)\n d = Add()([d, layer_input])\n return d","def _shortcut(self, input, residual):\n # Expand channels of shortcut to match residual.\n # Stride appropriately to match residual (width, height)\n # Should be int if network architecture is correctly configured.\n input_shape = K.int_shape(input)\n residual_shape = K.int_shape(residual)\n stride_width = int(round(input_shape[1] / residual_shape[1]))\n stride_height = int(round(input_shape[2] / residual_shape[2]))\n equal_channels = input_shape[3] == residual_shape[3]\n \n shortcut = input\n # 1 X 1 conv if shape is different. Else identity.\n if stride_width > 1 or stride_height > 1 or not equal_channels:\n shortcut = Conv2D(filters=residual_shape[3],\n kernel_size=(1, 1),\n strides=(stride_width, stride_height),\n padding=\"valid\",\n kernel_initializer=\"he_normal\",\n kernel_regularizer=l2(0.0001))(input)\n \n return add([shortcut, residual])","def residual_block(layer_input, filters):\n d = Conv2D(filters, kernel_size=3, strides=1, padding='same')(layer_input)\n d = Activation('relu')(d)\n d = BatchNormalization(momentum=0.8)(d)\n d = Conv2D(filters, kernel_size=3, strides=1, padding='same')(d)\n d = BatchNormalization(momentum=0.8)(d)\n d = Add()([d, layer_input])\n return d","def resBlock(_input, _stage, _block):\n nFilters = NBASEFILTERS * (2 ** _stage)\n if _stage > 0 and _block == 0: # downsample\n strides = 2\n else:\n strides = 1\n\n # 2 conv\n output = resLayer(_input, nFilters, _stride=strides)\n output = resLayer(output, nFilters, _acti=False)\n\n # shortcut\n if _stage > 0 and _block == 0: # projection\n # Caution: here the Keras document implementation differs from \n # the one mentioned before (in kernel size), and we use Keras's.\n _input = resLayer(_input, nFilters, _kernelSize=1,\n _stride=strides, _norm=False, _acti=False)\n\n output = keras.layers.add([_input, output])\n output = Activation('relu')(output)\n return output","def reduce_recipe(self):\n\n self.recipe.reduce(self.crafting, self.crafting_stride)","def residual_block(net, style_weights, filters, kernel_size, strides,\n depthwise_separable_conv):\n tmp = conv_block(net,\n style_weights,\n filters=filters,\n kernel_size=kernel_size,\n strides=strides,\n activation=\"relu\",\n depthwise_separable_conv=depthwise_separable_conv)\n tmp = conv_block(tmp,\n style_weights,\n filters=filters,\n kernel_size=kernel_size,\n strides=strides,\n activation=None,\n depthwise_separable_conv=depthwise_separable_conv)\n return Add()([net, tmp])","def _shortcut(input, residual):\r\n # Expand channels of shortcut to match residual.\r\n # Stride appropriately to match residual (width, height)\r\n # Should be int if network architecture is correctly configured.\r\n input_shape = K.int_shape(input)\r\n residual_shape = K.int_shape(residual)\r\n stride_width = int(round(input_shape[1] / residual_shape[1]))\r\n stride_height = int(round(input_shape[2] / residual_shape[2]))\r\n equal_channels = input_shape[3] == residual_shape[3]\r\n\r\n shortcut = input\r\n # 1 X 1 conv if shape is different. Else identity.\r\n if stride_width > 1 or stride_height > 1 or not equal_channels:\r\n shortcut = Conv2D(filters=residual_shape[3],\r\n kernel_size=(1, 1),\r\n strides=(stride_width, stride_height),\r\n padding=\"valid\",\r\n kernel_initializer=\"he_normal\",\r\n kernel_regularizer=l2(0.0001))(input)\r\n\r\n return add([shortcut, residual])","def _shortcut(input, residual):\n # Expand channels of shortcut to match residual.\n # Stride appropriately to match residual (width, height)\n # Should be int if network architecture is correctly configured.\n input_shape = K.int_shape(input)\n residual_shape = K.int_shape(residual)\n stride_width = int(round(input_shape[1] / residual_shape[1]))\n stride_height = int(round(input_shape[2] / residual_shape[2]))\n equal_channels = input_shape[3] == residual_shape[3]\n\n shortcut = input\n # 1 X 1 conv if shape is different. Else identity.\n if stride_width > 1 or stride_height > 1 or not equal_channels:\n shortcut = Conv2D(filters=residual_shape[3],\n kernel_size=(1, 1),\n strides=(stride_width, stride_height),\n padding=\"valid\",\n kernel_initializer=\"he_normal\",\n kernel_regularizer=l2(0.0001))(input)\n\n return add([shortcut, residual])","def residual_block(self, x, stride, out_filter, activate_before_residual=False, padding_in='SAME'):\n with tf.name_scope(\"res_block\" + str(self._count_conv)):\n in_filter = x.get_shape().as_list()[-1]\n if activate_before_residual:\n with tf.variable_scope('shared_activation'):\n x = self.bn(x)\n x = self.activation(x)\n orig_x = x\n else:\n with tf.variable_scope('residual_only_activation'):\n orig_x = x\n x = self.bn(x)\n x = self.activation(x)\n\n with tf.variable_scope('sub1'):\n x = self.conv(x, 3, stride, out_filter, padding_in=padding_in)\n\n with tf.variable_scope('sub2'):\n x = self.bn(x)\n x = self.activation(x)\n x = self.conv(x, 3, 1, out_filter, padding_in=padding_in)\n\n with tf.variable_scope('sub_add'):\n if in_filter != out_filter:\n orig_x = tf.nn.avg_pool(orig_x, [1, stride, stride, 1], [1, stride, stride, 1], 'VALID')\n\n orig_x = tf.pad(\n orig_x, [[0, 0], [0, 0], [0, 0],\n [(out_filter - in_filter) // 2, (out_filter - in_filter) // 2]])\n\n x += orig_x\n\n return x","def residual_block(blockInput, nf, strides=1, batch_activate=False):\n x = BatchActivate(blockInput)\n x = res_conv_block(x, nf)\n x = res_conv_block(x, nf, activation=False)\n x = Add()([x, blockInput])\n if batch_activate:\n x = BatchActivate(x)\n return x","def residual_block(x, filters: int, a=0.01, dr=0.05, depth=2):\n y = conv_block(x, filters, a, dr)\n for _ in range(depth - 1):\n y = conv_block(y, filters, a, dr)\n y = Add()([x, y])\n\n return y","def with_sum_sum_reduction(self):\n return self.with_reduction(lambda x: x.sum())","def _shortcut(input, residual):\n # Expand channels of shortcut to match residual.\n # Stride appropriately to match residual (width, height)\n # Should be int if network architecture is correctly configured.\n input_shape = K.int_shape(input)\n residual_shape = K.int_shape(residual)\n stride_width = int(round(input_shape[ROW_AXIS] / residual_shape[ROW_AXIS]))\n stride_height = int(round(input_shape[COL_AXIS] / residual_shape[COL_AXIS]))\n equal_channels = input_shape[CHANNEL_AXIS] == residual_shape[CHANNEL_AXIS]\n\n shortcut = input\n # 1 X 1 conv if shape is different. Else identity.\n if stride_width > 1 or stride_height > 1 or not equal_channels:\n shortcut = Conv2D(filters=residual_shape[CHANNEL_AXIS],\n kernel_size=(1, 1),\n strides=(stride_width, stride_height),\n padding=\"valid\",\n kernel_initializer=\"he_normal\",\n kernel_regularizer=l2(0.0001))(input)\n\n return add([shortcut, residual])","def residual_block(x,index,step=\"encoding\"):\r\n if step != \"encoding\":\r\n index = \"decode_{}\".format(index)\r\n \r\n x_new = kl.Conv2D(128,(3,3),padding=\"same\",activation=\"selu\",kernel_initializer=initializer,\r\n name=\"conv1_res_{}\".format(index))(x)\r\n \r\n x_new = kl.Conv2D(128,(3,3),padding=\"same\",kernel_initializer=initializer,\r\n name=\"conv2_res_{}\".format(index))(x_new)\r\n \r\n x_out = kl.Add()([x,x_new])\r\n x_out = kl.Activation(\"relu\")(x_out)\r\n return(x_out)","def _residual_block(input, id_block, conv_block, mid_f, output_f, repetitions, stage, is_first_layer=False):\n\n for i in range(repetitions):\n if i == 0 and is_first_layer is True:\n input = conv_block(mid_f, output_f, stage, i, input, stride=(1, 1))\n elif i == 0 and is_first_layer is False:\n input = conv_block(mid_f, output_f, stage, i, input)\n else:\n input = id_block(mid_f, output_f, stage, i, input)\n return input","def darknet53_residualBlock(inputs, filters, training, data_format, strides):\n shortcuts = inputs\n\n inputs = conv2D_fiexed_padding(inputs,\n filters=filters,\n kernel_size=1,\n strides=strides,\n data_format=data_format)\n inputs = batchNorm(inputs, training=training, data_format=data_format)\n inputs = tf.nn.leaky_relu(inputs, alpha=_LEAKY_RELU)\n\n inputs = conv2D_fiexed_padding(inputs,\n filters=2*filters,\n kernel_size=3,\n strides=strides,\n data_format=data_format)\n inputs = batchNorm(inputs, training, data_format)\n inputs = tf.nn.leaky_relu(inputs, alpha=_LEAKY_RELU)\n\n inputs += shortcuts\n\n return inputs\n pass","def _shortcut(input, residual):\n # Expand channels of shortcut to match residual.\n # Stride appropriately to match residual (width, height)\n # Should be int if network architecture is correctly configured.\n input_shape = K.int_shape(input)\n residual_shape = K.int_shape(residual)\n stride_width = int(round(input_shape[ROW_AXIS] / residual_shape[ROW_AXIS]))\n stride_height = int(round(input_shape[COL_AXIS] / residual_shape[COL_AXIS]))\n stride_depth = int(round(input_shape[DEP_AXIS] / residual_shape[DEP_AXIS]))\n equal_channels = input_shape[CHANNEL_AXIS] == residual_shape[CHANNEL_AXIS]\n\n shortcut = input\n # 1 X 1 conv if shape is different. Else identity.\n if stride_width > 1 or stride_height > 1 or stride_depth > 1 or not equal_channels:\n shortcut = Conv3D(filters=residual_shape[CHANNEL_AXIS],\n kernel_size=(1, 1,1),\n strides=(stride_width, stride_height,stride_depth),\n padding=\"valid\",\n kernel_initializer=\"he_normal\",\n kernel_regularizer=l2(0.0001))(input)\n\n return add([shortcut, residual])","def sum_row(input, output, i):\r\n sum_ = input[i, :].sum()\r\n print(\"[Worker %d] Sum for row %d is %f\" % (os.getpid(), i, sum_))\r\n output[i] = sum_","def convolutional_block(X, f, filters, stage, block, s = 2):\n \n # defining name basis\n conv_name_base = 'res' + str(stage) + block + '_branch'\n bn_name_base = 'bn' + str(stage) + block + '_branch'\n \n # Retrieve Filters\n F1, F2, F3 = filters\n \n # Save the input value\n X_shortcut = X\n\n\n ##### MAIN PATH #####\n # First component of main path \n X = Conv2D(F1, (1, 1), strides = (s,s), name = conv_name_base + '2a',padding = 'valid', kernel_initializer = glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n X = Activation('relu')(X)\n\n # Second component of main path\n X = Conv2D(F2, (f, f), strides = (1,1), name = conv_name_base + '2b', padding = 'same', kernel_initializer = glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\n X = Activation('relu')(X)\n\n # Third component of main path\n X = Conv2D(F3, (1, 1), strides = (1,1), name = conv_name_base + '2c', padding = 'valid', kernel_initializer = glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\n\n ##### SHORTCUT PATH ####\n X_shortcut = Conv2D(F3, (1, 1), strides = (s,s), name = conv_name_base + '1', padding = 'valid', kernel_initializer = glorot_uniform(seed=0),kernel_regularizer = regularizers.l1_l2(l1= 0.01,l2 = 0.1))(X_shortcut)\n X_shortcut = BatchNormalization(axis = 3, name = bn_name_base + '1')(X_shortcut)\n\n # Final step: Add shortcut value to main path, and pass it through a RELU activation\n X = Add()([X,X_shortcut])\n X = Activation('relu')(X)\n \n return X","def _shortcut(input, residual, name):\n # Expand channels of shortcut to match residual.\n # Stride appropriately to match residual (width, height)\n # Should be int if network architecture is correctly configured.\n input_shape = K.int_shape(input)\n residual_shape = K.int_shape(residual)\n stride_width = int(round(input_shape[ROW_AXIS] / residual_shape[ROW_AXIS]))\n stride_height = int(round(input_shape[COL_AXIS] / residual_shape[COL_AXIS]))\n equal_channels = input_shape[CHANNEL_AXIS] == residual_shape[CHANNEL_AXIS]\n\n shortcut = input\n # 1 X 1 conv if shape is different. Else identity.\n if stride_width > 1 or stride_height > 1 or not equal_channels:\n shortcut = Conv2D(filters=residual_shape[CHANNEL_AXIS],\n kernel_size=(1, 1),\n strides=(stride_width, stride_height),\n padding=\"valid\",\n kernel_initializer=\"he_normal\",\n kernel_regularizer=l2(0.0001),\n\t\t name = name)(input)\n\n return add([shortcut, residual])","def rrdb(x):\n h = dense_block(x)\n h = dense_block(h)\n h = dense_block(h)\n h = tf.keras.layers.Lambda(lambda x: x * 0.2)(h)\n out = tf.keras.layers.Add()([h, x])\n return out","def __radd__(self,that):\n return self.__opExpand2(that,np.add)","def building_block_v2(self, inputs, block_params, training, projection_shortcut,\n half_layer=None, initial_layer=False, no_prenorm=False):\n filters = block_params['filters']\n kernels = block_params['kernels']\n strides = block_params['strides']\n pad_stride1 = block_params['pad_stride1']\n\n shortcut = inputs\n if (not initial_layer) and (not no_prenorm):\n inputs = self.batch_norm_act(inputs, training)\n if projection_shortcut == 'FirstResUnit':\n # For pointnet, projection shortcut is not needed at the First ResUnit.\n # However, BN and Activation is still required at the First ResUnit for\n # pre-activation.\n shortcut = inputs\n projection_shortcut = None\n if self.IsShowModel: self.log(\n 'shortcut after activation identity for pointnet first res unit')\n if half_layer:\n projection_shortcut = None\n\n # The projection shortcut should come after the first batch norm and ReLU\n # since it performs a 1x1 convolution.\n if projection_shortcut is not None:\n shortcut = projection_shortcut(inputs)\n\n with tf.variable_scope('c0'):\n inputs = self.conv1d2d3d(inputs, filters, kernels, strides, pad_stride1)\n self.log_tensor_c(inputs, kernels, strides, pad_stride1,\n tf.get_variable_scope().name)\n if half_layer: return inputs\n inputs = self.batch_norm_act(inputs, training)\n\n with tf.variable_scope('c1'):\n inputs = self.conv1d2d3d(inputs, filters, kernels, 1, 's')\n self.log_tensor_c(inputs, kernels, 1, 's',\n tf.get_variable_scope().name)\n\n if self.residual and (not initial_layer):\n assert inputs.shape == shortcut.shape\n if self.IsShowModel: self.log('Add shortcut*%0.1f'%(self.res_scale))\n return inputs * self.res_scale + shortcut\n else:\n return inputs","def convolutional_block(X, f, filters, stage, block, s = 2):\n \n # Defines name basis.\n conv_name_base = 'res' + str(stage) + block + '_branch'\n bn_name_base = 'bn' + str(stage) + block + '_branch'\n \n # Retrieves Filters.\n F1, F2, F3 = filters\n \n # Saves the input value.\n X_shortcut = X\n\n\n ##### MAIN PATH #####\n # First component of main path \n X = Conv2D(F1, (1, 1), strides = (s,s), padding = 'valid',name = conv_name_base + '2a', kernel_initializer = glorot_uniform())(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n X = Activation('relu')(X)\n\n # Second component of main path.\n X = Conv2D(F2, (f, f), strides = (1,1), padding = 'same',name = conv_name_base + '2b', kernel_initializer = glorot_uniform())(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\n X = Activation('relu')(X)\n\n # Third component of main path.\n X = Conv2D(F3, (1, 1), strides = (1,1), padding = 'valid',name = conv_name_base + '2c', kernel_initializer = glorot_uniform())(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\n \n ##### SHORTCUT PATH ####\n X_shortcut= Conv2D(F3, (1, 1), strides = (s,s), padding = 'valid',name = conv_name_base + '1', kernel_initializer = glorot_uniform())(X_shortcut)\n X_shortcut = BatchNormalization(axis = 3, name = bn_name_base + '1')(X_shortcut)\n \n # Final step: Adds shortcut value to main path, and pass it through a RELU activation.\n X = Add()([X, X_shortcut])\n X = Activation('relu')(X)\n\n return X","def update_weights_sum(self):\n vals = self.nn.get_param_values()\n # only use the last layer for summation (w, b)\n self.w_sum = np.sum(vals[-2]) + np.sum(vals[-1])","def sum_value(self, lv, rv):","def convolutional_block(X, filters, stage, block):\n \n # defining name basis\n conv_name_base = 'res' + str(stage) + block + '_branch'\n bn_name_base = 'bn' + str(stage) + block + '_branch'\n \n # Retrieve Filters\n F1, F2 = filters\n \n # Save the input value\n X_shortcut = X\n\n ##### MAIN PATH #####\n # First component of main path \n X = Conv2D(F1, (3, 3), strides = (2, 2), padding = 'same', name = conv_name_base + '2a', kernel_initializer = glorot_uniform())(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n X = Activation('relu')(X)\n\n # Second component of main path\n X = Conv2D(F2, (3, 3), strides = (1, 1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform())(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\n\n ##### SHORTCUT PATH ####\n X_shortcut = Conv2D(F2, (3, 3), strides = (2, 2), padding = 'same', name = conv_name_base + '1', kernel_initializer = glorot_uniform())(X_shortcut)\n X_shortcut = BatchNormalization(axis = 3, name = bn_name_base + '1')(X_shortcut)\n\n # Final step: Add shortcut value to main path, and pass it through a RELU activation (≈2 lines)\n X = Add()([X, X_shortcut])\n X = Activation('relu')(X)\n \n return X","def inline_sum(summands, seed):\n for r in summands:\n seed += r\n return seed","def inline_sum(summands, seed):\n for r in summands:\n seed += r\n return seed","def _shortcut(input_feature, residual, conv_name_base=None, bn_name_base=None):\n # Expand channels of shortcut to match residual.\n # Stride appropriately to match residual (width, height)\n # Should be int if network architecture is correctly configured.\n input_shape = K.int_shape(input_feature)\n residual_shape = K.int_shape(residual)\n stride_width = int(round(input_shape[ROW_AXIS] / residual_shape[ROW_AXIS]))\n stride_height = int(round(input_shape[COL_AXIS] / residual_shape[COL_AXIS]))\n equal_channels = input_shape[CHANNEL_AXIS] == residual_shape[CHANNEL_AXIS]\n\n shortcut = input_feature\n # 1 X 1 conv if shape is different. Else identity.\n if stride_width > 1 or stride_height > 1 or not equal_channels:\n # print('reshaping via a convolution...')\n shortcut = Conv2D(\n filters=residual_shape[CHANNEL_AXIS],\n kernel_size=(1, 1),\n strides=(stride_width, stride_height),\n padding=\"valid\",\n kernel_initializer=\"he_normal\",\n kernel_regularizer=l2(0.0001),\n name=conv_name_base,\n )(input_feature)\n shortcut = BatchNormalization(axis=CHANNEL_AXIS, name=bn_name_base)(shortcut)\n\n return add([shortcut, residual])","def convolutional_block(X, f, filters, stage, block, s=2):\n\n # defining name basis\n conv_name_base = 'res' + str(stage) + block + '_branch'\n bn_name_base = 'bn' + str(stage) + block + '_branch'\n\n # Retrieve Filters\n F1, F2, F3 = filters\n\n # Save the input value.\n X_shortcut = X\n\n # First component of main path\n X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (s,s), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n X = Activation('relu')(X)\n\n # Second component of main path\n X = Conv2D(filters = F2, kernel_size= (f,f),strides= (1,1), padding= 'same' , name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis=3, name=bn_name_base + '2b')(X)\n X = Activation('relu')(X)\n\n # Third component of main path\n X = Conv2D(filters = F3, kernel_size= (1,1),strides= (1,1), padding= 'valid' , name = conv_name_base + '2c', kernel_initializer = glorot_uniform(seed=0))(X)\n X = BatchNormalization(axis=3, name=bn_name_base + '2c')(X)\n\n #Add shortcut value to main path\n X_shortcut = Conv2D(filters = F3, kernel_size= (1,1),strides= (s,s), padding= 'valid' , name = conv_name_base + '1', kernel_initializer = glorot_uniform(seed=0))(X_shortcut)\n X_shortcut = BatchNormalization(axis=3, name=bn_name_base + '1')(X_shortcut)\n\n # Final step: Add shortcut value to main path, and pass it through a RELU activation\n X = layers.add([X,X_shortcut])\n X = Activation('relu')(X)\n\n return X","def bottleneck_block_v2(self, inputs, block_params, training, projection_shortcut,\n half_layer=None, initial_layer=False, no_prenorm=False):\n filters = block_params['filters']\n kernels = block_params['kernels']\n strides = block_params['strides']\n pad_stride1 = block_params['pad_stride1']\n\n shortcut = inputs\n if (not initial_layer) and (not no_prenorm):\n inputs = self.batch_norm_act(inputs, training)\n\n # The projection shortcut should come after the first batch norm and ReLU\n # since it performs a 1x1 convolution.\n if projection_shortcut is not None:\n shortcut = projection_shortcut(inputs)\n\n with tf.variable_scope('c0'):\n inputs = self.conv1d2d3d(inputs, filters//4, 1, 1, 's')\n self.log_tensor_c(inputs, 1, 1, 's', tf.get_variable_scope().name)\n\n inputs = self.batch_norm_act(inputs, training)\n\n with tf.variable_scope('c1'):\n inputs = self.conv1d2d3d(inputs, filters//4, kernels, strides, pad_stride1)\n self.log_tensor_c(inputs, kernels, strides, pad_stride1,\n tf.get_variable_scope().name)\n\n inputs = self.batch_norm_act(inputs, training)\n\n with tf.variable_scope('c2'):\n inputs = self.conv1d2d3d(inputs, filters, 1, 1, 's')\n self.log_tensor_c(inputs, 1, 1, 's', tf.get_variable_scope().name)\n\n if self.residual:\n if not inputs.shape == shortcut.shape:\n import pdb; pdb.set_trace() # XXX BREAKPOINT\n\n if self.IsShowModel: self.log('Add shortcut*%0.1f'%(self.res_scale))\n return inputs * self.res_scale + shortcut\n else:\n return inputs","def additional_equations(self, k):\n ######################################################################\n # equation for saturated gas at hot side outlet\n o1 = self.outl[0].to_flow()\n self.residual[k] = o1[2] - h_mix_pQ(o1, 1)","def _residual(self, x, in_filter, out_filter, stride, activate_before_residual=False):\n if activate_before_residual: \n with tf.variable_scope('shared_activation'):\n x = self._batch_norm('init_bn', x)\n x = self._relu(x, self.hps.relu_leakiness)\n orig_x = x\n else:\n with tf.variable_scope('residual_only_activation'):\n orig_x = x\n x = self._batch_norm('init_bn', x)\n x = self._relu(x, self.hps.relu_leakiness)\n\n with tf.variable_scope('sub1'):\n x = self._conv('conv1', x, 3, in_filter, out_filter, stride)\n\n with tf.variable_scope('sub2'):\n x = self._batch_norm('bn2', x)\n x = self._relu(x, self.hps.relu_leakiness)\n x = self._conv('conv2', x, 3, out_filter, out_filter, [1, 1, 1, 1])\n\n with tf.variable_scope('sub_add'):\n if in_filter != out_filter:\n orig_x = tf.nn.avg_pool(orig_x, stride, stride, 'VALID')\n orig_x = tf.pad(\n orig_x, [[0, 0], [0, 0], [0, 0],\n [(out_filter-in_filter)//2, (out_filter-in_filter)//2]])\n x += orig_x\n\n tf.logging.debug('image after unit %s', x.get_shape())\n return x","def final_sum(data: Iterator[str]) -> SnailfishNumber:\n return reduce(add, parse_input(data))","def _shortcut(inputs, residual):\n inputs_shape = K.int_shape(inputs)\n residual_shape = K.int_shape(residual)\n equal_channels = inputs_shape[2] == residual_shape[2]\n shortcut = inputs\n # 1 x 1 conv if shape is different. Else identity.\n if not equal_channels:\n shortcut = Conv1D(filters=residual_shape[2],\n kernel_size=1, strides=1, padding=\"same\",\n kernel_initializer=\"he_normal\",\n kernel_regularizer=l2(1.e-4))(inputs)\n return add([shortcut, residual])","def weighted_sum(h):\n return h","def _residual_block(block_function, filters, repetitions):\n def f(inputs):\n for i in range(repetitions):\n inputs = block_function(filters=filters, init_strides=1)(inputs)\n return inputs\n return f","def compute_residuals(r):\n global conv_residuals\n conv_residuals.append(r)\n return","def res_block(input_tensor, kernel_size, filters, stage, \n use_bias=True, train_bn=True):\n nb_filter1, nb_filter2, nb_filter3 = filters\n conv_name_base = 'res' + str(stage) + '_branch'\n bn_name_base = 'bn' + str(stage) + '_branch'\n\n with tf.name_scope(conv_name_base) as sc:\n x = KL.Conv2D(nb_filter1, (kernel_size, kernel_size), padding='same',\n name=conv_name_base + '2a', use_bias=use_bias)(input_tensor)\n x = BatchNorm(name=bn_name_base + '2a')(x, training=train_bn)\n x = KL.Activation('relu')(x)\n\n x = KL.Conv2D(nb_filter2, (kernel_size, kernel_size), padding='same',\n name=conv_name_base + '2b', use_bias=use_bias)(x)\n x = BatchNorm(name=bn_name_base + '2b')(x, training=train_bn)\n x = KL.Activation('relu')(x)\n\n x = KL.Conv2D(nb_filter3, (kernel_size, kernel_size), padding='same',\n name=conv_name_base + '2c', use_bias=use_bias)(x)\n x = BatchNorm(name=bn_name_base + '2c')(x, training=train_bn)\n\n x = KL.Add()([x, input_tensor])\n x = KL.Activation('relu', name='res' + str(stage) + '_out')(x)\n return x","def funky_sum(a, b, mix):\n if mix <= 0:\n return a\n elif mix >= 1:\n return b\n else:\n return (1 - mix) * a + mix * b","def get_shortcut(\n inputs,\n resnet_unit_label,\n block_id,\n features,\n stride,\n use_bias=False,\n kernel_initializer=\"he_normal\",\n bn_epsilon=1e-5,\n axis=3,\n):\n\n if block_id == 0:\n shortcut = Conv3D(\n features,\n (1, 1, 1),\n strides=stride,\n use_bias=use_bias,\n name=f\"resunit{resnet_unit_label}_block{block_id}_shortcut_conv\",\n kernel_initializer=kernel_initializer,\n )(inputs)\n\n shortcut = BatchNormalization(\n axis=axis,\n epsilon=bn_epsilon,\n name=f\"resunit{resnet_unit_label}_block{block_id}_shortcut_bn\",\n )(shortcut)\n return shortcut\n else:\n return inputs","def block_sum(i, bins, C, n_u):\n s= 0.0\n for j in range(bins[i], bins[i+1]):\n for k in range(bins[i], bins[i+1]):\n s+= C[j][k]*n_u[j]*n_u[k]\n return s","def residual_block(layer_input, filters=512, down_filter=False, normalization=False):\n\td1 = Conv2D(filters, kernel_size=3, strides=1, padding='same')(layer_input)\n\tif normalization:\n\t\t# d = InstanceNormalization()(d)\n\t\td1 = BatchNormalization(momentum=0.8)(d1) # 6/6/2018: use it for CT # 6/5/2018: remove it for MNIST\n\td1 = Activation('relu')(d1)\n\td2 = Conv2D(filters, kernel_size=3, strides=1, padding='same')(d1)\n\tif normalization:\n\t\t# d = InstanceNormalization()(d)\n\t\td2 = BatchNormalization(momentum=0.8)(d2) # 6/6/2018: use it for CT # 6/5/2018: remove it for MNIST\n\tif down_filter:\n\t\td = Add()([d1, d2])\n\telse:\n\t\td = Add()([d2, layer_input])\n\treturn d","def _shortcut(self, x, res):\n # Expand channels of shortcut to match residual's\n # Stride should be int if network architecture is configured correctly\n # To match residual's height and width\n input_shape = x.get_shape().as_list()\n res_shape = res.get_shape().as_list()\n stride_h = int(round(input_shape[1] / res_shape[1]))\n stride_w = int(round(input_shape[2] / res_shape[2]))\n equal_channel = (input_shape[3] == res_shape[3])\n\n shortcut = x\n # # 1 X 1 conv if shape is different, else identity.\n if stride_h > 1 or stride_w > 1 or not equal_channel:\n filter_shape = [1, 1, input_shape[3], res_shape[3]]\n w = self._get_weight_variable(filter_shape)\n shortcut = tf.nn.conv2d(x, w, strides=[1, stride_h, stride_w, 1], padding='VALID')\n\n out = shortcut + res\n\n return out","def custom_sum(*args):\n return functools.reduce(lambda x, y: x + y, args)","def simple_block(input_tensor, filters, prefix, kernel_size = 3, stride = 1,\n regularizer = None, activation = 'relu', conv_shortcut = False, bn = True):\n \n if K.image_data_format() == 'channels_last':\n bn_axis = 3\n else:\n bn_axis = 1\n conv_name_base = 'res' + prefix\n bn_name_base = 'bn' + prefix\n\n x = Conv2D(filters[1], kernel_size, padding='same', strides=(stride, stride),\n kernel_regularizer = regularizer,\n name=conv_name_base + 'x')(input_tensor)\n if bn:\n x = BatchNormalization(axis=bn_axis, name=bn_name_base + 'x')(x)\n x = Activation(activation)(x)\n\n x = Conv2D(filters[1], kernel_size, padding='same',\n kernel_regularizer = regularizer,\n name=conv_name_base + 'y')(x)\n if bn:\n x = BatchNormalization(axis=bn_axis, name=bn_name_base + 'y')(x)\n\n shortcut = input_tensor\n if (filters[0] != filters[1]) and conv_shortcut:\n shortcut = Conv2D(filters[1], (1, 1), strides=(stride, stride),\n kernel_regularizer = regularizer,\n name=conv_name_base + 'z')(shortcut)\n if bn:\n shortcut = BatchNormalization(axis=bn_axis, name=bn_name_base + 'z')(shortcut)\n else:\n if stride > 1:\n shortcut = AveragePooling2D((stride, stride), name='avg'+prefix)(shortcut)\n if filters[0] < filters[1]:\n shortcut = ChannelPadding(((filters[1] - filters[0]) // 2, filters[1] - filters[0] - (filters[1] - filters[0]) // 2),\n name = 'pad'+prefix)(shortcut)\n\n x = layers.add([x, shortcut])\n x = Activation(activation)(x)\n return x","def add_block(self, _input, growth_rate, layers_per_block):\n output = _input\n for layer in range(layers_per_block):\n with tf.variable_scope(\"layer_%d\" % layer):\n output = self.add_internal_layer(output, growth_rate)\n return output","def conv_block(input_tensor, kernel_size, filters, stage, block, strides=(1, 1)):\n # retriving filters\n F1, F2, F3 = filters\n\n # defining name basis\n conv_name_base = 'res' + str(stage) + block + '_branch'\n bn_name_base = 'bn' + str(stage) + block + '_branch'\n\n x_shortcut = input_tensor\n\n # First component of main path\n x = Conv2D(filters=F1, kernel_size=(1, 1), strides=strides, name=conv_name_base + '2a')(input_tensor)\n x = BatchNormalization(axis=3, name=bn_name_base + '2a')(x)\n x = Activation('relu')(x)\n\n # Second component of main path\n x = Conv2D(filters=F2, kernel_size=(kernel_size, kernel_size), strides=(1, 1), padding='same',\n name=conv_name_base + '2b')(x)\n x = BatchNormalization(axis=3, name=bn_name_base + '2b')(x)\n x = Activation('relu')(x)\n\n # Third component of main path\n x = Conv2D(filters=F3, kernel_size=(1, 1), strides=(1, 1), padding='valid', name=conv_name_base + '2c')(x)\n x = BatchNormalization(axis=3, name=bn_name_base + '2c')(x)\n\n # shortcut convolution layer\n x_shortcut = Conv2D(filters=F3, kernel_size=(1, 1), strides=strides, padding='valid', name=conv_name_base + '1')(\n x_shortcut)\n x_shortcut = BatchNormalization(axis=3, name=bn_name_base + '1')(x_shortcut)\n\n # Final step: Add shortcut value to main path, and pass it through a RELU activation\n x = add([x, x_shortcut])\n x = Activation('relu')(x)\n\n return x","def _bottleneck_block_v1(inputs, filters, training, projection_shortcut,\n strides, data_format):\n shortcut = inputs\n\n if projection_shortcut is not None:\n shortcut = projection_shortcut(inputs)\n shortcut = batch_norm(inputs=shortcut, training=training,\n data_format=data_format)\n\n inputs = conv2d_fixed_padding(\n inputs=inputs, filters=filters, kernel_size=1, strides=1,\n data_format=data_format)\n inputs = batch_norm(inputs, training, data_format)\n inputs = tf.nn.relu(inputs)\n\n inputs = conv2d_fixed_padding(\n inputs=inputs, filters=filters, kernel_size=3, strides=strides,\n data_format=data_format)\n inputs = batch_norm(inputs, training, data_format)\n inputs = tf.nn.relu(inputs)\n\n inputs = conv2d_fixed_padding(\n inputs=inputs, filters=4 * filters, kernel_size=1, strides=1,\n data_format=data_format)\n inputs = batch_norm(inputs, training, data_format)\n inputs += shortcut\n inputs = tf.nn.relu(inputs)\n\n return inputs","def sum(self, start=0, end=None):\n return super(SumSegmentTree, self).reduce(start, end)","def sum(self, start=0, end=None):\n return super(SumSegmentTree, self).reduce(start, end)","def sum(self, start=0, end=None):\n return super(SumSegmentTree, self).reduce(start, end)","def sum(self, start=0, end=None):\n return super(SumSegmentTree, self).reduce(start, end)","def sum(self, start=0, end=None):\n return super(SumSegmentTree, self).reduce(start, end)","def test_local_sum_sum_int8(self):\r\n x = tensor.tensor3(dtype='int8')\r\n y = x.sum(axis=0).sum(axis=1)\r\n backup = config.on_opt_error\r\n config.on_opt_error = 'raise'\r\n try:\r\n # This compilation would fail prior to fix.\r\n f = theano.function([x], y)\r\n finally:\r\n config.on_opt_error = backup","def build_resnet_block(inputres, dim, name=\"resnet\", padding=\"REFLECT\"):\n with tf.variable_scope(name):\n out_res = tf.pad(inputres, [[0, 0], [1, 1], [\n 1, 1], [0, 0]], padding)\n out_res = general_conv2d(\n out_res, dim, 3, 3, 1, 1, 0.02, \"VALID\", \"c1\")\n out_res = tf.pad(out_res, [[0, 0], [1, 1], [1, 1], [0, 0]], padding)\n out_res = general_conv2d(\n out_res, dim, 3, 3, 1, 1, 0.02, \"VALID\", \"c2\", do_relu=False)\n\n return tf.nn.relu(out_res + inputres)","def residual_block_(inputs,\n filters,\n is_training,\n strides,\n use_projection=False,\n pruning_method='baseline',\n init_method='baseline',\n data_format='channels_first',\n end_sparsity=0.,\n weight_decay=0.,\n name=''):\n shortcut = inputs\n if use_projection:\n # Projection shortcut in first layer to match filters and strides\n end_point = 'residual_projection_%s' % name\n shortcut = conv2d_fixed_padding(\n inputs=inputs,\n filters=filters,\n kernel_size=1,\n strides=strides,\n pruning_method=pruning_method,\n init_method=init_method,\n data_format=data_format,\n end_sparsity=end_sparsity,\n weight_decay=weight_decay,\n name=end_point)\n shortcut = batch_norm_relu(\n shortcut, is_training, relu=False, data_format=data_format)\n\n end_point = 'residual_1_%s' % name\n inputs = conv2d_fixed_padding(\n inputs=inputs,\n filters=filters,\n kernel_size=3,\n strides=strides,\n pruning_method=pruning_method,\n init_method=init_method,\n data_format=data_format,\n end_sparsity=end_sparsity,\n weight_decay=weight_decay,\n name=end_point)\n inputs = batch_norm_relu(\n inputs, is_training, data_format=data_format)\n\n end_point = 'residual_2_%s' % name\n inputs = conv2d_fixed_padding(\n inputs=inputs,\n filters=filters,\n kernel_size=3,\n strides=1,\n pruning_method=pruning_method,\n init_method=init_method,\n data_format=data_format,\n end_sparsity=end_sparsity,\n weight_decay=weight_decay,\n name=end_point)\n inputs = batch_norm_relu(\n inputs, is_training, relu=False, init_zero=True, data_format=data_format)\n\n return tf.nn.relu(inputs + shortcut)","def ResBlock(input_tensor, filters):\n \n conv_1 = Conv2D(filters = filters, kernel_size = 3, padding = 'same', kernel_initializer = 'he_normal') \n conv_1a = conv_1(input_tensor) # Shared weights conv layer\n batch_1 = BatchNormalization()(conv_1a)\n relu_1 = Activation(\"relu\")(batch_1)\n drop_1 = Dropout(drop)(relu_1)\n conv_1b = conv_1(drop_1) # Shared weights conv layer\n batch_1 = BatchNormalization()(conv_1b)\n return batch_1","def custom_sum(*args):\n return functools.reduce(lambda x, y: x + y, args)","def custom_sum(*args):\n return functools.reduce(lambda x, y: x + y, args)","def reduce_sum_encoder(inputs):\n return tf.reduce_sum(inputs, axis=1)","def _residual_block(block_function, filters, repetitions, is_first_layer=False):\n def f(input):\n for i in range(repetitions):\n init_strides = (1, 1)\n if i == 0 and not is_first_layer:\n init_strides = (2, 2)\n input = block_function(filters=filters, init_strides=init_strides,\n is_first_block_of_first_layer=(is_first_layer and i == 0))(input)\n return input\n\n return f","def _combine_task_specific_block(\n feature,\n weights,\n biases,\n model_spec,\n scope=\"combine_task_specific_block\"\n ):\n with tf.variable_scope(scope):\n task_dim = weights[0][0].shape[0].value\n task_ones = tf.ones(shape=[task_dim])\n feature_task_expanded = tf.einsum(\n \"ik,j->ijk\",\n feature,\n task_ones\n )\n weights_combined = []\n biases_combined = []\n for i in range(len(weights[0])):\n weights_combined.append(\n weights[0][i] + weights[1][i]\n )\n biases_combined.append(\n biases[0][i] + biases[1][i]\n )\n # in the special case only two layers: len(weights_combined) == 2 #\n hidden_a = tf.einsum(\n \"ijk,jlk->ijl\",\n feature_task_expanded,\n weights_combined[0]\n )\n hidden_a = hidden_a + biases_combined[0]\n if model_spec[\"activation\"] is not None:\n hidden_a = model_spec[\"activation\"](hidden_a)\n hidden_a_dropout = tf.layers.dropout(\n hidden_a,\n rate=model_spec[\"dropout_task_hidden_a\"],\n name=\"task_hidden_a_dropout\"\n )\n logits = tf.einsum(\n \"ijk,jlk->ijl\",\n hidden_a_dropout,\n weights_combined[1]\n )\n logits = logits + biases_combined[1]\n return logits","def sum_plus(t, init):\n total = init\n for x in t:\n total += x\n return total","def add_block2(_input, growth_rate, layers_per_block, bc_mode, is_training):\n output = _input\n for layer in range(layers_per_block):\n with tf.variable_scope(\"layer_%d\" % layer):\n output = add_internal_layer(output, growth_rate, bc_mode=bc_mode, is_training=is_training)\n return output","def plus(self, layer):\n\n input1 = self.node(layer)\n if not input1:\n return\n LOGGER.debug('Plus layer to last:%s', layer)\n if not self.last_node:\n self.last_node = nuke.nodes.Constant()\n\n if layer not in self.layers():\n input1 = nuke.nodes.Shuffle(inputs=[input1], out=layer)\n self.last_node = nuke.nodes.Merge2(\n inputs=[self.last_node, input1], operation='plus',\n also_merge=layer if layer not in self.layers() else 'none',\n label=utf8(self.l10n(layer)),\n output='rgb')","def _residual(self,\n x,\n in_filter,\n out_filter,\n stride,\n activate_before_residual=False):\n\n if activate_before_residual:\n with tf.variable_scope('shared_activation'):\n x = self._batch_norm('init_bn', x)\n x = self._relu(x, self._params.relu_leakiness)\n orig_x = x\n else:\n with tf.variable_scope('residual_only_activation'):\n orig_x = x\n x = self._batch_norm('init_bn', x)\n x = self._relu(x, self._params.relu_leakiness)\n\n with tf.variable_scope('sub1'):\n x = self._conv('conv1', x, 3, in_filter, out_filter, stride)\n\n with tf.variable_scope('sub2'):\n x = self._batch_norm('bn2', x)\n x = self._relu(x, self._params.relu_leakiness)\n x = self._conv('conv2', x, 3, out_filter, out_filter, [1, 1, 1, 1])\n\n with tf.variable_scope('sub_add'):\n if in_filter != out_filter:\n orig_x = tf.nn.avg_pool(orig_x, stride, stride, 'VALID')\n orig_x = tf.pad(\n orig_x, [[0, 0], [0, 0], [0, 0], [(out_filter - in_filter) // 2,\n (out_filter - in_filter) // 2]])\n x += orig_x\n\n return x","def residual(n_filters, input):\n shape = input.shape\n _, h, w, d = shape\n l1 = Conv2D(n_filters, (5, 5), padding='valid', activation='elu')(input)\n l2 = Conv2D(n_filters, (1, 1), padding='valid', activation='linear')(l1)\n l3 = Cropping2D(cropping=2)(input)\n added = Add()([l2, l3])\n return added","def _res_block(self, X, name, out_channels):\n \n X_shortcut = X\n X = self._mfm(X, name = name + '_mfm1', out_channels=out_channels, kernel_size=3, strides=1)\n X = self._mfm(X, name = name + '_mfm2', out_channels=out_channels, kernel_size=3, strides=1)\n X = Add()([X, X_shortcut])\n return X","def sum_():\n\n @sinks\n def _dagpype_internal_fn_act(target):\n try:\n s = (yield)\n while True:\n s += (yield)\n except GeneratorExit:\n target.send(s)\n target.close()\n\n return _dagpype_internal_fn_act","def make_accumulator():\n pass # replace with your solution","def sum_sum(t, init):\n return sum(t, init)","def additional_equations(self, k):\n ######################################################################\n # equation for saturated liquid at hot side outlet\n if self.subcooling.val is False:\n o1 = self.outl[0].to_flow()\n self.residual[k] = o1[2] - h_mix_pQ(o1, 0)\n k += 1","def identity_block(input_tensor, kernel_size, filters, stage, block):\n filters0, filters1, filters2 = filters\n conv_name_base = 'res' + str(stage) + block\n bn_name_base = 'bn' + str(stage) + block\n add_name = 'add' + str(stage) + \"_\" + block\n relu_name = 'relu' + str(stage) + \"_\" + block\n\n # Tensors\n input_tensor_chans = input_tensor.dims(\n 3) if input_tensor.shape.layout == sg.NHWC else input_tensor.dims(1)\n conv0_tensor = sg.Tensor(\n data_layout=sg.NHWC, tensor_data=generate_random_data(\n (filters0, 1, 1, input_tensor_chans)))\n bn0_mean_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\n bn0_var_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\n bn0_gamma_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\n bn0_beta_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\n conv1_tensor = sg.Tensor(\n data_layout=sg.NHWC, tensor_data=generate_random_data(\n (filters1, kernel_size, kernel_size, filters0)))\n bn1_mean_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\n bn1_var_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\n bn1_gamma_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\n bn1_beta_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\n conv2_tensor = sg.Tensor(\n data_layout=sg.NHWC, tensor_data=generate_random_data(\n (filters2, 1, 1, filters1)))\n bn2_mean_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\n bn2_var_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\n bn2_gamma_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\n bn2_beta_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\n\n x = sg.nn.convolution(\n input_tensor, conv0_tensor, stride=[1, 1], padding=\"same\",\n name=conv_name_base + '_2a')\n x = sg.nn.batch_norm(\n x, bn0_mean_tensor, bn0_var_tensor, bn0_gamma_tensor, bn0_beta_tensor,\n activation=\"relu\", name=bn_name_base + '_2a')\n x = sg.nn.convolution(\n x, conv1_tensor, stride=[1, 1], padding=\"same\",\n name=conv_name_base + '_2b')\n x = sg.nn.batch_norm(\n x, bn1_mean_tensor, bn1_var_tensor, bn1_gamma_tensor, bn1_beta_tensor,\n activation=\"relu\", name=bn_name_base + '_2b')\n x = sg.nn.convolution(\n x, conv2_tensor, stride=[1, 1], padding=\"same\",\n name=conv_name_base + '_2c')\n x = sg.nn.batch_norm(\n x, bn2_mean_tensor, bn2_var_tensor, bn2_gamma_tensor, bn2_beta_tensor,\n name=bn_name_base + '_2c')\n x = sg.math.add(x, input_tensor, name=add_name)\n x = sg.nn.relu(x, name=relu_name)\n return x","def get_sum(a,b):\n return","def __iadd__(self, term):\n self.add(term)\n return self","def add(self, term):\n self._value = self.accum_param.addInPlace(self._value, term)","def _building_block_v1(inputs, filters, training, projection_shortcut, strides,\n data_format):\n shortcut = inputs\n\n if projection_shortcut is not None:\n shortcut = projection_shortcut(inputs)\n shortcut = batch_norm(inputs=shortcut, training=training,\n data_format=data_format)\n\n inputs = conv2d_fixed_padding(\n inputs=inputs, filters=filters, kernel_size=3, strides=strides,\n data_format=data_format)\n inputs = batch_norm(inputs, training, data_format)\n inputs = tf.nn.relu(inputs)\n\n inputs = conv2d_fixed_padding(\n inputs=inputs, filters=filters, kernel_size=3, strides=1,\n data_format=data_format)\n inputs = batch_norm(inputs, training, data_format)\n inputs += shortcut\n inputs = tf.nn.relu(inputs)\n\n return inputs","def _building_block_v2(inputs, filters, training, \n projection_shortcut, strides,\n data_format):\n shortcut = inputs\n inputs = batch_norm(inputs, training, data_format)\n inputs = tf.nn.relu(inputs)\n ENDING_POINTS.append(inputs)\n\n # The projection shortcut should come after the first batch norm and ReLU\n # since it performs a 1x1 convolution.\n if projection_shortcut is not None:\n shortcut = projection_shortcut(inputs)\n\n inputs = conv3d_fixed_padding(\n inputs=inputs, filters=filters, kernel_size=3, \n time_kernel_size=3, strides=strides,\n data_format=data_format, time_stride=strides)\n\n inputs = batch_norm(inputs, training, data_format)\n inputs = tf.nn.relu(inputs)\n inputs = conv3d_fixed_padding(\n inputs=inputs, filters=filters, kernel_size=3, \n time_kernel_size=3, strides=1,\n data_format=data_format)\n\n return inputs + shortcut","def identity_block(X, f, filters, stage, block):\n \n # Defines name basis.\n conv_name_base = 'res' + str(stage) + block + '_branch'\n bn_name_base = 'bn' + str(stage) + block + '_branch'\n \n # Retrieves Filters.\n F1, F2, F3 = filters\n \n # Saves the input value. This is needed later to add back to the main path. \n X_shortcut = X\n \n ##### MAIN PATH #####\n # First component of main path.\n X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform())(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n X = Activation('relu')(X)\n \n \n # Second component of main path.\n X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform())(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\n X = Activation('relu')(X)\n \n # Third component of main path.\n X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c', kernel_initializer = glorot_uniform())(X)\n X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\n\n\n # Final step: Adds shortcut value to main path, and pass it through a RELU activation.\n X = Add()([X, X_shortcut])\n X = Activation('relu')(X)\n\n return X","def residual_module(in_block, K, stride, chanDim, red=False,\n reg= 1e-4, bnEps=2e-5, bnMom=.9):\n\n x = in_block\n chan_in = in_block.shape.as_list()[-1]\n bn1 = BatchNormalization(axis=chanDim, epsilon=bnEps, momentum=bnMom)(x)\n relu1 = Activation(\"relu\")(bn1)\n conv1 = Conv2D(filters=int(K * .25), kernel_size=(1, 1),\n use_bias=False,\n kernel_regularizer=l2(reg))(relu1) #Conv2D learns 1/4(0.25) of the last conv filter\n\n bn2 = BatchNormalization(axis=chanDim, epsilon=bnEps, momentum=bnMom)(conv1)\n relu2 = Activation(\"relu\")(bn2)\n conv2 = Conv2D(filters=int(K * .25), kernel_size=(3, 3), strides=stride,\n padding=\"same\",\n use_bias=False,\n kernel_regularizer=l2(reg))(relu2) #Conv2D learns 1/4(0.25) of the last conv filter\n\n bn3 = BatchNormalization(axis=chanDim, epsilon=bnEps, momentum=bnMom)(conv2)\n relu3 = Activation(\"relu\")(bn3)\n conv3 = Conv2D(filters=K, kernel_size=(1, 1),\n kernel_regularizer=l2(reg))(relu3)\n\n if red:\n x = Conv2D(filters=K, kernel_size=(1, 1), strides=stride,\n kernel_regularizer=l2(reg))(relu1)\n x = se_block(x)\n return add([x, conv3])","def __add__(self,that):\n return self.__opExpand2(that,np.add)","def add_block(_input, growth_rate, layers_per_block, bc_mode, name, is_training):\n output = _input\n for layer in range(layers_per_block):\n with tf.variable_scope(\"%s_layer_%d\" % (name, layer)):\n output = add_internal_layer(output, growth_rate, bc_mode=bc_mode, is_training=is_training)\n return output","def __add__(self, region):\n return Sequence(\n self.weight + region.weight,\n region.finish,\n (*self.regs, region)\n )","def __iadd__(self,that):\n #return self.__opExpand1(that,np.add, out=self)\n return self.__opExpand2(that,np.add, out=self)","def add(self, params):\n if len(params) < 2:\n return\n x = self.reg_dct[params[0]]\n y = self.reg_dct[params[1]]\n self.reg_dct[params[0]] = (x + y) % (2** 32)","def test_tensor_can_be_added_summation(free_alg):\n\n dr = free_alg\n p = dr.names\n i, j = p.R_dumms[:2]\n x = IndexedBase('x')\n y = IndexedBase('y')\n\n tensor = dr.sum((i, p.R), x[i, j] * y[j, i])\n\n for res in [\n dr.einst(tensor),\n dr.sum((j, p.R), tensor)\n ]:\n assert res == dr.einst(x[i, j] * y[j, i])","def sum(self, start=0, end=None):\n return super().reduce(start, end)","def attn_sum_bahdanau(v_attn, keys, query):\n return tf.reduce_sum(v_attn * tf.tanh(keys + tf.expand_dims(query, 1)), [2])","def add_input(self, accumulator, batch: input_batch.InputBatch) -> int:\n null_mask = batch.null_mask(self._path)\n if self._required_paths:\n required_null_mask = batch.all_null_mask(*self._required_paths)\n null_mask = null_mask & ~required_null_mask\n return accumulator + np.sum(null_mask)","def chamfer_sum(a,b):\n #tf.print(a)\n #tf.print(a[0,0,:])\n #tf.print(b[0,0,:])\n M = pairwise_distances(a, b)\n if len(M.shape) == 2:\n M = tf.expand_dims(M,0) #[np.newaxis, :, :]\n #return tf.keras.backend.sum(tf.reduce_sum(tf.reduce_min(M, 1), 1) + tf.reduce_sum(tf.reduce_min(M, 2), 1))\n c=tf.reduce_sum(tf.reduce_min(M, 1), 1) + tf.reduce_sum(tf.reduce_min(M, 2), 1)\n #tf.print(tf.reduce_sum(c))\n return c","def block_reduction_a(self, inputs, scope=None, reuse=None):\n # By default use stride=1 and SAME padding\n with slim.arg_scope([slim.conv2d, slim.avg_pool2d, slim.max_pool2d],\n stride=1, padding='SAME'):\n with tf.variable_scope(scope, 'BlockReductionA', [inputs], reuse=reuse):\n with tf.variable_scope('Branch_0'):\n branch_0 = slim.conv2d(inputs, 384, [3, 3], stride=2, padding='VALID',\n scope='Conv2d_1a_3x3')\n with tf.variable_scope('Branch_1'):\n branch_1 = slim.conv2d(inputs, 192, [1, 1], scope='Conv2d_0a_1x1')\n branch_1 = slim.conv2d(branch_1, 224, [3, 3], scope='Conv2d_0b_3x3')\n branch_1 = slim.conv2d(branch_1, 256, [3, 3], stride=2,\n padding='VALID', scope='Conv2d_1a_3x3')\n with tf.variable_scope('Branch_2'):\n branch_2 = slim.max_pool2d(inputs, [3, 3], stride=2, padding='VALID',\n scope='MaxPool_1a_3x3')\n return tf.concat(axis=3, values=[branch_0, branch_1, branch_2])","def addition_homework(data: Iterator[str]) -> int:\n n = final_sum(data)\n return n.magnitude","def conv_block(\n input_tensor, kernel_size, filters, stage, block, strides=(2, 2)):\n filters0, filters1, filters2 = filters\n conv_name_base = 'res' + str(stage) + block\n bn_name_base = 'bn' + str(stage) + block\n add_name = 'add' + str(stage) + \"_\" + block\n relu_name = 'relu' + str(stage) + \"_\" + block\n\n # sg.Tensors\n input_tensor_chans = input_tensor.dims(\n 3) if input_tensor.shape.layout == sg.NHWC else input_tensor.dims(1)\n conv0_tensor = sg.Tensor(\n data_layout=sg.NHWC, tensor_data=generate_random_data(\n (filters0, 1, 1, input_tensor_chans)))\n bn0_mean_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\n bn0_var_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\n bn0_gamma_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\n bn0_beta_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\n conv1_tensor = sg.Tensor(\n data_layout=sg.NHWC, tensor_data=generate_random_data(\n (filters1, kernel_size, kernel_size, filters0)))\n bn1_mean_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\n bn1_var_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\n bn1_gamma_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\n bn1_beta_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\n conv2_tensor = sg.Tensor(\n data_layout=sg.NHWC, tensor_data=generate_random_data(\n (filters2, 1, 1, filters1)))\n bn2_mean_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\n bn2_var_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\n bn2_gamma_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\n bn2_beta_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\n conv3_tensor = sg.Tensor(\n data_layout=sg.NHWC, tensor_data=generate_random_data(\n (filters2, 1, 1, input_tensor_chans)))\n bn3_mean_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\n bn3_var_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\n bn3_gamma_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\n bn3_beta_tensor = sg.Tensor(\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\n\n x = sg.nn.convolution(\n input_tensor, conv0_tensor, stride=[1, 1], padding=\"same\",\n name=conv_name_base + '_2a')\n x = sg.nn.batch_norm(\n x, bn0_mean_tensor, bn0_var_tensor, bn0_gamma_tensor, bn0_beta_tensor,\n activation=\"relu\")\n x = sg.nn.convolution(\n x, conv1_tensor, stride=strides, padding=\"same\",\n name=conv_name_base + '_2b')\n x = sg.nn.batch_norm(\n x, bn1_mean_tensor, bn1_var_tensor, bn1_gamma_tensor, bn1_beta_tensor,\n activation=\"relu\", name=bn_name_base + '_2b')\n x = sg.nn.convolution(\n x, conv2_tensor, stride=[1, 1], padding=\"same\",\n name=conv_name_base + '_2c')\n x = sg.nn.batch_norm(\n x, bn2_mean_tensor, bn2_var_tensor, bn2_gamma_tensor, bn2_beta_tensor,\n name=bn_name_base + '_2c')\n shortcut = sg.nn.convolution(\n input_tensor, conv3_tensor, stride=strides, padding=\"same\",\n name=conv_name_base + '_1')\n shortcut = sg.nn.batch_norm(\n shortcut, bn3_mean_tensor, bn3_var_tensor, bn3_gamma_tensor,\n bn3_beta_tensor, name=bn_name_base + '_1')\n x = sg.math.add(x, shortcut, name=add_name)\n x = sg.nn.relu(x, name=relu_name)\n return x","def addRes(res1, res2):\n return [(x + y) for x, y in zip(res1, res2)]","def combine_and_select_block(self, first):\n block = self.combine_block(first)\n self.combined.append(block)","def compute_partials(self, inputs, partials):\n partials['y', 'x'] = 2.0"],"string":"[\n \"def residual_block(layer, filters):\\n shortcut = layer\\n layer = Conv2D(filters=filters, kernel_size=(3, 3),\\n strides=(1, 1), padding=\\\"same\\\")(layer)\\n layer = LeakyReLU(alpha=LEAKY_RELU_ALPHA)(layer)\\n layer = Conv2D(filters=filters, kernel_size=(3, 3),\\n strides=(1, 1), padding=\\\"same\\\")(layer)\\n\\n layer = Add()([layer, shortcut])\\n layer = LeakyReLU(alpha=LEAKY_RELU_ALPHA)(layer)\\n return layer\",\n \"def _output_add(block_x, orig_x):\\n stride = orig_x.shape[-2] // block_x.shape[-2]\\n strides = (stride, stride)\\n if block_x.shape[-1] != orig_x.shape[-1]:\\n orig_x = nn.avg_pool(orig_x, strides, strides)\\n channels_to_add = block_x.shape[-1] - orig_x.shape[-1]\\n orig_x = jnp.pad(orig_x, [(0, 0), (0, 0), (0, 0), (0, channels_to_add)])\\n return block_x + orig_x\",\n \"def residual_block(layer_input, filters):\\n d = Conv2D(filters, kernel_size=3, strides=1, padding='same')(layer_input)\\n d = Activation('relu')(d)\\n d = BatchNormalization(momentum=0.8)(d)\\n d = Conv2D(filters, kernel_size=3, strides=1, padding='same')(d)\\n d = BatchNormalization(momentum=0.8)(d)\\n d = Add()([d, layer_input])\\n return d\",\n \"def _shortcut(self, input, residual):\\n # Expand channels of shortcut to match residual.\\n # Stride appropriately to match residual (width, height)\\n # Should be int if network architecture is correctly configured.\\n input_shape = K.int_shape(input)\\n residual_shape = K.int_shape(residual)\\n stride_width = int(round(input_shape[1] / residual_shape[1]))\\n stride_height = int(round(input_shape[2] / residual_shape[2]))\\n equal_channels = input_shape[3] == residual_shape[3]\\n \\n shortcut = input\\n # 1 X 1 conv if shape is different. Else identity.\\n if stride_width > 1 or stride_height > 1 or not equal_channels:\\n shortcut = Conv2D(filters=residual_shape[3],\\n kernel_size=(1, 1),\\n strides=(stride_width, stride_height),\\n padding=\\\"valid\\\",\\n kernel_initializer=\\\"he_normal\\\",\\n kernel_regularizer=l2(0.0001))(input)\\n \\n return add([shortcut, residual])\",\n \"def residual_block(layer_input, filters):\\n d = Conv2D(filters, kernel_size=3, strides=1, padding='same')(layer_input)\\n d = Activation('relu')(d)\\n d = BatchNormalization(momentum=0.8)(d)\\n d = Conv2D(filters, kernel_size=3, strides=1, padding='same')(d)\\n d = BatchNormalization(momentum=0.8)(d)\\n d = Add()([d, layer_input])\\n return d\",\n \"def resBlock(_input, _stage, _block):\\n nFilters = NBASEFILTERS * (2 ** _stage)\\n if _stage > 0 and _block == 0: # downsample\\n strides = 2\\n else:\\n strides = 1\\n\\n # 2 conv\\n output = resLayer(_input, nFilters, _stride=strides)\\n output = resLayer(output, nFilters, _acti=False)\\n\\n # shortcut\\n if _stage > 0 and _block == 0: # projection\\n # Caution: here the Keras document implementation differs from \\n # the one mentioned before (in kernel size), and we use Keras's.\\n _input = resLayer(_input, nFilters, _kernelSize=1,\\n _stride=strides, _norm=False, _acti=False)\\n\\n output = keras.layers.add([_input, output])\\n output = Activation('relu')(output)\\n return output\",\n \"def reduce_recipe(self):\\n\\n self.recipe.reduce(self.crafting, self.crafting_stride)\",\n \"def residual_block(net, style_weights, filters, kernel_size, strides,\\n depthwise_separable_conv):\\n tmp = conv_block(net,\\n style_weights,\\n filters=filters,\\n kernel_size=kernel_size,\\n strides=strides,\\n activation=\\\"relu\\\",\\n depthwise_separable_conv=depthwise_separable_conv)\\n tmp = conv_block(tmp,\\n style_weights,\\n filters=filters,\\n kernel_size=kernel_size,\\n strides=strides,\\n activation=None,\\n depthwise_separable_conv=depthwise_separable_conv)\\n return Add()([net, tmp])\",\n \"def _shortcut(input, residual):\\r\\n # Expand channels of shortcut to match residual.\\r\\n # Stride appropriately to match residual (width, height)\\r\\n # Should be int if network architecture is correctly configured.\\r\\n input_shape = K.int_shape(input)\\r\\n residual_shape = K.int_shape(residual)\\r\\n stride_width = int(round(input_shape[1] / residual_shape[1]))\\r\\n stride_height = int(round(input_shape[2] / residual_shape[2]))\\r\\n equal_channels = input_shape[3] == residual_shape[3]\\r\\n\\r\\n shortcut = input\\r\\n # 1 X 1 conv if shape is different. Else identity.\\r\\n if stride_width > 1 or stride_height > 1 or not equal_channels:\\r\\n shortcut = Conv2D(filters=residual_shape[3],\\r\\n kernel_size=(1, 1),\\r\\n strides=(stride_width, stride_height),\\r\\n padding=\\\"valid\\\",\\r\\n kernel_initializer=\\\"he_normal\\\",\\r\\n kernel_regularizer=l2(0.0001))(input)\\r\\n\\r\\n return add([shortcut, residual])\",\n \"def _shortcut(input, residual):\\n # Expand channels of shortcut to match residual.\\n # Stride appropriately to match residual (width, height)\\n # Should be int if network architecture is correctly configured.\\n input_shape = K.int_shape(input)\\n residual_shape = K.int_shape(residual)\\n stride_width = int(round(input_shape[1] / residual_shape[1]))\\n stride_height = int(round(input_shape[2] / residual_shape[2]))\\n equal_channels = input_shape[3] == residual_shape[3]\\n\\n shortcut = input\\n # 1 X 1 conv if shape is different. Else identity.\\n if stride_width > 1 or stride_height > 1 or not equal_channels:\\n shortcut = Conv2D(filters=residual_shape[3],\\n kernel_size=(1, 1),\\n strides=(stride_width, stride_height),\\n padding=\\\"valid\\\",\\n kernel_initializer=\\\"he_normal\\\",\\n kernel_regularizer=l2(0.0001))(input)\\n\\n return add([shortcut, residual])\",\n \"def residual_block(self, x, stride, out_filter, activate_before_residual=False, padding_in='SAME'):\\n with tf.name_scope(\\\"res_block\\\" + str(self._count_conv)):\\n in_filter = x.get_shape().as_list()[-1]\\n if activate_before_residual:\\n with tf.variable_scope('shared_activation'):\\n x = self.bn(x)\\n x = self.activation(x)\\n orig_x = x\\n else:\\n with tf.variable_scope('residual_only_activation'):\\n orig_x = x\\n x = self.bn(x)\\n x = self.activation(x)\\n\\n with tf.variable_scope('sub1'):\\n x = self.conv(x, 3, stride, out_filter, padding_in=padding_in)\\n\\n with tf.variable_scope('sub2'):\\n x = self.bn(x)\\n x = self.activation(x)\\n x = self.conv(x, 3, 1, out_filter, padding_in=padding_in)\\n\\n with tf.variable_scope('sub_add'):\\n if in_filter != out_filter:\\n orig_x = tf.nn.avg_pool(orig_x, [1, stride, stride, 1], [1, stride, stride, 1], 'VALID')\\n\\n orig_x = tf.pad(\\n orig_x, [[0, 0], [0, 0], [0, 0],\\n [(out_filter - in_filter) // 2, (out_filter - in_filter) // 2]])\\n\\n x += orig_x\\n\\n return x\",\n \"def residual_block(blockInput, nf, strides=1, batch_activate=False):\\n x = BatchActivate(blockInput)\\n x = res_conv_block(x, nf)\\n x = res_conv_block(x, nf, activation=False)\\n x = Add()([x, blockInput])\\n if batch_activate:\\n x = BatchActivate(x)\\n return x\",\n \"def residual_block(x, filters: int, a=0.01, dr=0.05, depth=2):\\n y = conv_block(x, filters, a, dr)\\n for _ in range(depth - 1):\\n y = conv_block(y, filters, a, dr)\\n y = Add()([x, y])\\n\\n return y\",\n \"def with_sum_sum_reduction(self):\\n return self.with_reduction(lambda x: x.sum())\",\n \"def _shortcut(input, residual):\\n # Expand channels of shortcut to match residual.\\n # Stride appropriately to match residual (width, height)\\n # Should be int if network architecture is correctly configured.\\n input_shape = K.int_shape(input)\\n residual_shape = K.int_shape(residual)\\n stride_width = int(round(input_shape[ROW_AXIS] / residual_shape[ROW_AXIS]))\\n stride_height = int(round(input_shape[COL_AXIS] / residual_shape[COL_AXIS]))\\n equal_channels = input_shape[CHANNEL_AXIS] == residual_shape[CHANNEL_AXIS]\\n\\n shortcut = input\\n # 1 X 1 conv if shape is different. Else identity.\\n if stride_width > 1 or stride_height > 1 or not equal_channels:\\n shortcut = Conv2D(filters=residual_shape[CHANNEL_AXIS],\\n kernel_size=(1, 1),\\n strides=(stride_width, stride_height),\\n padding=\\\"valid\\\",\\n kernel_initializer=\\\"he_normal\\\",\\n kernel_regularizer=l2(0.0001))(input)\\n\\n return add([shortcut, residual])\",\n \"def residual_block(x,index,step=\\\"encoding\\\"):\\r\\n if step != \\\"encoding\\\":\\r\\n index = \\\"decode_{}\\\".format(index)\\r\\n \\r\\n x_new = kl.Conv2D(128,(3,3),padding=\\\"same\\\",activation=\\\"selu\\\",kernel_initializer=initializer,\\r\\n name=\\\"conv1_res_{}\\\".format(index))(x)\\r\\n \\r\\n x_new = kl.Conv2D(128,(3,3),padding=\\\"same\\\",kernel_initializer=initializer,\\r\\n name=\\\"conv2_res_{}\\\".format(index))(x_new)\\r\\n \\r\\n x_out = kl.Add()([x,x_new])\\r\\n x_out = kl.Activation(\\\"relu\\\")(x_out)\\r\\n return(x_out)\",\n \"def _residual_block(input, id_block, conv_block, mid_f, output_f, repetitions, stage, is_first_layer=False):\\n\\n for i in range(repetitions):\\n if i == 0 and is_first_layer is True:\\n input = conv_block(mid_f, output_f, stage, i, input, stride=(1, 1))\\n elif i == 0 and is_first_layer is False:\\n input = conv_block(mid_f, output_f, stage, i, input)\\n else:\\n input = id_block(mid_f, output_f, stage, i, input)\\n return input\",\n \"def darknet53_residualBlock(inputs, filters, training, data_format, strides):\\n shortcuts = inputs\\n\\n inputs = conv2D_fiexed_padding(inputs,\\n filters=filters,\\n kernel_size=1,\\n strides=strides,\\n data_format=data_format)\\n inputs = batchNorm(inputs, training=training, data_format=data_format)\\n inputs = tf.nn.leaky_relu(inputs, alpha=_LEAKY_RELU)\\n\\n inputs = conv2D_fiexed_padding(inputs,\\n filters=2*filters,\\n kernel_size=3,\\n strides=strides,\\n data_format=data_format)\\n inputs = batchNorm(inputs, training, data_format)\\n inputs = tf.nn.leaky_relu(inputs, alpha=_LEAKY_RELU)\\n\\n inputs += shortcuts\\n\\n return inputs\\n pass\",\n \"def _shortcut(input, residual):\\n # Expand channels of shortcut to match residual.\\n # Stride appropriately to match residual (width, height)\\n # Should be int if network architecture is correctly configured.\\n input_shape = K.int_shape(input)\\n residual_shape = K.int_shape(residual)\\n stride_width = int(round(input_shape[ROW_AXIS] / residual_shape[ROW_AXIS]))\\n stride_height = int(round(input_shape[COL_AXIS] / residual_shape[COL_AXIS]))\\n stride_depth = int(round(input_shape[DEP_AXIS] / residual_shape[DEP_AXIS]))\\n equal_channels = input_shape[CHANNEL_AXIS] == residual_shape[CHANNEL_AXIS]\\n\\n shortcut = input\\n # 1 X 1 conv if shape is different. Else identity.\\n if stride_width > 1 or stride_height > 1 or stride_depth > 1 or not equal_channels:\\n shortcut = Conv3D(filters=residual_shape[CHANNEL_AXIS],\\n kernel_size=(1, 1,1),\\n strides=(stride_width, stride_height,stride_depth),\\n padding=\\\"valid\\\",\\n kernel_initializer=\\\"he_normal\\\",\\n kernel_regularizer=l2(0.0001))(input)\\n\\n return add([shortcut, residual])\",\n \"def sum_row(input, output, i):\\r\\n sum_ = input[i, :].sum()\\r\\n print(\\\"[Worker %d] Sum for row %d is %f\\\" % (os.getpid(), i, sum_))\\r\\n output[i] = sum_\",\n \"def convolutional_block(X, f, filters, stage, block, s = 2):\\n \\n # defining name basis\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n \\n # Retrieve Filters\\n F1, F2, F3 = filters\\n \\n # Save the input value\\n X_shortcut = X\\n\\n\\n ##### MAIN PATH #####\\n # First component of main path \\n X = Conv2D(F1, (1, 1), strides = (s,s), name = conv_name_base + '2a',padding = 'valid', kernel_initializer = glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\\n X = Activation('relu')(X)\\n\\n # Second component of main path\\n X = Conv2D(F2, (f, f), strides = (1,1), name = conv_name_base + '2b', padding = 'same', kernel_initializer = glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\\n X = Activation('relu')(X)\\n\\n # Third component of main path\\n X = Conv2D(F3, (1, 1), strides = (1,1), name = conv_name_base + '2c', padding = 'valid', kernel_initializer = glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\\n\\n ##### SHORTCUT PATH ####\\n X_shortcut = Conv2D(F3, (1, 1), strides = (s,s), name = conv_name_base + '1', padding = 'valid', kernel_initializer = glorot_uniform(seed=0),kernel_regularizer = regularizers.l1_l2(l1= 0.01,l2 = 0.1))(X_shortcut)\\n X_shortcut = BatchNormalization(axis = 3, name = bn_name_base + '1')(X_shortcut)\\n\\n # Final step: Add shortcut value to main path, and pass it through a RELU activation\\n X = Add()([X,X_shortcut])\\n X = Activation('relu')(X)\\n \\n return X\",\n \"def _shortcut(input, residual, name):\\n # Expand channels of shortcut to match residual.\\n # Stride appropriately to match residual (width, height)\\n # Should be int if network architecture is correctly configured.\\n input_shape = K.int_shape(input)\\n residual_shape = K.int_shape(residual)\\n stride_width = int(round(input_shape[ROW_AXIS] / residual_shape[ROW_AXIS]))\\n stride_height = int(round(input_shape[COL_AXIS] / residual_shape[COL_AXIS]))\\n equal_channels = input_shape[CHANNEL_AXIS] == residual_shape[CHANNEL_AXIS]\\n\\n shortcut = input\\n # 1 X 1 conv if shape is different. Else identity.\\n if stride_width > 1 or stride_height > 1 or not equal_channels:\\n shortcut = Conv2D(filters=residual_shape[CHANNEL_AXIS],\\n kernel_size=(1, 1),\\n strides=(stride_width, stride_height),\\n padding=\\\"valid\\\",\\n kernel_initializer=\\\"he_normal\\\",\\n kernel_regularizer=l2(0.0001),\\n\\t\\t name = name)(input)\\n\\n return add([shortcut, residual])\",\n \"def rrdb(x):\\n h = dense_block(x)\\n h = dense_block(h)\\n h = dense_block(h)\\n h = tf.keras.layers.Lambda(lambda x: x * 0.2)(h)\\n out = tf.keras.layers.Add()([h, x])\\n return out\",\n \"def __radd__(self,that):\\n return self.__opExpand2(that,np.add)\",\n \"def building_block_v2(self, inputs, block_params, training, projection_shortcut,\\n half_layer=None, initial_layer=False, no_prenorm=False):\\n filters = block_params['filters']\\n kernels = block_params['kernels']\\n strides = block_params['strides']\\n pad_stride1 = block_params['pad_stride1']\\n\\n shortcut = inputs\\n if (not initial_layer) and (not no_prenorm):\\n inputs = self.batch_norm_act(inputs, training)\\n if projection_shortcut == 'FirstResUnit':\\n # For pointnet, projection shortcut is not needed at the First ResUnit.\\n # However, BN and Activation is still required at the First ResUnit for\\n # pre-activation.\\n shortcut = inputs\\n projection_shortcut = None\\n if self.IsShowModel: self.log(\\n 'shortcut after activation identity for pointnet first res unit')\\n if half_layer:\\n projection_shortcut = None\\n\\n # The projection shortcut should come after the first batch norm and ReLU\\n # since it performs a 1x1 convolution.\\n if projection_shortcut is not None:\\n shortcut = projection_shortcut(inputs)\\n\\n with tf.variable_scope('c0'):\\n inputs = self.conv1d2d3d(inputs, filters, kernels, strides, pad_stride1)\\n self.log_tensor_c(inputs, kernels, strides, pad_stride1,\\n tf.get_variable_scope().name)\\n if half_layer: return inputs\\n inputs = self.batch_norm_act(inputs, training)\\n\\n with tf.variable_scope('c1'):\\n inputs = self.conv1d2d3d(inputs, filters, kernels, 1, 's')\\n self.log_tensor_c(inputs, kernels, 1, 's',\\n tf.get_variable_scope().name)\\n\\n if self.residual and (not initial_layer):\\n assert inputs.shape == shortcut.shape\\n if self.IsShowModel: self.log('Add shortcut*%0.1f'%(self.res_scale))\\n return inputs * self.res_scale + shortcut\\n else:\\n return inputs\",\n \"def convolutional_block(X, f, filters, stage, block, s = 2):\\n \\n # Defines name basis.\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n \\n # Retrieves Filters.\\n F1, F2, F3 = filters\\n \\n # Saves the input value.\\n X_shortcut = X\\n\\n\\n ##### MAIN PATH #####\\n # First component of main path \\n X = Conv2D(F1, (1, 1), strides = (s,s), padding = 'valid',name = conv_name_base + '2a', kernel_initializer = glorot_uniform())(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\\n X = Activation('relu')(X)\\n\\n # Second component of main path.\\n X = Conv2D(F2, (f, f), strides = (1,1), padding = 'same',name = conv_name_base + '2b', kernel_initializer = glorot_uniform())(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\\n X = Activation('relu')(X)\\n\\n # Third component of main path.\\n X = Conv2D(F3, (1, 1), strides = (1,1), padding = 'valid',name = conv_name_base + '2c', kernel_initializer = glorot_uniform())(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\\n \\n ##### SHORTCUT PATH ####\\n X_shortcut= Conv2D(F3, (1, 1), strides = (s,s), padding = 'valid',name = conv_name_base + '1', kernel_initializer = glorot_uniform())(X_shortcut)\\n X_shortcut = BatchNormalization(axis = 3, name = bn_name_base + '1')(X_shortcut)\\n \\n # Final step: Adds shortcut value to main path, and pass it through a RELU activation.\\n X = Add()([X, X_shortcut])\\n X = Activation('relu')(X)\\n\\n return X\",\n \"def update_weights_sum(self):\\n vals = self.nn.get_param_values()\\n # only use the last layer for summation (w, b)\\n self.w_sum = np.sum(vals[-2]) + np.sum(vals[-1])\",\n \"def sum_value(self, lv, rv):\",\n \"def convolutional_block(X, filters, stage, block):\\n \\n # defining name basis\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n \\n # Retrieve Filters\\n F1, F2 = filters\\n \\n # Save the input value\\n X_shortcut = X\\n\\n ##### MAIN PATH #####\\n # First component of main path \\n X = Conv2D(F1, (3, 3), strides = (2, 2), padding = 'same', name = conv_name_base + '2a', kernel_initializer = glorot_uniform())(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\\n X = Activation('relu')(X)\\n\\n # Second component of main path\\n X = Conv2D(F2, (3, 3), strides = (1, 1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform())(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\\n\\n ##### SHORTCUT PATH ####\\n X_shortcut = Conv2D(F2, (3, 3), strides = (2, 2), padding = 'same', name = conv_name_base + '1', kernel_initializer = glorot_uniform())(X_shortcut)\\n X_shortcut = BatchNormalization(axis = 3, name = bn_name_base + '1')(X_shortcut)\\n\\n # Final step: Add shortcut value to main path, and pass it through a RELU activation (≈2 lines)\\n X = Add()([X, X_shortcut])\\n X = Activation('relu')(X)\\n \\n return X\",\n \"def inline_sum(summands, seed):\\n for r in summands:\\n seed += r\\n return seed\",\n \"def inline_sum(summands, seed):\\n for r in summands:\\n seed += r\\n return seed\",\n \"def _shortcut(input_feature, residual, conv_name_base=None, bn_name_base=None):\\n # Expand channels of shortcut to match residual.\\n # Stride appropriately to match residual (width, height)\\n # Should be int if network architecture is correctly configured.\\n input_shape = K.int_shape(input_feature)\\n residual_shape = K.int_shape(residual)\\n stride_width = int(round(input_shape[ROW_AXIS] / residual_shape[ROW_AXIS]))\\n stride_height = int(round(input_shape[COL_AXIS] / residual_shape[COL_AXIS]))\\n equal_channels = input_shape[CHANNEL_AXIS] == residual_shape[CHANNEL_AXIS]\\n\\n shortcut = input_feature\\n # 1 X 1 conv if shape is different. Else identity.\\n if stride_width > 1 or stride_height > 1 or not equal_channels:\\n # print('reshaping via a convolution...')\\n shortcut = Conv2D(\\n filters=residual_shape[CHANNEL_AXIS],\\n kernel_size=(1, 1),\\n strides=(stride_width, stride_height),\\n padding=\\\"valid\\\",\\n kernel_initializer=\\\"he_normal\\\",\\n kernel_regularizer=l2(0.0001),\\n name=conv_name_base,\\n )(input_feature)\\n shortcut = BatchNormalization(axis=CHANNEL_AXIS, name=bn_name_base)(shortcut)\\n\\n return add([shortcut, residual])\",\n \"def convolutional_block(X, f, filters, stage, block, s=2):\\n\\n # defining name basis\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n\\n # Retrieve Filters\\n F1, F2, F3 = filters\\n\\n # Save the input value.\\n X_shortcut = X\\n\\n # First component of main path\\n X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (s,s), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\\n X = Activation('relu')(X)\\n\\n # Second component of main path\\n X = Conv2D(filters = F2, kernel_size= (f,f),strides= (1,1), padding= 'same' , name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis=3, name=bn_name_base + '2b')(X)\\n X = Activation('relu')(X)\\n\\n # Third component of main path\\n X = Conv2D(filters = F3, kernel_size= (1,1),strides= (1,1), padding= 'valid' , name = conv_name_base + '2c', kernel_initializer = glorot_uniform(seed=0))(X)\\n X = BatchNormalization(axis=3, name=bn_name_base + '2c')(X)\\n\\n #Add shortcut value to main path\\n X_shortcut = Conv2D(filters = F3, kernel_size= (1,1),strides= (s,s), padding= 'valid' , name = conv_name_base + '1', kernel_initializer = glorot_uniform(seed=0))(X_shortcut)\\n X_shortcut = BatchNormalization(axis=3, name=bn_name_base + '1')(X_shortcut)\\n\\n # Final step: Add shortcut value to main path, and pass it through a RELU activation\\n X = layers.add([X,X_shortcut])\\n X = Activation('relu')(X)\\n\\n return X\",\n \"def bottleneck_block_v2(self, inputs, block_params, training, projection_shortcut,\\n half_layer=None, initial_layer=False, no_prenorm=False):\\n filters = block_params['filters']\\n kernels = block_params['kernels']\\n strides = block_params['strides']\\n pad_stride1 = block_params['pad_stride1']\\n\\n shortcut = inputs\\n if (not initial_layer) and (not no_prenorm):\\n inputs = self.batch_norm_act(inputs, training)\\n\\n # The projection shortcut should come after the first batch norm and ReLU\\n # since it performs a 1x1 convolution.\\n if projection_shortcut is not None:\\n shortcut = projection_shortcut(inputs)\\n\\n with tf.variable_scope('c0'):\\n inputs = self.conv1d2d3d(inputs, filters//4, 1, 1, 's')\\n self.log_tensor_c(inputs, 1, 1, 's', tf.get_variable_scope().name)\\n\\n inputs = self.batch_norm_act(inputs, training)\\n\\n with tf.variable_scope('c1'):\\n inputs = self.conv1d2d3d(inputs, filters//4, kernels, strides, pad_stride1)\\n self.log_tensor_c(inputs, kernels, strides, pad_stride1,\\n tf.get_variable_scope().name)\\n\\n inputs = self.batch_norm_act(inputs, training)\\n\\n with tf.variable_scope('c2'):\\n inputs = self.conv1d2d3d(inputs, filters, 1, 1, 's')\\n self.log_tensor_c(inputs, 1, 1, 's', tf.get_variable_scope().name)\\n\\n if self.residual:\\n if not inputs.shape == shortcut.shape:\\n import pdb; pdb.set_trace() # XXX BREAKPOINT\\n\\n if self.IsShowModel: self.log('Add shortcut*%0.1f'%(self.res_scale))\\n return inputs * self.res_scale + shortcut\\n else:\\n return inputs\",\n \"def additional_equations(self, k):\\n ######################################################################\\n # equation for saturated gas at hot side outlet\\n o1 = self.outl[0].to_flow()\\n self.residual[k] = o1[2] - h_mix_pQ(o1, 1)\",\n \"def _residual(self, x, in_filter, out_filter, stride, activate_before_residual=False):\\n if activate_before_residual: \\n with tf.variable_scope('shared_activation'):\\n x = self._batch_norm('init_bn', x)\\n x = self._relu(x, self.hps.relu_leakiness)\\n orig_x = x\\n else:\\n with tf.variable_scope('residual_only_activation'):\\n orig_x = x\\n x = self._batch_norm('init_bn', x)\\n x = self._relu(x, self.hps.relu_leakiness)\\n\\n with tf.variable_scope('sub1'):\\n x = self._conv('conv1', x, 3, in_filter, out_filter, stride)\\n\\n with tf.variable_scope('sub2'):\\n x = self._batch_norm('bn2', x)\\n x = self._relu(x, self.hps.relu_leakiness)\\n x = self._conv('conv2', x, 3, out_filter, out_filter, [1, 1, 1, 1])\\n\\n with tf.variable_scope('sub_add'):\\n if in_filter != out_filter:\\n orig_x = tf.nn.avg_pool(orig_x, stride, stride, 'VALID')\\n orig_x = tf.pad(\\n orig_x, [[0, 0], [0, 0], [0, 0],\\n [(out_filter-in_filter)//2, (out_filter-in_filter)//2]])\\n x += orig_x\\n\\n tf.logging.debug('image after unit %s', x.get_shape())\\n return x\",\n \"def final_sum(data: Iterator[str]) -> SnailfishNumber:\\n return reduce(add, parse_input(data))\",\n \"def _shortcut(inputs, residual):\\n inputs_shape = K.int_shape(inputs)\\n residual_shape = K.int_shape(residual)\\n equal_channels = inputs_shape[2] == residual_shape[2]\\n shortcut = inputs\\n # 1 x 1 conv if shape is different. Else identity.\\n if not equal_channels:\\n shortcut = Conv1D(filters=residual_shape[2],\\n kernel_size=1, strides=1, padding=\\\"same\\\",\\n kernel_initializer=\\\"he_normal\\\",\\n kernel_regularizer=l2(1.e-4))(inputs)\\n return add([shortcut, residual])\",\n \"def weighted_sum(h):\\n return h\",\n \"def _residual_block(block_function, filters, repetitions):\\n def f(inputs):\\n for i in range(repetitions):\\n inputs = block_function(filters=filters, init_strides=1)(inputs)\\n return inputs\\n return f\",\n \"def compute_residuals(r):\\n global conv_residuals\\n conv_residuals.append(r)\\n return\",\n \"def res_block(input_tensor, kernel_size, filters, stage, \\n use_bias=True, train_bn=True):\\n nb_filter1, nb_filter2, nb_filter3 = filters\\n conv_name_base = 'res' + str(stage) + '_branch'\\n bn_name_base = 'bn' + str(stage) + '_branch'\\n\\n with tf.name_scope(conv_name_base) as sc:\\n x = KL.Conv2D(nb_filter1, (kernel_size, kernel_size), padding='same',\\n name=conv_name_base + '2a', use_bias=use_bias)(input_tensor)\\n x = BatchNorm(name=bn_name_base + '2a')(x, training=train_bn)\\n x = KL.Activation('relu')(x)\\n\\n x = KL.Conv2D(nb_filter2, (kernel_size, kernel_size), padding='same',\\n name=conv_name_base + '2b', use_bias=use_bias)(x)\\n x = BatchNorm(name=bn_name_base + '2b')(x, training=train_bn)\\n x = KL.Activation('relu')(x)\\n\\n x = KL.Conv2D(nb_filter3, (kernel_size, kernel_size), padding='same',\\n name=conv_name_base + '2c', use_bias=use_bias)(x)\\n x = BatchNorm(name=bn_name_base + '2c')(x, training=train_bn)\\n\\n x = KL.Add()([x, input_tensor])\\n x = KL.Activation('relu', name='res' + str(stage) + '_out')(x)\\n return x\",\n \"def funky_sum(a, b, mix):\\n if mix <= 0:\\n return a\\n elif mix >= 1:\\n return b\\n else:\\n return (1 - mix) * a + mix * b\",\n \"def get_shortcut(\\n inputs,\\n resnet_unit_label,\\n block_id,\\n features,\\n stride,\\n use_bias=False,\\n kernel_initializer=\\\"he_normal\\\",\\n bn_epsilon=1e-5,\\n axis=3,\\n):\\n\\n if block_id == 0:\\n shortcut = Conv3D(\\n features,\\n (1, 1, 1),\\n strides=stride,\\n use_bias=use_bias,\\n name=f\\\"resunit{resnet_unit_label}_block{block_id}_shortcut_conv\\\",\\n kernel_initializer=kernel_initializer,\\n )(inputs)\\n\\n shortcut = BatchNormalization(\\n axis=axis,\\n epsilon=bn_epsilon,\\n name=f\\\"resunit{resnet_unit_label}_block{block_id}_shortcut_bn\\\",\\n )(shortcut)\\n return shortcut\\n else:\\n return inputs\",\n \"def block_sum(i, bins, C, n_u):\\n s= 0.0\\n for j in range(bins[i], bins[i+1]):\\n for k in range(bins[i], bins[i+1]):\\n s+= C[j][k]*n_u[j]*n_u[k]\\n return s\",\n \"def residual_block(layer_input, filters=512, down_filter=False, normalization=False):\\n\\td1 = Conv2D(filters, kernel_size=3, strides=1, padding='same')(layer_input)\\n\\tif normalization:\\n\\t\\t# d = InstanceNormalization()(d)\\n\\t\\td1 = BatchNormalization(momentum=0.8)(d1) # 6/6/2018: use it for CT # 6/5/2018: remove it for MNIST\\n\\td1 = Activation('relu')(d1)\\n\\td2 = Conv2D(filters, kernel_size=3, strides=1, padding='same')(d1)\\n\\tif normalization:\\n\\t\\t# d = InstanceNormalization()(d)\\n\\t\\td2 = BatchNormalization(momentum=0.8)(d2) # 6/6/2018: use it for CT # 6/5/2018: remove it for MNIST\\n\\tif down_filter:\\n\\t\\td = Add()([d1, d2])\\n\\telse:\\n\\t\\td = Add()([d2, layer_input])\\n\\treturn d\",\n \"def _shortcut(self, x, res):\\n # Expand channels of shortcut to match residual's\\n # Stride should be int if network architecture is configured correctly\\n # To match residual's height and width\\n input_shape = x.get_shape().as_list()\\n res_shape = res.get_shape().as_list()\\n stride_h = int(round(input_shape[1] / res_shape[1]))\\n stride_w = int(round(input_shape[2] / res_shape[2]))\\n equal_channel = (input_shape[3] == res_shape[3])\\n\\n shortcut = x\\n # # 1 X 1 conv if shape is different, else identity.\\n if stride_h > 1 or stride_w > 1 or not equal_channel:\\n filter_shape = [1, 1, input_shape[3], res_shape[3]]\\n w = self._get_weight_variable(filter_shape)\\n shortcut = tf.nn.conv2d(x, w, strides=[1, stride_h, stride_w, 1], padding='VALID')\\n\\n out = shortcut + res\\n\\n return out\",\n \"def custom_sum(*args):\\n return functools.reduce(lambda x, y: x + y, args)\",\n \"def simple_block(input_tensor, filters, prefix, kernel_size = 3, stride = 1,\\n regularizer = None, activation = 'relu', conv_shortcut = False, bn = True):\\n \\n if K.image_data_format() == 'channels_last':\\n bn_axis = 3\\n else:\\n bn_axis = 1\\n conv_name_base = 'res' + prefix\\n bn_name_base = 'bn' + prefix\\n\\n x = Conv2D(filters[1], kernel_size, padding='same', strides=(stride, stride),\\n kernel_regularizer = regularizer,\\n name=conv_name_base + 'x')(input_tensor)\\n if bn:\\n x = BatchNormalization(axis=bn_axis, name=bn_name_base + 'x')(x)\\n x = Activation(activation)(x)\\n\\n x = Conv2D(filters[1], kernel_size, padding='same',\\n kernel_regularizer = regularizer,\\n name=conv_name_base + 'y')(x)\\n if bn:\\n x = BatchNormalization(axis=bn_axis, name=bn_name_base + 'y')(x)\\n\\n shortcut = input_tensor\\n if (filters[0] != filters[1]) and conv_shortcut:\\n shortcut = Conv2D(filters[1], (1, 1), strides=(stride, stride),\\n kernel_regularizer = regularizer,\\n name=conv_name_base + 'z')(shortcut)\\n if bn:\\n shortcut = BatchNormalization(axis=bn_axis, name=bn_name_base + 'z')(shortcut)\\n else:\\n if stride > 1:\\n shortcut = AveragePooling2D((stride, stride), name='avg'+prefix)(shortcut)\\n if filters[0] < filters[1]:\\n shortcut = ChannelPadding(((filters[1] - filters[0]) // 2, filters[1] - filters[0] - (filters[1] - filters[0]) // 2),\\n name = 'pad'+prefix)(shortcut)\\n\\n x = layers.add([x, shortcut])\\n x = Activation(activation)(x)\\n return x\",\n \"def add_block(self, _input, growth_rate, layers_per_block):\\n output = _input\\n for layer in range(layers_per_block):\\n with tf.variable_scope(\\\"layer_%d\\\" % layer):\\n output = self.add_internal_layer(output, growth_rate)\\n return output\",\n \"def conv_block(input_tensor, kernel_size, filters, stage, block, strides=(1, 1)):\\n # retriving filters\\n F1, F2, F3 = filters\\n\\n # defining name basis\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n\\n x_shortcut = input_tensor\\n\\n # First component of main path\\n x = Conv2D(filters=F1, kernel_size=(1, 1), strides=strides, name=conv_name_base + '2a')(input_tensor)\\n x = BatchNormalization(axis=3, name=bn_name_base + '2a')(x)\\n x = Activation('relu')(x)\\n\\n # Second component of main path\\n x = Conv2D(filters=F2, kernel_size=(kernel_size, kernel_size), strides=(1, 1), padding='same',\\n name=conv_name_base + '2b')(x)\\n x = BatchNormalization(axis=3, name=bn_name_base + '2b')(x)\\n x = Activation('relu')(x)\\n\\n # Third component of main path\\n x = Conv2D(filters=F3, kernel_size=(1, 1), strides=(1, 1), padding='valid', name=conv_name_base + '2c')(x)\\n x = BatchNormalization(axis=3, name=bn_name_base + '2c')(x)\\n\\n # shortcut convolution layer\\n x_shortcut = Conv2D(filters=F3, kernel_size=(1, 1), strides=strides, padding='valid', name=conv_name_base + '1')(\\n x_shortcut)\\n x_shortcut = BatchNormalization(axis=3, name=bn_name_base + '1')(x_shortcut)\\n\\n # Final step: Add shortcut value to main path, and pass it through a RELU activation\\n x = add([x, x_shortcut])\\n x = Activation('relu')(x)\\n\\n return x\",\n \"def _bottleneck_block_v1(inputs, filters, training, projection_shortcut,\\n strides, data_format):\\n shortcut = inputs\\n\\n if projection_shortcut is not None:\\n shortcut = projection_shortcut(inputs)\\n shortcut = batch_norm(inputs=shortcut, training=training,\\n data_format=data_format)\\n\\n inputs = conv2d_fixed_padding(\\n inputs=inputs, filters=filters, kernel_size=1, strides=1,\\n data_format=data_format)\\n inputs = batch_norm(inputs, training, data_format)\\n inputs = tf.nn.relu(inputs)\\n\\n inputs = conv2d_fixed_padding(\\n inputs=inputs, filters=filters, kernel_size=3, strides=strides,\\n data_format=data_format)\\n inputs = batch_norm(inputs, training, data_format)\\n inputs = tf.nn.relu(inputs)\\n\\n inputs = conv2d_fixed_padding(\\n inputs=inputs, filters=4 * filters, kernel_size=1, strides=1,\\n data_format=data_format)\\n inputs = batch_norm(inputs, training, data_format)\\n inputs += shortcut\\n inputs = tf.nn.relu(inputs)\\n\\n return inputs\",\n \"def sum(self, start=0, end=None):\\n return super(SumSegmentTree, self).reduce(start, end)\",\n \"def sum(self, start=0, end=None):\\n return super(SumSegmentTree, self).reduce(start, end)\",\n \"def sum(self, start=0, end=None):\\n return super(SumSegmentTree, self).reduce(start, end)\",\n \"def sum(self, start=0, end=None):\\n return super(SumSegmentTree, self).reduce(start, end)\",\n \"def sum(self, start=0, end=None):\\n return super(SumSegmentTree, self).reduce(start, end)\",\n \"def test_local_sum_sum_int8(self):\\r\\n x = tensor.tensor3(dtype='int8')\\r\\n y = x.sum(axis=0).sum(axis=1)\\r\\n backup = config.on_opt_error\\r\\n config.on_opt_error = 'raise'\\r\\n try:\\r\\n # This compilation would fail prior to fix.\\r\\n f = theano.function([x], y)\\r\\n finally:\\r\\n config.on_opt_error = backup\",\n \"def build_resnet_block(inputres, dim, name=\\\"resnet\\\", padding=\\\"REFLECT\\\"):\\n with tf.variable_scope(name):\\n out_res = tf.pad(inputres, [[0, 0], [1, 1], [\\n 1, 1], [0, 0]], padding)\\n out_res = general_conv2d(\\n out_res, dim, 3, 3, 1, 1, 0.02, \\\"VALID\\\", \\\"c1\\\")\\n out_res = tf.pad(out_res, [[0, 0], [1, 1], [1, 1], [0, 0]], padding)\\n out_res = general_conv2d(\\n out_res, dim, 3, 3, 1, 1, 0.02, \\\"VALID\\\", \\\"c2\\\", do_relu=False)\\n\\n return tf.nn.relu(out_res + inputres)\",\n \"def residual_block_(inputs,\\n filters,\\n is_training,\\n strides,\\n use_projection=False,\\n pruning_method='baseline',\\n init_method='baseline',\\n data_format='channels_first',\\n end_sparsity=0.,\\n weight_decay=0.,\\n name=''):\\n shortcut = inputs\\n if use_projection:\\n # Projection shortcut in first layer to match filters and strides\\n end_point = 'residual_projection_%s' % name\\n shortcut = conv2d_fixed_padding(\\n inputs=inputs,\\n filters=filters,\\n kernel_size=1,\\n strides=strides,\\n pruning_method=pruning_method,\\n init_method=init_method,\\n data_format=data_format,\\n end_sparsity=end_sparsity,\\n weight_decay=weight_decay,\\n name=end_point)\\n shortcut = batch_norm_relu(\\n shortcut, is_training, relu=False, data_format=data_format)\\n\\n end_point = 'residual_1_%s' % name\\n inputs = conv2d_fixed_padding(\\n inputs=inputs,\\n filters=filters,\\n kernel_size=3,\\n strides=strides,\\n pruning_method=pruning_method,\\n init_method=init_method,\\n data_format=data_format,\\n end_sparsity=end_sparsity,\\n weight_decay=weight_decay,\\n name=end_point)\\n inputs = batch_norm_relu(\\n inputs, is_training, data_format=data_format)\\n\\n end_point = 'residual_2_%s' % name\\n inputs = conv2d_fixed_padding(\\n inputs=inputs,\\n filters=filters,\\n kernel_size=3,\\n strides=1,\\n pruning_method=pruning_method,\\n init_method=init_method,\\n data_format=data_format,\\n end_sparsity=end_sparsity,\\n weight_decay=weight_decay,\\n name=end_point)\\n inputs = batch_norm_relu(\\n inputs, is_training, relu=False, init_zero=True, data_format=data_format)\\n\\n return tf.nn.relu(inputs + shortcut)\",\n \"def ResBlock(input_tensor, filters):\\n \\n conv_1 = Conv2D(filters = filters, kernel_size = 3, padding = 'same', kernel_initializer = 'he_normal') \\n conv_1a = conv_1(input_tensor) # Shared weights conv layer\\n batch_1 = BatchNormalization()(conv_1a)\\n relu_1 = Activation(\\\"relu\\\")(batch_1)\\n drop_1 = Dropout(drop)(relu_1)\\n conv_1b = conv_1(drop_1) # Shared weights conv layer\\n batch_1 = BatchNormalization()(conv_1b)\\n return batch_1\",\n \"def custom_sum(*args):\\n return functools.reduce(lambda x, y: x + y, args)\",\n \"def custom_sum(*args):\\n return functools.reduce(lambda x, y: x + y, args)\",\n \"def reduce_sum_encoder(inputs):\\n return tf.reduce_sum(inputs, axis=1)\",\n \"def _residual_block(block_function, filters, repetitions, is_first_layer=False):\\n def f(input):\\n for i in range(repetitions):\\n init_strides = (1, 1)\\n if i == 0 and not is_first_layer:\\n init_strides = (2, 2)\\n input = block_function(filters=filters, init_strides=init_strides,\\n is_first_block_of_first_layer=(is_first_layer and i == 0))(input)\\n return input\\n\\n return f\",\n \"def _combine_task_specific_block(\\n feature,\\n weights,\\n biases,\\n model_spec,\\n scope=\\\"combine_task_specific_block\\\"\\n ):\\n with tf.variable_scope(scope):\\n task_dim = weights[0][0].shape[0].value\\n task_ones = tf.ones(shape=[task_dim])\\n feature_task_expanded = tf.einsum(\\n \\\"ik,j->ijk\\\",\\n feature,\\n task_ones\\n )\\n weights_combined = []\\n biases_combined = []\\n for i in range(len(weights[0])):\\n weights_combined.append(\\n weights[0][i] + weights[1][i]\\n )\\n biases_combined.append(\\n biases[0][i] + biases[1][i]\\n )\\n # in the special case only two layers: len(weights_combined) == 2 #\\n hidden_a = tf.einsum(\\n \\\"ijk,jlk->ijl\\\",\\n feature_task_expanded,\\n weights_combined[0]\\n )\\n hidden_a = hidden_a + biases_combined[0]\\n if model_spec[\\\"activation\\\"] is not None:\\n hidden_a = model_spec[\\\"activation\\\"](hidden_a)\\n hidden_a_dropout = tf.layers.dropout(\\n hidden_a,\\n rate=model_spec[\\\"dropout_task_hidden_a\\\"],\\n name=\\\"task_hidden_a_dropout\\\"\\n )\\n logits = tf.einsum(\\n \\\"ijk,jlk->ijl\\\",\\n hidden_a_dropout,\\n weights_combined[1]\\n )\\n logits = logits + biases_combined[1]\\n return logits\",\n \"def sum_plus(t, init):\\n total = init\\n for x in t:\\n total += x\\n return total\",\n \"def add_block2(_input, growth_rate, layers_per_block, bc_mode, is_training):\\n output = _input\\n for layer in range(layers_per_block):\\n with tf.variable_scope(\\\"layer_%d\\\" % layer):\\n output = add_internal_layer(output, growth_rate, bc_mode=bc_mode, is_training=is_training)\\n return output\",\n \"def plus(self, layer):\\n\\n input1 = self.node(layer)\\n if not input1:\\n return\\n LOGGER.debug('Plus layer to last:%s', layer)\\n if not self.last_node:\\n self.last_node = nuke.nodes.Constant()\\n\\n if layer not in self.layers():\\n input1 = nuke.nodes.Shuffle(inputs=[input1], out=layer)\\n self.last_node = nuke.nodes.Merge2(\\n inputs=[self.last_node, input1], operation='plus',\\n also_merge=layer if layer not in self.layers() else 'none',\\n label=utf8(self.l10n(layer)),\\n output='rgb')\",\n \"def _residual(self,\\n x,\\n in_filter,\\n out_filter,\\n stride,\\n activate_before_residual=False):\\n\\n if activate_before_residual:\\n with tf.variable_scope('shared_activation'):\\n x = self._batch_norm('init_bn', x)\\n x = self._relu(x, self._params.relu_leakiness)\\n orig_x = x\\n else:\\n with tf.variable_scope('residual_only_activation'):\\n orig_x = x\\n x = self._batch_norm('init_bn', x)\\n x = self._relu(x, self._params.relu_leakiness)\\n\\n with tf.variable_scope('sub1'):\\n x = self._conv('conv1', x, 3, in_filter, out_filter, stride)\\n\\n with tf.variable_scope('sub2'):\\n x = self._batch_norm('bn2', x)\\n x = self._relu(x, self._params.relu_leakiness)\\n x = self._conv('conv2', x, 3, out_filter, out_filter, [1, 1, 1, 1])\\n\\n with tf.variable_scope('sub_add'):\\n if in_filter != out_filter:\\n orig_x = tf.nn.avg_pool(orig_x, stride, stride, 'VALID')\\n orig_x = tf.pad(\\n orig_x, [[0, 0], [0, 0], [0, 0], [(out_filter - in_filter) // 2,\\n (out_filter - in_filter) // 2]])\\n x += orig_x\\n\\n return x\",\n \"def residual(n_filters, input):\\n shape = input.shape\\n _, h, w, d = shape\\n l1 = Conv2D(n_filters, (5, 5), padding='valid', activation='elu')(input)\\n l2 = Conv2D(n_filters, (1, 1), padding='valid', activation='linear')(l1)\\n l3 = Cropping2D(cropping=2)(input)\\n added = Add()([l2, l3])\\n return added\",\n \"def _res_block(self, X, name, out_channels):\\n \\n X_shortcut = X\\n X = self._mfm(X, name = name + '_mfm1', out_channels=out_channels, kernel_size=3, strides=1)\\n X = self._mfm(X, name = name + '_mfm2', out_channels=out_channels, kernel_size=3, strides=1)\\n X = Add()([X, X_shortcut])\\n return X\",\n \"def sum_():\\n\\n @sinks\\n def _dagpype_internal_fn_act(target):\\n try:\\n s = (yield)\\n while True:\\n s += (yield)\\n except GeneratorExit:\\n target.send(s)\\n target.close()\\n\\n return _dagpype_internal_fn_act\",\n \"def make_accumulator():\\n pass # replace with your solution\",\n \"def sum_sum(t, init):\\n return sum(t, init)\",\n \"def additional_equations(self, k):\\n ######################################################################\\n # equation for saturated liquid at hot side outlet\\n if self.subcooling.val is False:\\n o1 = self.outl[0].to_flow()\\n self.residual[k] = o1[2] - h_mix_pQ(o1, 0)\\n k += 1\",\n \"def identity_block(input_tensor, kernel_size, filters, stage, block):\\n filters0, filters1, filters2 = filters\\n conv_name_base = 'res' + str(stage) + block\\n bn_name_base = 'bn' + str(stage) + block\\n add_name = 'add' + str(stage) + \\\"_\\\" + block\\n relu_name = 'relu' + str(stage) + \\\"_\\\" + block\\n\\n # Tensors\\n input_tensor_chans = input_tensor.dims(\\n 3) if input_tensor.shape.layout == sg.NHWC else input_tensor.dims(1)\\n conv0_tensor = sg.Tensor(\\n data_layout=sg.NHWC, tensor_data=generate_random_data(\\n (filters0, 1, 1, input_tensor_chans)))\\n bn0_mean_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\\n bn0_var_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\\n bn0_gamma_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\\n bn0_beta_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\\n conv1_tensor = sg.Tensor(\\n data_layout=sg.NHWC, tensor_data=generate_random_data(\\n (filters1, kernel_size, kernel_size, filters0)))\\n bn1_mean_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\\n bn1_var_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\\n bn1_gamma_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\\n bn1_beta_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\\n conv2_tensor = sg.Tensor(\\n data_layout=sg.NHWC, tensor_data=generate_random_data(\\n (filters2, 1, 1, filters1)))\\n bn2_mean_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\\n bn2_var_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\\n bn2_gamma_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\\n bn2_beta_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\\n\\n x = sg.nn.convolution(\\n input_tensor, conv0_tensor, stride=[1, 1], padding=\\\"same\\\",\\n name=conv_name_base + '_2a')\\n x = sg.nn.batch_norm(\\n x, bn0_mean_tensor, bn0_var_tensor, bn0_gamma_tensor, bn0_beta_tensor,\\n activation=\\\"relu\\\", name=bn_name_base + '_2a')\\n x = sg.nn.convolution(\\n x, conv1_tensor, stride=[1, 1], padding=\\\"same\\\",\\n name=conv_name_base + '_2b')\\n x = sg.nn.batch_norm(\\n x, bn1_mean_tensor, bn1_var_tensor, bn1_gamma_tensor, bn1_beta_tensor,\\n activation=\\\"relu\\\", name=bn_name_base + '_2b')\\n x = sg.nn.convolution(\\n x, conv2_tensor, stride=[1, 1], padding=\\\"same\\\",\\n name=conv_name_base + '_2c')\\n x = sg.nn.batch_norm(\\n x, bn2_mean_tensor, bn2_var_tensor, bn2_gamma_tensor, bn2_beta_tensor,\\n name=bn_name_base + '_2c')\\n x = sg.math.add(x, input_tensor, name=add_name)\\n x = sg.nn.relu(x, name=relu_name)\\n return x\",\n \"def get_sum(a,b):\\n return\",\n \"def __iadd__(self, term):\\n self.add(term)\\n return self\",\n \"def add(self, term):\\n self._value = self.accum_param.addInPlace(self._value, term)\",\n \"def _building_block_v1(inputs, filters, training, projection_shortcut, strides,\\n data_format):\\n shortcut = inputs\\n\\n if projection_shortcut is not None:\\n shortcut = projection_shortcut(inputs)\\n shortcut = batch_norm(inputs=shortcut, training=training,\\n data_format=data_format)\\n\\n inputs = conv2d_fixed_padding(\\n inputs=inputs, filters=filters, kernel_size=3, strides=strides,\\n data_format=data_format)\\n inputs = batch_norm(inputs, training, data_format)\\n inputs = tf.nn.relu(inputs)\\n\\n inputs = conv2d_fixed_padding(\\n inputs=inputs, filters=filters, kernel_size=3, strides=1,\\n data_format=data_format)\\n inputs = batch_norm(inputs, training, data_format)\\n inputs += shortcut\\n inputs = tf.nn.relu(inputs)\\n\\n return inputs\",\n \"def _building_block_v2(inputs, filters, training, \\n projection_shortcut, strides,\\n data_format):\\n shortcut = inputs\\n inputs = batch_norm(inputs, training, data_format)\\n inputs = tf.nn.relu(inputs)\\n ENDING_POINTS.append(inputs)\\n\\n # The projection shortcut should come after the first batch norm and ReLU\\n # since it performs a 1x1 convolution.\\n if projection_shortcut is not None:\\n shortcut = projection_shortcut(inputs)\\n\\n inputs = conv3d_fixed_padding(\\n inputs=inputs, filters=filters, kernel_size=3, \\n time_kernel_size=3, strides=strides,\\n data_format=data_format, time_stride=strides)\\n\\n inputs = batch_norm(inputs, training, data_format)\\n inputs = tf.nn.relu(inputs)\\n inputs = conv3d_fixed_padding(\\n inputs=inputs, filters=filters, kernel_size=3, \\n time_kernel_size=3, strides=1,\\n data_format=data_format)\\n\\n return inputs + shortcut\",\n \"def identity_block(X, f, filters, stage, block):\\n \\n # Defines name basis.\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n \\n # Retrieves Filters.\\n F1, F2, F3 = filters\\n \\n # Saves the input value. This is needed later to add back to the main path. \\n X_shortcut = X\\n \\n ##### MAIN PATH #####\\n # First component of main path.\\n X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform())(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\\n X = Activation('relu')(X)\\n \\n \\n # Second component of main path.\\n X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform())(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\\n X = Activation('relu')(X)\\n \\n # Third component of main path.\\n X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c', kernel_initializer = glorot_uniform())(X)\\n X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\\n\\n\\n # Final step: Adds shortcut value to main path, and pass it through a RELU activation.\\n X = Add()([X, X_shortcut])\\n X = Activation('relu')(X)\\n\\n return X\",\n \"def residual_module(in_block, K, stride, chanDim, red=False,\\n reg= 1e-4, bnEps=2e-5, bnMom=.9):\\n\\n x = in_block\\n chan_in = in_block.shape.as_list()[-1]\\n bn1 = BatchNormalization(axis=chanDim, epsilon=bnEps, momentum=bnMom)(x)\\n relu1 = Activation(\\\"relu\\\")(bn1)\\n conv1 = Conv2D(filters=int(K * .25), kernel_size=(1, 1),\\n use_bias=False,\\n kernel_regularizer=l2(reg))(relu1) #Conv2D learns 1/4(0.25) of the last conv filter\\n\\n bn2 = BatchNormalization(axis=chanDim, epsilon=bnEps, momentum=bnMom)(conv1)\\n relu2 = Activation(\\\"relu\\\")(bn2)\\n conv2 = Conv2D(filters=int(K * .25), kernel_size=(3, 3), strides=stride,\\n padding=\\\"same\\\",\\n use_bias=False,\\n kernel_regularizer=l2(reg))(relu2) #Conv2D learns 1/4(0.25) of the last conv filter\\n\\n bn3 = BatchNormalization(axis=chanDim, epsilon=bnEps, momentum=bnMom)(conv2)\\n relu3 = Activation(\\\"relu\\\")(bn3)\\n conv3 = Conv2D(filters=K, kernel_size=(1, 1),\\n kernel_regularizer=l2(reg))(relu3)\\n\\n if red:\\n x = Conv2D(filters=K, kernel_size=(1, 1), strides=stride,\\n kernel_regularizer=l2(reg))(relu1)\\n x = se_block(x)\\n return add([x, conv3])\",\n \"def __add__(self,that):\\n return self.__opExpand2(that,np.add)\",\n \"def add_block(_input, growth_rate, layers_per_block, bc_mode, name, is_training):\\n output = _input\\n for layer in range(layers_per_block):\\n with tf.variable_scope(\\\"%s_layer_%d\\\" % (name, layer)):\\n output = add_internal_layer(output, growth_rate, bc_mode=bc_mode, is_training=is_training)\\n return output\",\n \"def __add__(self, region):\\n return Sequence(\\n self.weight + region.weight,\\n region.finish,\\n (*self.regs, region)\\n )\",\n \"def __iadd__(self,that):\\n #return self.__opExpand1(that,np.add, out=self)\\n return self.__opExpand2(that,np.add, out=self)\",\n \"def add(self, params):\\n if len(params) < 2:\\n return\\n x = self.reg_dct[params[0]]\\n y = self.reg_dct[params[1]]\\n self.reg_dct[params[0]] = (x + y) % (2** 32)\",\n \"def test_tensor_can_be_added_summation(free_alg):\\n\\n dr = free_alg\\n p = dr.names\\n i, j = p.R_dumms[:2]\\n x = IndexedBase('x')\\n y = IndexedBase('y')\\n\\n tensor = dr.sum((i, p.R), x[i, j] * y[j, i])\\n\\n for res in [\\n dr.einst(tensor),\\n dr.sum((j, p.R), tensor)\\n ]:\\n assert res == dr.einst(x[i, j] * y[j, i])\",\n \"def sum(self, start=0, end=None):\\n return super().reduce(start, end)\",\n \"def attn_sum_bahdanau(v_attn, keys, query):\\n return tf.reduce_sum(v_attn * tf.tanh(keys + tf.expand_dims(query, 1)), [2])\",\n \"def add_input(self, accumulator, batch: input_batch.InputBatch) -> int:\\n null_mask = batch.null_mask(self._path)\\n if self._required_paths:\\n required_null_mask = batch.all_null_mask(*self._required_paths)\\n null_mask = null_mask & ~required_null_mask\\n return accumulator + np.sum(null_mask)\",\n \"def chamfer_sum(a,b):\\n #tf.print(a)\\n #tf.print(a[0,0,:])\\n #tf.print(b[0,0,:])\\n M = pairwise_distances(a, b)\\n if len(M.shape) == 2:\\n M = tf.expand_dims(M,0) #[np.newaxis, :, :]\\n #return tf.keras.backend.sum(tf.reduce_sum(tf.reduce_min(M, 1), 1) + tf.reduce_sum(tf.reduce_min(M, 2), 1))\\n c=tf.reduce_sum(tf.reduce_min(M, 1), 1) + tf.reduce_sum(tf.reduce_min(M, 2), 1)\\n #tf.print(tf.reduce_sum(c))\\n return c\",\n \"def block_reduction_a(self, inputs, scope=None, reuse=None):\\n # By default use stride=1 and SAME padding\\n with slim.arg_scope([slim.conv2d, slim.avg_pool2d, slim.max_pool2d],\\n stride=1, padding='SAME'):\\n with tf.variable_scope(scope, 'BlockReductionA', [inputs], reuse=reuse):\\n with tf.variable_scope('Branch_0'):\\n branch_0 = slim.conv2d(inputs, 384, [3, 3], stride=2, padding='VALID',\\n scope='Conv2d_1a_3x3')\\n with tf.variable_scope('Branch_1'):\\n branch_1 = slim.conv2d(inputs, 192, [1, 1], scope='Conv2d_0a_1x1')\\n branch_1 = slim.conv2d(branch_1, 224, [3, 3], scope='Conv2d_0b_3x3')\\n branch_1 = slim.conv2d(branch_1, 256, [3, 3], stride=2,\\n padding='VALID', scope='Conv2d_1a_3x3')\\n with tf.variable_scope('Branch_2'):\\n branch_2 = slim.max_pool2d(inputs, [3, 3], stride=2, padding='VALID',\\n scope='MaxPool_1a_3x3')\\n return tf.concat(axis=3, values=[branch_0, branch_1, branch_2])\",\n \"def addition_homework(data: Iterator[str]) -> int:\\n n = final_sum(data)\\n return n.magnitude\",\n \"def conv_block(\\n input_tensor, kernel_size, filters, stage, block, strides=(2, 2)):\\n filters0, filters1, filters2 = filters\\n conv_name_base = 'res' + str(stage) + block\\n bn_name_base = 'bn' + str(stage) + block\\n add_name = 'add' + str(stage) + \\\"_\\\" + block\\n relu_name = 'relu' + str(stage) + \\\"_\\\" + block\\n\\n # sg.Tensors\\n input_tensor_chans = input_tensor.dims(\\n 3) if input_tensor.shape.layout == sg.NHWC else input_tensor.dims(1)\\n conv0_tensor = sg.Tensor(\\n data_layout=sg.NHWC, tensor_data=generate_random_data(\\n (filters0, 1, 1, input_tensor_chans)))\\n bn0_mean_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\\n bn0_var_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\\n bn0_gamma_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\\n bn0_beta_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters0)))\\n conv1_tensor = sg.Tensor(\\n data_layout=sg.NHWC, tensor_data=generate_random_data(\\n (filters1, kernel_size, kernel_size, filters0)))\\n bn1_mean_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\\n bn1_var_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\\n bn1_gamma_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\\n bn1_beta_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters1)))\\n conv2_tensor = sg.Tensor(\\n data_layout=sg.NHWC, tensor_data=generate_random_data(\\n (filters2, 1, 1, filters1)))\\n bn2_mean_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\\n bn2_var_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\\n bn2_gamma_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\\n bn2_beta_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\\n conv3_tensor = sg.Tensor(\\n data_layout=sg.NHWC, tensor_data=generate_random_data(\\n (filters2, 1, 1, input_tensor_chans)))\\n bn3_mean_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\\n bn3_var_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\\n bn3_gamma_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\\n bn3_beta_tensor = sg.Tensor(\\n data_layout=sg.NC, tensor_data=generate_random_data((1, filters2)))\\n\\n x = sg.nn.convolution(\\n input_tensor, conv0_tensor, stride=[1, 1], padding=\\\"same\\\",\\n name=conv_name_base + '_2a')\\n x = sg.nn.batch_norm(\\n x, bn0_mean_tensor, bn0_var_tensor, bn0_gamma_tensor, bn0_beta_tensor,\\n activation=\\\"relu\\\")\\n x = sg.nn.convolution(\\n x, conv1_tensor, stride=strides, padding=\\\"same\\\",\\n name=conv_name_base + '_2b')\\n x = sg.nn.batch_norm(\\n x, bn1_mean_tensor, bn1_var_tensor, bn1_gamma_tensor, bn1_beta_tensor,\\n activation=\\\"relu\\\", name=bn_name_base + '_2b')\\n x = sg.nn.convolution(\\n x, conv2_tensor, stride=[1, 1], padding=\\\"same\\\",\\n name=conv_name_base + '_2c')\\n x = sg.nn.batch_norm(\\n x, bn2_mean_tensor, bn2_var_tensor, bn2_gamma_tensor, bn2_beta_tensor,\\n name=bn_name_base + '_2c')\\n shortcut = sg.nn.convolution(\\n input_tensor, conv3_tensor, stride=strides, padding=\\\"same\\\",\\n name=conv_name_base + '_1')\\n shortcut = sg.nn.batch_norm(\\n shortcut, bn3_mean_tensor, bn3_var_tensor, bn3_gamma_tensor,\\n bn3_beta_tensor, name=bn_name_base + '_1')\\n x = sg.math.add(x, shortcut, name=add_name)\\n x = sg.nn.relu(x, name=relu_name)\\n return x\",\n \"def addRes(res1, res2):\\n return [(x + y) for x, y in zip(res1, res2)]\",\n \"def combine_and_select_block(self, first):\\n block = self.combine_block(first)\\n self.combined.append(block)\",\n \"def compute_partials(self, inputs, partials):\\n partials['y', 'x'] = 2.0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6083529","0.5894693","0.5735994","0.56371546","0.5619291","0.5514519","0.5502387","0.5502087","0.54550755","0.54191214","0.54108816","0.5387289","0.53559756","0.5333165","0.53286403","0.5305475","0.5285419","0.5280931","0.5280322","0.52757835","0.52651584","0.5226238","0.51707584","0.5166492","0.5157738","0.5149284","0.5146962","0.5143549","0.5135152","0.5133739","0.5133739","0.51181805","0.5112227","0.50783056","0.50556105","0.5049382","0.50405335","0.5034451","0.501865","0.5014752","0.501416","0.5004759","0.50024974","0.50016445","0.49969983","0.49855515","0.49635902","0.4958141","0.49513847","0.49402955","0.4933999","0.493056","0.49005392","0.49005392","0.49005392","0.49005392","0.49005392","0.48994178","0.48689172","0.48619723","0.48616308","0.486131","0.486131","0.48606828","0.48468104","0.4839924","0.48362008","0.48349166","0.4833033","0.48290336","0.482136","0.48125598","0.48067382","0.48051438","0.47974223","0.4793421","0.47857055","0.47842354","0.4776741","0.47717035","0.47597125","0.47560155","0.47559467","0.47557437","0.47436547","0.47431573","0.4741686","0.47385788","0.47341672","0.47335073","0.47303116","0.47294116","0.47254378","0.47253445","0.47228637","0.47226715","0.4718978","0.4718711","0.47092474","0.47049385"],"string":"[\n \"0.6083529\",\n \"0.5894693\",\n \"0.5735994\",\n \"0.56371546\",\n \"0.5619291\",\n \"0.5514519\",\n \"0.5502387\",\n \"0.5502087\",\n \"0.54550755\",\n \"0.54191214\",\n \"0.54108816\",\n \"0.5387289\",\n \"0.53559756\",\n \"0.5333165\",\n \"0.53286403\",\n \"0.5305475\",\n \"0.5285419\",\n \"0.5280931\",\n \"0.5280322\",\n \"0.52757835\",\n \"0.52651584\",\n \"0.5226238\",\n \"0.51707584\",\n \"0.5166492\",\n \"0.5157738\",\n \"0.5149284\",\n \"0.5146962\",\n \"0.5143549\",\n \"0.5135152\",\n \"0.5133739\",\n \"0.5133739\",\n \"0.51181805\",\n \"0.5112227\",\n \"0.50783056\",\n \"0.50556105\",\n \"0.5049382\",\n \"0.50405335\",\n \"0.5034451\",\n \"0.501865\",\n \"0.5014752\",\n \"0.501416\",\n \"0.5004759\",\n \"0.50024974\",\n \"0.50016445\",\n \"0.49969983\",\n \"0.49855515\",\n \"0.49635902\",\n \"0.4958141\",\n \"0.49513847\",\n \"0.49402955\",\n \"0.4933999\",\n \"0.493056\",\n \"0.49005392\",\n \"0.49005392\",\n \"0.49005392\",\n \"0.49005392\",\n \"0.49005392\",\n \"0.48994178\",\n \"0.48689172\",\n \"0.48619723\",\n \"0.48616308\",\n \"0.486131\",\n \"0.486131\",\n \"0.48606828\",\n \"0.48468104\",\n \"0.4839924\",\n \"0.48362008\",\n \"0.48349166\",\n \"0.4833033\",\n \"0.48290336\",\n \"0.482136\",\n \"0.48125598\",\n \"0.48067382\",\n \"0.48051438\",\n \"0.47974223\",\n \"0.4793421\",\n \"0.47857055\",\n \"0.47842354\",\n \"0.4776741\",\n \"0.47717035\",\n \"0.47597125\",\n \"0.47560155\",\n \"0.47559467\",\n \"0.47557437\",\n \"0.47436547\",\n \"0.47431573\",\n \"0.4741686\",\n \"0.47385788\",\n \"0.47341672\",\n \"0.47335073\",\n \"0.47303116\",\n \"0.47294116\",\n \"0.47254378\",\n \"0.47253445\",\n \"0.47228637\",\n \"0.47226715\",\n \"0.4718978\",\n \"0.4718711\",\n \"0.47092474\",\n \"0.47049385\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.515336"},"document_rank":{"kind":"string","value":"25"}}},{"rowIdx":5489,"cells":{"query":{"kind":"string","value":"Patching out the functions in CrimeIncidentsIntent that use requests.get"},"document":{"kind":"string","value":"def setUp(self):\n super().setUp()\n self.get_crime_incident_response = \\\n mock.patch(\n ('mycity.intents.crime_activity_intent.'\n 'get_crime_incident_response'),\n return_value=test_constants.GET_CRIME_INCIDENTS_API_MOCK)\n self.get_crime_incident_response.start()\n response = self.controller.on_intent(self.request)\n for record in MOCK_RESPONSE[RESULT][RECORDS]:\n self.assertIn(record[STREET], response.output_speech)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _external_request(self, method, url, *args, **kwargs):\n self.last_url = url\n if url in self.responses.keys() and method == 'get':\n return self.responses[url] # return from cache if its there\n\n headers = kwargs.pop('headers', None)\n custom = {'User-Agent': useragent}\n if headers:\n headers.update(custom)\n kwargs['headers'] = headers\n else:\n kwargs['headers'] = custom\n\n response = getattr(requests, method)(url, *args, **kwargs)\n\n if self.verbose:\n print(\"Got Response: %s\" % url)\n\n if response.status_code == 503:\n raise SkipThisService(\"Service returned 503 - Temporarily out of service.\")\n\n if method == 'get':\n self.responses[url] = response # cache for later\n\n self.last_raw_response = response\n return response","def test_request_should_not_include_token(self):\n client = Client()\n\n with patch(\"requests.request\") as request:\n request.return_value.json.return_value = {}\n\n client.request(\"GET\", \"http://www.google.com/\")\n\n request.assert_called_once_with(\n \"GET\",\n \"http://www.google.com/\",\n headers=None,\n json=None,\n params=b\"per_page=100\",\n )","def mocked_requests_scrapping_get(*args, **kwargs):\n class MockResponse:\n def __init__(self, json_data, status_code, url):\n self.content = json_data\n self.status_code = status_code\n self.url = url\n self.cookies = {\"JSESSIONID\": \"jkghhjgjhgfjgfgjg\"}\n self.encoding = \"utf-8\"\n\n def json(self):\n return self.json_data\n\n dn = os.path.dirname(os.path.realpath(__file__))\n for url, provider in {f\"{settings.BASE_URL}/eAnnuaire/formulaire?appelRetour=true\": \"form\",\n f\"{settings.BASE_URL}/eAnnuaire/resultat\": \"suivant\",\n f\"{settings.BASE_URL}/eAnnuaire/fiche\": \"detail\"}.items():\n if args[0].startswith(url):\n with open(os.path.join(dn, \"fixtures\", f\"{provider}.html\"), \"rb\") as fp:\n return MockResponse(fp.read(), 200, args[0])","def get(self, request):\n pass","def test_client_can_load_client_page_requests_directly(self):\n\n req = self.httpbin_3.get_request_data('get_my_ip')\n\n self.assertEqual(req, self.httpbin_3.client[\"homepage\"]['get_my_ip'])\n req = self.httpbin_3.get_request_data('test_requests_patch_method')\n self.assertEqual(req, self.httpbin_3.client[\"homepage\"]['test_requests_patch_method'])\n req = self.httpbin_3.get_request_data('test_requests_delete_method')\n self.assertEqual(req, self.httpbin_3.client[\"second_page\"]['test_requests_delete_method'])\n\n req = self.httpbin_4.get_request_data('get_my_ip')\n self.assertEqual(req, self.httpbin_4.client['get_my_ip'])\n req = self.httpbin_4.get_request_data('get_user_my_agent')\n self.assertEqual(req, self.httpbin_4.client['get_user_my_agent'])\n req = self.httpbin_4.get_request_data('test_requests_put_method')\n self.assertEqual(req, self.httpbin_4.client['test_requests_put_method'])\n req = self.httpbin_4.get_request_data('test_requests_post_method')\n self.assertEqual(req, self.httpbin_4.client['test_requests_post_method'])","def test_get(self):\n return self.doRequest(self.url, method=\"GET\", body=self.input)","def request(self, url, *args, **kwargs):\n raise NotImplementedError","def aget(url, **kwargs):\n return requests.get(url, **kwargs)","def rhsa(monkeypatch, mock_get):\n monkeypatch.delattr('requests.sessions.Session.request')\n monkeypatch.setattr(ErrataConnector, '_auth', None)\n monkeypatch.setattr(requests, 'get', mock_get)\n return Erratum(errata_id=36762)","def requester(get_args: dict) -> dict:\n get_args.update(dict(apikey = apikey))\n response = requests.get(URL, params = get_args)\n return response.json()","def _request(self, url, **kwargs):\n headers = {'PRIVATE-TOKEN': self.token}\n response = make_request(self.base_url + url, headers=headers, **kwargs)\n logging.info('Requested: {0}'.format(url))\n logging.info('Method: {0}'.format(kwargs.get('method', 'GET')))\n logging.info(response.content)\n return json.loads(response.content)","def get_request(req_context, uri):\n headers = { 'Accept': \"application/json\", \n 'User-Agent': \"testApp\"\n }\n if config.ENVIRONMENT == \"Sandbox\":\n base_url = \"https://sandbox-quickbooks.api.intuit.com/v3/company/\"\n else:\n base_url = \"https://quickbooks.api.intuit.com/v3/company/\"\n url = base_url + req_context.realm_id + uri\n print(url)\n if config.AUTH_TYPE == \"OAuth2\":\n headers['Authorization'] = \"Bearer \" + req_context.access_token\n req = requests.get(url, headers=headers)\n else:\n auth = OAuth1(req_context.consumer_key, req_context.consumer_secret, req_context.access_key, req_context.access_secret)\n req = requests.get(url, auth=auth, headers=headers)\n return req","def crime_data_fbi(request):\n http = urllib3.PoolManager()\n\n # Getting the request arguments for city, distance , start date and end date \n\n #request_args = request.args\n #print('request_args')\n #ori=request_args['ori']\n #start_date=request_args['start_date']\n #end_date=request_args['end_date']\n #distance=request_args['distance']\n base_url=fbi_url(request)\n print(base_url)\n \n # New request url \n request_url = base_url\n print(request_url)\n \n print(\"i am inside the functino\")\n payload = http.request('GET',\n request_url,\n headers={\n 'Content-Type': 'application/json',\n 'x-api-key': creds\n },\n fields={\n 'API_KEY':creds\n }\n )\n\n #*** only changing it for testing ***\n #return request_url\n print(payload)\n return payload","def get_request(url):\n\tr = requests.get(url)\n\treturn(r)","def mock_requests_get(mocker, mocked_requests_get):\n\n def _requests_get(module, content, status):\n mock_func = mocker.patch(f'{module}.requests.get')\n mock_func.return_value = mocked_requests_get(content, status)\n\n return _requests_get","def do_GET(self):\n self.log.debug('do_GET called')\n self.HeadGet('GET')","def request( # pylint: disable=arguments-differ\n self, method: str, url: str, **kwargs\n ) -> object:\n if self.base_url is not None and not url.startswith('https'):\n url = f'{self.base_url}{url}'\n\n # this kwargs value is used to signal 429 handling that this is a retry, but the super\n # method doesn't expect it so it needs to be removed.\n tc_is_retry = kwargs.pop('tc_is_retry', False)\n\n response: Response = super().request(method, url, **kwargs)\n\n if response.status_code == 429 and not tc_is_retry:\n too_many_requests_handler = self.too_many_requests_handler\n time.sleep(too_many_requests_handler(response))\n kwargs['tc_is_retry'] = True\n return self.request(method, url, **kwargs)\n\n # APP-79 - adding logging of request as curl commands\n if not response.ok or self.log_curl:\n try:\n self.log.debug(\n self.requests_to_curl.convert(\n response.request,\n mask_body=self.mask_body,\n mask_headers=self.mask_headers,\n mask_patterns=self.mask_patterns,\n proxies=self.proxies,\n verify=self.verify,\n )\n )\n except Exception: # nosec\n pass # logging curl command is best effort\n\n self.log.debug(\n f'feature=external-session, request-url={response.request.url}, '\n f'status_code={response.status_code}, elapsed={response.elapsed}'\n )\n\n return response","def do_request(method, url, data=None, headers=None):\n try:\n if method == 'GET':\n resp = requests.get(url, headers=headers)\n return resp\n elif method == 'POST':\n resp = requests.post(url, json=data, headers=headers)\n return resp\n elif method == 'PATCH':\n resp = requests.patch(url, json=data, headers=headers)\n return resp\n except Exception, e:\n print \"Retry {} with {}, {}\".format(str(e), url, data)\n raise e","def cached():\n ##from pprint import pprint\n # let's restrict this to the api server, to avoid shenanigans\n root_relative_url = request.env.request_uri.split('/cached/')[-1]\n ##pprint('ROOT-RELATIVE URL: ')\n ##pprint(root_relative_url)\n fetch_url = '%s://%s/%s' % (request.env.wsgi_url_scheme, request.env.http_host, root_relative_url)\n ##pprint('PROXYING TO SIMPLE URL: ')\n ##pprint(fetch_url)\n\n # permissive CORS handling of requests from another domain (e.g. tree.opentreeoflife.org)\n if request.env.request_method == 'OPTIONS':\n if request.env.http_access_control_request_method:\n response.headers['Access-Control-Allow-Methods'] = request.env.http_access_control_request_method\n if request.env.http_access_control_request_headers:\n response.headers['Access-Control-Allow-Headers'] = request.env.http_access_control_request_headers\n ##pprint('RESPONDING TO OPTIONS')\n raise HTTP(200, **(response.headers))\n\n # N.B. This try/except block means we'll cache errors. For now, the fix is to clear the entire cache.\n try:\n # fetch the latest IDs as JSON from remote site\n import simplejson\n\n if fetch_url.startswith('//'):\n # Prepend scheme to a scheme-relative URL\n fetch_url = \"http:%s\" % fetch_url\n\n fetch_args = request.vars # {'startingTaxonOTTId': \"\"}\n\n # TODO: For more flexibility, we should examine and mimic the original request (HTTP verb, headers, etc)\n\n # this needs to be a POST (pass fetch_args or ''); if GET, it just describes the API\n # N.B. that gluon.tools.fetch() can't be used here, since it won't send \"raw\" JSON data as treemachine expects\n req = urllib2.Request(url=fetch_url, data=simplejson.dumps(fetch_args), headers={\"Content-Type\": \"application/json\"}) \n the_response = urllib2.urlopen(req).read()\n ##pprint('RESPONSE:')\n ##pprint(the_response)\n return the_response\n\n except Exception, e:\n # throw 403 or 500 or just leave it\n return ('ERROR', e.message)","def live_url_request(url, arg):\n if arg == \"-m\":\n json_response = requests.get(url)\n\n elif arg == \"-l\":\n live_token= get_live_token()\n json_response = requests.get(url, headers={\"PRIVATE-TOKEN\": live_token})\n return json_response","def _request(self, *args):\n raise NotImplementedError","def getFromCache(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def _get(self, url):\n return self._request(url)","def mock_requests_get(request, monkeypatch, mock_get_args):\n\n def mock_get(url, *args, **kwargs):\n mock_get_args(url, *args, **kwargs)\n\n mock_resp = MagicMock()\n if url == qml.data.data_manager.FOLDERMAP_URL:\n json_data = _folder_map\n elif url == qml.data.data_manager.DATA_STRUCT_URL:\n json_data = _data_struct\n else:\n json_data = None\n\n mock_resp.json.return_value = json_data\n if hasattr(request, \"param\"):\n mock_resp.content = request.param\n\n return mock_resp\n\n monkeypatch.setattr(qml.data.data_manager, \"get\", mock_get)\n\n return mock_get","def _call_api(self, verb, url, **request_kwargs):\n api = 'https://api.github.com{}'.format(url)\n auth_headers = {'Authorization': 'token {}'.format(self.api_token)}\n headers = {**auth_headers, **request_kwargs.pop('headers', {})}\n return getattr(requests, verb)(api, headers=headers, **request_kwargs)","def patch_get(request):\n try:\n mp = request.getfixturevalue(\"monkeypatch\")\n except AttributeError: # pytest < 3\n mp = request.getfuncargvalue(\"monkeypatch\")\n mp.setattr(requests.Session, 'request', get_mockreturn)\n return mp","def step_impl(context, query):\n url = context.base_url+query\n print('url:',url,'\\n')\n with closing(requests.get(url)) as response:\n context.response = response\n context.response_json = response.json()","def url_for_request(self, method, extras):\n raise NotImplementedError(\"Should be overriden by subclass\")","def test_request_extra_allowed_codes():\n mocked_codes = {\"codes\": [HTTPCreated.code, HTTPOk.code, HTTPCreated.code]} # note: used in reverse order\n\n def mocked_request(*_, **__):\n mocked_resp = Response()\n mocked_resp.status_code = mocked_codes[\"codes\"].pop()\n return mocked_resp\n\n with mock.patch(\"requests.Session.request\", side_effect=mocked_request) as mocked:\n resp = request_extra(\"get\", \"http://whatever\", retries=3, allowed_codes=[HTTPOk.code])\n assert resp.status_code == HTTPOk.code\n assert mocked.call_count == 2","def GetCustomInterest(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def _make_request_with_auth_fallback(self, url, headers=None, params=None):\n self.log.debug(\"Request URL and Params: %s, %s\", url, params)\n try:\n resp = requests.get(\n url,\n headers=headers,\n verify=self._ssl_verify,\n params=params,\n timeout=DEFAULT_API_REQUEST_TIMEOUT,\n proxies=self.proxy_config,\n )\n resp.raise_for_status()\n except requests.exceptions.HTTPError as e:\n self.log.debug(\"Error contacting openstack endpoint: %s\", e)\n if resp.status_code == 401:\n self.log.info('Need to reauthenticate before next check')\n\n # Delete the scope, we'll populate a new one on the next run for this instance\n self.delete_current_scope()\n elif resp.status_code == 409:\n raise InstancePowerOffFailure()\n elif resp.status_code == 404:\n raise e\n else:\n raise\n\n return resp.json()","def __call__(self, request):\n response = self.get_request(request)\n return response","def test_request_fetch(response, mocker):\n mocker.patch(\"requests.get\", autospec=True)\n requests.get.return_value = response\n request.fetch(\"http://localhost\")\n requests.get.assert_called_with(\"http://localhost\", request.headers)","def requestURL(userID): #@NoSelf","def _make_request(self, url: str, parameters: dict = None,\n method: str = 'GET', *args, **kwargs):\n response = requests.request(\n method=method,\n url=build_url(\n self.BASE_API_URL, url, parameters\n ),\n headers={\n 'Authorization': 'Bearer {}'.format(self._access_token)\n }, **kwargs\n )\n if response.ok:\n return response.json()\n raise MondoApiException(response.json()['message'])","def do_GET(self):\n self.http_method = 'GET'\n self.response()","def _Dynamic_Fetch(self, request, response):\n print \"Request:\"\n print (\"Request: {}\").format(request)\n response.set_content(self.mock_response_issue)\n response.set_statuscode(200)\n new_header = response.add_header()\n new_header.set_key('Content-type')\n new_header.set_value('application/json')\n\n response.set_finalurl(request.url)\n response.set_contentwastruncated(False)\n\n # allow to query the object after it is used\n # pylint: disable=attribute-defined-outside-init\n self.request = request\n self.response = response","def _make_get_request(self,url,object_fh,params=None,return_type=None,extras=None):\n \n if params is None:\n params = {}\n \n if extras is None:\n extras = {}\n \n #Polite Pool Work\n #---------------------------------------\n #Example \n #GroovyBib/1.1 (https://example.org/GroovyBib/; mailto:GroovyBib@example.org) BasedOnFunkyLib/1.4.\n\n #It is unclear if we need to match this format\n #This is good enough for now\n #Eventually we might allow a user to describe their application\n #version, and url\n ua_str = 'st_crossref/%s (https://github.com/ScholarTools/crossref_api_python; mailto:%s)' % (VERSION,user_config.email)\n \n headers = {'user-agent': ua_str}\n \n \n #TODO Check params and # of results ...\n \n #TODO: Implement rate limits ...\n \n \n #The params get passed directly\n r = self.session.get(url,params=params,headers=headers) \n \n\n #Update limits\n #--------------------- \n headers = r.headers\n self.rate_limit = headers.get('X-Rate-Limit-Limit',50)\n self.rate_limit_interval = int(headers.get('X-Rate-Limit-Interval','1s')[:-1])\n \n #TODO: Implement ...https://konghq.com/blog/how-to-design-a-scalable-rate-limiting-algorithm/\n \n\n #These are debug only and should not be used for anything else\n #-------------------------------------------------------------\n self.last_url = url\n self.last_response = r \n self.last_params = params \n \n if r.status_code == 404:\n #This typically happens when the DOI is invalid\n #TODO: Make this a named exception\n raise errors.RequestError(r.text)\n \n json_data = r.json()\n if json_data['status'] == 'failed':\n self.last_error = json_data\n raise errors.CrossrefAPIError(json_data['message'])\n \n #Example error \n \"\"\"\n {'status': 'failed', 'message-type': 'validation-failure', \n 'message': [{'value': 'sample', \n 'message': 'This route does not support sample', 'type': 'parameter-not-allowed'}]}\n \"\"\" \n \n #TODO: return_type\n if return_type == 'json' or object_fh is None:\n return json_data\n else:\n return object_fh(json_data,self)","def request(self, flow: mitmproxy.http.HTTPFlow):","def request(self, flow: mitmproxy.http.HTTPFlow):","def http_get(config_args):\n #global config_args\n \n \n try:\n #r = requests.get(config_args.address,headers=headers,verify=config_args.cacert)\n if 'https' in config_args.address.lower() and config_args.host != None:\n headers = {'host': config_args.host}\n r = requests.get(config_args.address,headers=headers,verify=False)\n #print(config_args.address.lower())\n elif 'https' in config_args.address.lower() and config_args.host == None:\n r = requests.get(config_args.address,verify=False)\n print(config_args.address.lower())\n else:\n r = requests.get(config_args.address)\n\n if r.status_code != 200 and r.status_code != 301 and r.status_code != 302:\n print(\"Request failed...code: {}\".format(r.status_code))\n except KeyboardInterrupt:\n print ('Stopping now....')\n try:\n sys.exit(0)\n except SystemExit:\n os._exit(0) \n \n return r","def get_response(request_url):\n return requests.get(request_url)","def reddit_request(url, params):\n payload = params\n keys=payload.keys()\n if 'user-agent' not in keys:\n payload['user-agent'] = 'downtime'\n else:\n pass\n return requests.get(url, params=payload)","def _get(self, request_obj):\n return self._execute_action(request_obj, 'GET')","def fetch_requests(v1):\n \n #check if user has any requests\n if len(all_requests) < 1:\n return jsonify({\n \"message\":\"You have not made any requests yet\"\n })\n \n #if user has more than one request\n if len(all_requests) >= 1:\n return jsonify({\n \"message\":\"Successfully fetched requests\",\n \"requests\":[\n a_request.__dict__ for a_request in all_requests\n ]\n })\n return jsonify({\"message\":\"Can not fetch requests now\"})","def do_GET(self):\n self._try_to_process_request(self._handle_get_request)","def basic_requests(url):\r\n # get requests\r\n response = requests.get(base_url+'/get')\r\n print(response.status_code)\r\n\r\n time.sleep(3)\r\n print(\"Sleep 3 seconds\")\r\n # post requests\r\n response = requests.post(base_url+'/post')\r\n print(response.status_code)\r\n\r\n time.sleep(2)\r\n print(\"Sleep 3 seconds\")\r\n response = requests.put(base_url + '/put')\r\n print(response.status_code)\r\n\r\n time.sleep(2)\r\n print(\"Sleep 3 seconds\")\r\n response = requests.delete(base_url + '/delete')\r\n print(response.status_code)","def _req_get(self, url: str):\n self._get_cookies()\n if not self._cookies:\n return\n r = reqtry.get(url, cookies=self._cookies, allow_redirects=False, timeout=(3, 3), tries=3, delay=1,\n backoff=1.5, jitter=(1, 1.5))\n assert r.status_code == 200, f\"Get request: Invalid http status code: {r.status_code}\"\n return r","def call_api(url):\n\n req = requests.get(url)\n return req","def call_api(url):\n\n req = requests.get(url)\n return req","def base_request(url_path):\n response = requests.get(settings.URL_API + url_path)\n if response.status_code != 200:\n return response\n else:\n return response.json()","def access_url(context, url):\n context.response = requests.get(context.coreapi_url + url)","def _Get(self, url, timeout_seconds, headers): # pylint: disable=W0613, R0201\n raise NotImplementedError() # pragma: no cover","def do_GET(s):\r\n print \"processing get request...\"\r\n s.send_response(200)\r\n s.send_header(\"Content-type\", \"application/json\")\r\n s.send_header(\"Access-Control-Allow-Origin\", \"*\")\r\n s.end_headers()\r\n\r\n inputUrl = s.path\r\n\r\n print \"####INPUT########\"\r\n print inputUrl\r\n print \"#####INPUT#######\"\r\n\r\n try:\r\n index = string.index(inputUrl, \"url=\") + 4\r\n urlParam = inputUrl[index:]\r\n print \"url request: \" + urlParam\r\n response = urllib.urlopen(urlParam).read()\r\n s.wfile.write(response)\r\n except:\r\n print \"no url specified\"\r\n\r\n try:\r\n index = string.index(inputUrl, \"random\") + 6\r\n randomParam = inputUrl[index:]\r\n scientists = open(\"C:\\Users\\ASUS 1\\Documents\\GitHub\\girlsWhoCode\\womenScientists\\women_scientists.txt\", 'r').readlines()\r\n size = len(scientists)\r\n fileIndex = random.randint(0, size)\r\n scientist = scientists[fileIndex]\r\n print \"random request returning: \" + scientist\r\n response = json.dumps(scientist)\r\n s.wfile.write(response)\r\n\r\n except Exception as e:\r\n print e.message\r\n print \"no female scientist requested\"\r\n\r\n try:\r\n index = string.index(inputUrl, \"wiki=\") + 5\r\n scientistParam = inputUrl[index:]\r\n scientist = ' '.join(scientistParam.split(\"%20\"))\r\n print \"wiki request for \" + scientist\r\n page = wikipedia.page(scientist)\r\n summary = page.summary\r\n response = json.dumps(summary)\r\n s.wfile.write(response)\r\n except:\r\n print \"no wiki request\"","def mock_requests_get(self, mocker):\n mock = mocker.patch(\"requests.get\")\n mock.return_value.__enter__.return_value.json.return_value = {\n \"item\": {\n \"icon\": \"\",\n \"icon_large\": \"\",\n \"id\": 21787,\n \"type\": \"Miscellaneous\",\n \"typeIcon\": \"\",\n \"name\": \"Steadfast boots\",\n \"description\": \"A pair of powerful-looking boots.\",\n \"current\": {\"trend\": \"neutral\", \"price\": \"5.9m\"},\n \"today\": {\"trend\": \"negative\", \"price\": \"- 138.2k\"},\n \"members\": \"true\",\n \"day30\": {\"trend\": \"positive\", \"change\": \"+0.0%\"},\n \"day90\": {\"trend\": \"negative\", \"change\": \"-3.0%\"},\n \"day180\": {\"trend\": \"negative\", \"change\": \"-4.0%\"},\n }\n }","def __call__(self, request):\n if request.host.startswith('127.0.0.1:'):\n return self.real_http_fetch(request)\n\n response = self.http_archive.get(request)\n\n if self.use_closest_match and not response:\n closest_request = self.http_archive.find_closest_request(\n request, use_path=True)\n if closest_request:\n response = self.http_archive.get(closest_request)\n if response:\n logging.info('Request not found: %s\\nUsing closest match: %s',\n request, closest_request)\n\n if not response:\n reason = str(request)\n if self.use_diff_on_unknown_requests:\n diff = self.http_archive.diff(request)\n if diff:\n reason += (\n \"\\nNearest request diff \"\n \"('-' for archived request, '+' for current request):\\n%s\" % diff)\n logging.warning('Could not replay: %s', reason)\n else:\n if self.inject_script:\n response = _InjectScripts(response, self.inject_script)\n if self.scramble_images:\n response = _ScrambleImages(response)\n return response","def get(self, *args, **kwargs):\n self.request(\"get\", *args, **kwargs)","def _get(self, *args, **kwargs):\n return self._request('get', *args, **kwargs)","def test_client_can_load_client_requests_directly(self):\n\n req = self.httpbin.get_request_data('get_my_ip')\n self.assertEqual(req, self.httpbin.client['get_my_ip'])\n req = self.httpbin.get_request_data('get_my_headers')\n self.assertEqual(req, self.httpbin.client['get_my_headers'])\n\n req = self.httpbin_2.get_request_data('get_my_ip')\n self.assertEqual(req, self.httpbin_2.client['get_my_ip'])\n req = self.httpbin_2.get_request_data('get_my_headers')\n self.assertEqual(req, self.httpbin_2.client['get_my_headers'])","def process_request(self, req, resp, resource, params):","def _request(self, *args, **kwargs):\n raise NotImplementedError()","def _do_request(self, url, method='GET', body=None):\n response, content = self.request(url, method=method, body=body, headers=self.headers)\n if int(response['status']) != 200:\n raise GPAPIError(response['status'], 'ERROR IN REQUEST')\n json = simplejson.loads(content)\n return json","def _make_http_request_read(self, path):\n url = self.url_base + path\n if url not in self._requests_cache:\n self._requests_cache[url] = self._perform_http_request(url)[2]\n return self._requests_cache[url]","def get(self, url: str) -> None:\n\n if self.number_of_requests_made % self.change_ip_after == 0:\n self.renew_ip()\n\n else:\n self.wait()\n\n self.last_call_timestamp = round(time.time(), 2)\n super().get(url)\n\n self.number_of_requests_made += 1","def _process_request(self, request, response):\n ...","def mock_requests_get(self, mocker):\n mock = mocker.patch(\"requests.get\")\n mock.return_value.__enter__.return_value.json.return_value = {\n \"types\": [],\n \"alpha\": [\n {\"letter\": \"#\", \"items\": 0},\n {\"letter\": \"a\", \"items\": 4},\n {\"letter\": \"j\", \"items\": 2},\n ],\n }","def _do_request(self, url: str):\n\n self.debug.ok('method', self.method)\n\n if self.client.fake_response_path:\n with open(self.client.fake_response_path, 'r') as f:\n return constants.ResponseCode.OK, f.read()\n\n elif self.method == constants.RequestConst.GET:\n response = requests.get(\n url, headers=self._headers(), timeout=self._timeout\n )\n\n self.debug.ok(\n constants.RequestConst.QUERY_PARAMETERS,\n self.parameters[constants.RequestConst.QUERY]\n )\n self.debug.ok(constants.ResponseConst.RESPONSE_OBJECT, response)\n\n return response.status_code, response.text\n\n elif self.method in [\n constants.RequestConst.POST,\n constants.RequestConst.PUT,\n constants.RequestConst.DELETE\n ]:\n if self.method == constants.RequestConst.POST:\n send_request = requests.post\n elif self.method == constants.RequestConst.PUT:\n send_request = requests.put\n elif self.method == constants.RequestConst.DELETE:\n send_request = requests.delete\n\n response = send_request(\n url, json=self.parameters[constants.RequestConst.QUERY],\n headers=self._headers(), timeout=self._timeout\n )\n\n self.debug.ok('payload', self.parameters[\n constants.RequestConst.QUERY\n ])\n self.debug.ok(constants.ResponseConst.RESPONSE_OBJECT, response)\n\n return response.status_code, response.text\n\n else:\n return constants.ResponseCode.NOT_FOUND, {}","def _request(self, *args):\n self._silent_request(*args)\n return self._get_response()","def access_gemini_url_patch_method(context, endpoint):\n url = urljoin(context.gemini_api_url, endpoint)\n context.response = requests.patch(url)","def test_two_legged_get(self):\n resp, content = self._two_legged(\"GET\")\n self.assertEqual(int(resp['status']), 200)","def _make_request(self, additional_params: dict, new_base_url: str = None) -> list:\n if new_base_url:\n url: str = new_base_url\n params: dict = additional_params\n else:\n url: str = self.base_url\n params: dict = dict(self.base_params, **additional_params)\n response: requests.Response = self.session.get(url, params=params)\n if response.status_code == 200:\n try:\n response_text = json.loads(response.text)\n except ValueError:\n response_text = response.text\n else:\n raise ALHTTPExceptionFromResponse(response)\n\n # sometimes we get a pure dictionary back, let's wrap it in a list for consistency\n if isinstance(response_text, dict):\n response_text = [response_text]\n return response_text","def test_get_request_normal_response(self, mock_get):\n\n # Arrange\n # Construct our mock response object, giving it relevant expected behaviours\n mock_resp_instance = MockResponse({\"msg\": \"success\"}, 200, content=\"abc\")\n mock_get.return_value = mock_resp_instance\n\n # Act\n response = get_request_data(self.url, json_resp=False)\n\n # Assert that the request-response cycle completed successfully.\n self.assertEqual(mock_resp_instance.status_code, 200)\n self.assertEqual(response, mock_resp_instance)","def _get(self, url: str) -> requests.Response:\n # todo: do some error checking here\n if url.startswith(API_PATH['base']):\n try:\n # logger.debug(f\"RestClient._get(): {url}\") # log in calling function\n response = requests.get(url, auth=self.auth)\n rest_code = response.json()['meta']['code']\n if rest_code not in [200, 201, 204]:\n raise RestException(f\"REST API Error: {rest_code}. {response.content}\")\n except RestException as e:\n logger.error(e)\n return None\n return response\n else:\n raise ValueError(f\"URL is invalid: {url}\")","async def _make_request(self, url: str, params, server_id: str):\n headers = {\n 'X-Response-Control': 'minified',\n 'User-Agent': 'Friendly Red bot'\n }\n\n if server_id in self.config:\n if 'API_TOKEN' in self.config[server_id]:\n headers['X-Auth-Token'] = self.config['API_TOKEN']\n else:\n await self.bot.say(box('Requests made without an authentication token are limited to 100 requests per 24 hours.\\nYou can request a key by registering at http://api.football-data.org and setting it via [p]football tokenset.'))\n\n async with aiohttp.get(url, headers=headers, params=params) as r:\n if r.status == 200:\n data = await r.json()\n return data\n elif r.status == 400:\n await self.bot.say(box('Bad Request [400]:\\nYour request was malformed most likely the value of a Filter was not set according to the Data Type that is expected.'))\n return\n elif r.status == 403:\n await self.bot.say(box('Restricted Resource [403]:\\nYou tried to access a resource that exists, but is not available for you. This can be out of the following reasons:\\n- the resource is only available to authenticated clients\\n- the resource is only available to donating clients\\n- the resource is not available in the API version you are using'))\n return\n elif r.status == 404:\n await self.bot.say(box('Not found [404]\\nYou tried to access a resource that doesn’t exist.'))\n return\n elif r.status == 429:\n await self.bot.say(box('Too many requests [429]\\nYou exceeded your allowed requests per minute/day depending on API version and your user status.\\nSee http://api.football-data.org/docs/v1/index.html#_request_throttling for more information.'))\n await self.bot.say(box('Requests reset in ' + r.headers['X-RequestCounter-Reset'] + ' seconds.'))\n return\n else:\n await self.bot.say(box('Pancake has no idea what you\\'ve done, seriously.'))\n await self.bot.say(box(r.status + '\\n' + r.json()['error']))\n return","def get(self, url):\n super().get(mfacebookToBasic(url))","def request(self, method, url, params=None, data=None):\n raise NotImplementedError(\n u\"%s: Method not implemented\", self.__class__.__name__)","def _request(self, url, method=\"GET\", data=None):\n\t\t# TODO: exception handling\n\t\tif self.logged_in:\n\t\t\tcookie_list = [\"{}={}\".format(k, v) for k, v in self.cookies.iteritems()]\n\t\t\theaders = {'Cookie': \"; \".join(cookie_list)}\n\t\telse:\n\t\t\theaders = {}\n\t\tself.connection.request(method, self.base_path + url, data, headers)\n\t\treturn self.connection.getresponse()","def handle_request_get(self, msg):\n\n\t\tfor arg in msg.arguments:\n\t\t\tmethod = {\n\t\t\t\t'ucr': self.handle_request_get_ucr,\n\t\t\t\t'meta': self.handle_request_get_meta,\n\t\t\t\t'info': self.handle_request_get_info,\n\t\t\t\t'modules/list': self.handle_request_get_modules,\n\t\t\t\t'modules': self.handle_request_get_modules,\n\t\t\t\t'categories/list': self.handle_request_get_categories,\n\t\t\t\t'categories': self.handle_request_get_categories,\n\t\t\t\t'user/preferences': self.handle_request_get_user_preferences,\n\t\t\t\t'hosts/list': self.handle_request_get_hosts,\n\t\t\t\t'hosts': self.handle_request_get_hosts,\n\t\t\t}.get(arg)\n\t\t\tif method:\n\t\t\t\tself.finished(msg.id, method(msg))\n\t\t\t\treturn\n\t\traise NotFound()","def request(self, method, url):\n\t\ttr = TwitterRequest( method.upper(), url )\n\t\treturn self.get_response( tr )","def _request(self, method, uri, **kwargs):\n url = self.url + uri\n self.logger.debug(\"Requesting {} on {}\".format(method, url))\n response = requests.request(method, url, verify=self.verify, **kwargs)\n try:\n response.raise_for_status()\n except requests.exceptions.HTTPError:\n self.logger.error(\"Bad http code {} requesting Clair\".format(response.status_code))\n if response.reason == \"Not Found\":\n raise ResourceNotFoundException(\"Resource not found\")\n raise ClairConnectionError(response)\n return response","def _request(self, method, *args, **kwargs):\n if not \"headers\" in kwargs:\n kwargs[\"headers\"] = self._headers\n return self._session.request(method, self._url(*args), **kwargs)","def request(self, method, url, *args, **kwargs):\n full_url = urljoin(self.base_url, url)\n if 'data' in kwargs:\n kwargs['data'] = self._encode_data(kwargs['data'])\n return super(Client, self).request(method, full_url, *args, **kwargs)","def start_requests(self):\n # This predefined list of URLs is chosen to include all types of\n # inquiries possible in the Austrian parliament in order to provide a\n # suitable testing surface for new functions.\n # urls = [\"https://www.parlament.gv.at/PAKT/VHG/XXV/JPR/JPR_00019/index.shtml\", \"https://www.parlament.gv.at/PAKT/VHG/XXV/JPR/JPR_00016/index.shtml\", \"https://www.parlament.gv.at/PAKT/VHG/XXV/J/J_06954/index.shtml\", \"https://www.parlament.gv.at/PAKT/VHG/XXV/M/M_00178/index.shtml\", \"https://www.parlament.gv.at/PAKT/VHG/XXV/JEU/JEU_00003/index.shtml\", \"https://www.parlament.gv.at/PAKT/VHG/XXV/J/J_06758/index.shtml\", \"https://www.parlament.gv.at/PAKT/VHG/BR/J-BR/J-BR_03089/index.shtml\",\n # \"https://www.parlament.gv.at/PAKT/VHG/BR/J-BR/J-BR_03091/index.shtml\", \"http://www.parlament.gv.at/PAKT/VHG/BR/J-BR/J-BR_01155/index.shtml\", \"http://www.parlament.gv.at/PAKT/VHG/XX/J/J_06110/index.shtml\", \"http://www.parlament.gv.at/PAKT/VHG/XX/J/J_06651/index.shtml\", \"http://www.parlament.gv.at/PAKT/VHG/XX/J/J_04024/index.shtml\", \"http://www.parlament.gv.at/PAKT/VHG/XX/J/J_04025/index.shtml\", \"https://www.parlament.gv.at/PAKT/VHG/XX/M/M_00178/index.shtml\"]\n urls = [] if not self.url_override else [self.url_override]\n\n if self.LLP and not self.url_override:\n for i in self.LLP:\n for nrbr in ['NR', 'BR']:\n roman_numeral = roman.toRoman(i)\n options = self.URLOPTIONS.copy()\n options['GP'] = roman_numeral\n options['NRBR'] = nrbr\n url_options = urlencode(options)\n url_llp = \"{}?{}\".format(self.BASE_URL, url_options)\n rss = feedparser.parse(url_llp)\n\n self.logger.info(\"GP {}: {} inquiries from {}\".format(\n roman_numeral, len(rss['entries']), nrbr)\n )\n urls = urls + [entry['link'] for entry in rss['entries']]\n self.TOTAL_COUNTER = len(urls)\n for url in urls:\n yield self.make_requests_from_url(url)","def _get_request(url, params):\n request = requests.get(url, params=params)\n\n return request","def challenge_get(self, environ, start_response):\n environ['wsgiorg.routing_args'][1]['recipe_name'] = self.CHALLENGER_RECIPE\n environ['tiddlyweb.type'] = 'text/x-tiddlywiki'\n return get_tiddlers(environ, start_response)","def _request(self, url):\n response = requests.get(url, headers=self.header)\n\n if str(response.status_code).startswith('2'):\n return response\n\n raise Exception(\"URI request returned an error. Error Code \" + str(response.status_code))","def test_client_load_pages_request(self):\n is_present = hasattr(self.httpbin_3, 'test_requests_patch_method')\n\n self.assertTrue(is_present)","def __patch(self, url):\n\n res = requests.patch(url, headers=self.auth_header)\n res.raise_for_status()\n return res","def get(self, request, *args, **kwargs):\n verify_secure(request)\n return super().get(request, args, kwargs)","def get(self, request, *args, **kwargs):\n verify_secure(request)\n return super().get(request, args, kwargs)","def get(self, request, *args, **kwargs):\n verify_secure(request)\n return super().get(request, args, kwargs)","def get(self, request, *args, **kwargs):\n verify_secure(request)\n return super().get(request, args, kwargs)","def _request(self, method, url, params=None, data=None, request_type=PRIVATE, headers={}):\n self._is_valid_request_option(request_type=request_type)\n\n request_headers = copy.deepcopy(self.BASE_HEADERS)\n request_headers.update(headers)\n\n response = getattr(requests, method.lower())(\n url,\n headers=request_headers,\n params=params,\n data=data\n )\n\n return self._handle_response(response)","def patched_request(urlpath):\n def inner(f):\n def wrapped(self, *args, **kwargs):\n cookies = self.client.get(urlpath, verify=False, auth=HTTP_BASIC_AUTH_CREDENTIALS).cookies\n token = cookies.get('csrftoken')\n headers = {\n 'X-CSRFToken': token,\n 'X-Requested-With': 'XMLHttpRequest',\n 'Content-Type': 'application/json'\n }\n f_kwargs = dict(verify=False, auth=HTTP_BASIC_AUTH_CREDENTIALS, headers=headers, cookies=cookies)\n get = partial(self.client.get, **f_kwargs)\n post = partial(self.client.post, **f_kwargs)\n put = partial(self.client.put, **f_kwargs)\n args += (get, post, put)\n return f(self, *args, **kwargs)\n return wrapped\n return inner","def render_GET(self, request):\r\n # First check if the version is ok\r\n try:\r\n version = request.args['version']\r\n except KeyError:\r\n request.setResponseCode(httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0])\r\n request.setHeader('content-type', 'text/plain; charset=utf-8')\r\n return \"Request is missing parameter: 'version'\"\r\n\r\n if len(version) != 1:\r\n request.setResponseCode(httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0])\r\n request.setHeader('content-type', 'text/plain; charset=utf-8')\r\n return \"Parameter 'version' has to be unique in request.\"\r\n\r\n version = version[0]\r\n\r\n if version < MINIMAL_VERSION:\r\n request.setResponseCode(httpstatus.HTTP_STATUS_CODE_GONE[0])\r\n request.setHeader('content-type', 'text/plain; charset=utf-8')\r\n return ('Client version is insufficient. Minimal version is '\r\n \"'{0}'.\".format(MINIMAL_VERSION))\r\n elif version > CURRENT_VERSION:\r\n request.setResponseCode(httpstatus.HTTP_STATUS_CODE_NOT_IMPLEMENTED[0])\r\n request.setHeader('content-type', 'text/plain; charset=utf-8')\r\n return 'Client version is newer than version supported by server.'\r\n\r\n # Version is ok, now the GET request can be processed\r\n # Extract and check the arguments\r\n try:\r\n userID = request.args['userID']\r\n except KeyError:\r\n request.setResponseCode(httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0])\r\n request.setHeader('content-type', 'text/plain; charset=utf-8')\r\n return \"Request is missing parameter: 'userID'\"\r\n\r\n if len(userID) != 1:\r\n request.setResponseCode(httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0])\r\n request.setHeader('content-type', 'text/plain; charset=utf-8')\r\n return \"Parameter 'userID' has to be unique in request.\"\r\n\r\n userID = userID[0]\r\n\r\n # Get the URL of a Robot process\r\n d = self._realm.requestURL(userID)\r\n d.addCallback(self._build_response, version, request)\r\n d.addErrback(self._handle_error, request)\r\n\r\n return NOT_DONE_YET","def MutateCustomInterests(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def _api_call(self, url, response_checker):\n self.request_compare(url)","def test_client_can_do_get_request(self):\n response = self.httpbin.get_my_headers(headers={'User-agent': 'Fake user agent'})\n self.assertEqual(response.request.method, 'GET')\n self.assertEqual(response.status_code, 200)","def fetch_a_request(v1, requestid):\n\n #check if user has any requests\n if len(all_requests) < 1:\n return jsonify({\n \"message\":\"You have not made any requests yet\"\n })\n \n #if user has more than one request\n if len(all_requests) >= 1:\n returned_request = []\n for a_request in all_requests:\n if a_request.request_id == int(requestid):\n returned_request.append(a_request)\n return jsonify({\n \"message\": \"Successfully fetched the request\",\n \"request\": returned_request[0].__dict__\n })\n \n return jsonify({\n \"message\":\"Request doesnt exist\"\n })","def monkey_patch_requests_for_xray():\n wrapt.wrap_function_wrapper(\n \"requests.sessions\", \"Session.send\", xray_requests_send,\n )","def test_request(self):\n client = RestClient(host=self.host, username='')\n rest_url = 'some/url/'\n\n # Mock good get response\n with responses.RequestsMock() as rsps:\n rsps.add(responses.GET, f'{self.host}/{rest_url}', status=200,\n json={'value':\"good!\"})\n r = client.request('get', rest_url)\n assert r.status_code == 200\n assert r.json()['value'] == 'good!'\n \n # Mock bad get response\n with responses.RequestsMock() as rsps:\n rsps.add(responses.GET, f'{self.host}/{rest_url}', status=401,\n json={'value':\"bad!\"})\n with raises(requests.HTTPError):\n r = client.request('get', rest_url)\n r = client.request('get', rest_url, checkstatus=False)\n assert r.status_code == 401\n assert r.json()['value'] == 'bad!'"],"string":"[\n \"def _external_request(self, method, url, *args, **kwargs):\\n self.last_url = url\\n if url in self.responses.keys() and method == 'get':\\n return self.responses[url] # return from cache if its there\\n\\n headers = kwargs.pop('headers', None)\\n custom = {'User-Agent': useragent}\\n if headers:\\n headers.update(custom)\\n kwargs['headers'] = headers\\n else:\\n kwargs['headers'] = custom\\n\\n response = getattr(requests, method)(url, *args, **kwargs)\\n\\n if self.verbose:\\n print(\\\"Got Response: %s\\\" % url)\\n\\n if response.status_code == 503:\\n raise SkipThisService(\\\"Service returned 503 - Temporarily out of service.\\\")\\n\\n if method == 'get':\\n self.responses[url] = response # cache for later\\n\\n self.last_raw_response = response\\n return response\",\n \"def test_request_should_not_include_token(self):\\n client = Client()\\n\\n with patch(\\\"requests.request\\\") as request:\\n request.return_value.json.return_value = {}\\n\\n client.request(\\\"GET\\\", \\\"http://www.google.com/\\\")\\n\\n request.assert_called_once_with(\\n \\\"GET\\\",\\n \\\"http://www.google.com/\\\",\\n headers=None,\\n json=None,\\n params=b\\\"per_page=100\\\",\\n )\",\n \"def mocked_requests_scrapping_get(*args, **kwargs):\\n class MockResponse:\\n def __init__(self, json_data, status_code, url):\\n self.content = json_data\\n self.status_code = status_code\\n self.url = url\\n self.cookies = {\\\"JSESSIONID\\\": \\\"jkghhjgjhgfjgfgjg\\\"}\\n self.encoding = \\\"utf-8\\\"\\n\\n def json(self):\\n return self.json_data\\n\\n dn = os.path.dirname(os.path.realpath(__file__))\\n for url, provider in {f\\\"{settings.BASE_URL}/eAnnuaire/formulaire?appelRetour=true\\\": \\\"form\\\",\\n f\\\"{settings.BASE_URL}/eAnnuaire/resultat\\\": \\\"suivant\\\",\\n f\\\"{settings.BASE_URL}/eAnnuaire/fiche\\\": \\\"detail\\\"}.items():\\n if args[0].startswith(url):\\n with open(os.path.join(dn, \\\"fixtures\\\", f\\\"{provider}.html\\\"), \\\"rb\\\") as fp:\\n return MockResponse(fp.read(), 200, args[0])\",\n \"def get(self, request):\\n pass\",\n \"def test_client_can_load_client_page_requests_directly(self):\\n\\n req = self.httpbin_3.get_request_data('get_my_ip')\\n\\n self.assertEqual(req, self.httpbin_3.client[\\\"homepage\\\"]['get_my_ip'])\\n req = self.httpbin_3.get_request_data('test_requests_patch_method')\\n self.assertEqual(req, self.httpbin_3.client[\\\"homepage\\\"]['test_requests_patch_method'])\\n req = self.httpbin_3.get_request_data('test_requests_delete_method')\\n self.assertEqual(req, self.httpbin_3.client[\\\"second_page\\\"]['test_requests_delete_method'])\\n\\n req = self.httpbin_4.get_request_data('get_my_ip')\\n self.assertEqual(req, self.httpbin_4.client['get_my_ip'])\\n req = self.httpbin_4.get_request_data('get_user_my_agent')\\n self.assertEqual(req, self.httpbin_4.client['get_user_my_agent'])\\n req = self.httpbin_4.get_request_data('test_requests_put_method')\\n self.assertEqual(req, self.httpbin_4.client['test_requests_put_method'])\\n req = self.httpbin_4.get_request_data('test_requests_post_method')\\n self.assertEqual(req, self.httpbin_4.client['test_requests_post_method'])\",\n \"def test_get(self):\\n return self.doRequest(self.url, method=\\\"GET\\\", body=self.input)\",\n \"def request(self, url, *args, **kwargs):\\n raise NotImplementedError\",\n \"def aget(url, **kwargs):\\n return requests.get(url, **kwargs)\",\n \"def rhsa(monkeypatch, mock_get):\\n monkeypatch.delattr('requests.sessions.Session.request')\\n monkeypatch.setattr(ErrataConnector, '_auth', None)\\n monkeypatch.setattr(requests, 'get', mock_get)\\n return Erratum(errata_id=36762)\",\n \"def requester(get_args: dict) -> dict:\\n get_args.update(dict(apikey = apikey))\\n response = requests.get(URL, params = get_args)\\n return response.json()\",\n \"def _request(self, url, **kwargs):\\n headers = {'PRIVATE-TOKEN': self.token}\\n response = make_request(self.base_url + url, headers=headers, **kwargs)\\n logging.info('Requested: {0}'.format(url))\\n logging.info('Method: {0}'.format(kwargs.get('method', 'GET')))\\n logging.info(response.content)\\n return json.loads(response.content)\",\n \"def get_request(req_context, uri):\\n headers = { 'Accept': \\\"application/json\\\", \\n 'User-Agent': \\\"testApp\\\"\\n }\\n if config.ENVIRONMENT == \\\"Sandbox\\\":\\n base_url = \\\"https://sandbox-quickbooks.api.intuit.com/v3/company/\\\"\\n else:\\n base_url = \\\"https://quickbooks.api.intuit.com/v3/company/\\\"\\n url = base_url + req_context.realm_id + uri\\n print(url)\\n if config.AUTH_TYPE == \\\"OAuth2\\\":\\n headers['Authorization'] = \\\"Bearer \\\" + req_context.access_token\\n req = requests.get(url, headers=headers)\\n else:\\n auth = OAuth1(req_context.consumer_key, req_context.consumer_secret, req_context.access_key, req_context.access_secret)\\n req = requests.get(url, auth=auth, headers=headers)\\n return req\",\n \"def crime_data_fbi(request):\\n http = urllib3.PoolManager()\\n\\n # Getting the request arguments for city, distance , start date and end date \\n\\n #request_args = request.args\\n #print('request_args')\\n #ori=request_args['ori']\\n #start_date=request_args['start_date']\\n #end_date=request_args['end_date']\\n #distance=request_args['distance']\\n base_url=fbi_url(request)\\n print(base_url)\\n \\n # New request url \\n request_url = base_url\\n print(request_url)\\n \\n print(\\\"i am inside the functino\\\")\\n payload = http.request('GET',\\n request_url,\\n headers={\\n 'Content-Type': 'application/json',\\n 'x-api-key': creds\\n },\\n fields={\\n 'API_KEY':creds\\n }\\n )\\n\\n #*** only changing it for testing ***\\n #return request_url\\n print(payload)\\n return payload\",\n \"def get_request(url):\\n\\tr = requests.get(url)\\n\\treturn(r)\",\n \"def mock_requests_get(mocker, mocked_requests_get):\\n\\n def _requests_get(module, content, status):\\n mock_func = mocker.patch(f'{module}.requests.get')\\n mock_func.return_value = mocked_requests_get(content, status)\\n\\n return _requests_get\",\n \"def do_GET(self):\\n self.log.debug('do_GET called')\\n self.HeadGet('GET')\",\n \"def request( # pylint: disable=arguments-differ\\n self, method: str, url: str, **kwargs\\n ) -> object:\\n if self.base_url is not None and not url.startswith('https'):\\n url = f'{self.base_url}{url}'\\n\\n # this kwargs value is used to signal 429 handling that this is a retry, but the super\\n # method doesn't expect it so it needs to be removed.\\n tc_is_retry = kwargs.pop('tc_is_retry', False)\\n\\n response: Response = super().request(method, url, **kwargs)\\n\\n if response.status_code == 429 and not tc_is_retry:\\n too_many_requests_handler = self.too_many_requests_handler\\n time.sleep(too_many_requests_handler(response))\\n kwargs['tc_is_retry'] = True\\n return self.request(method, url, **kwargs)\\n\\n # APP-79 - adding logging of request as curl commands\\n if not response.ok or self.log_curl:\\n try:\\n self.log.debug(\\n self.requests_to_curl.convert(\\n response.request,\\n mask_body=self.mask_body,\\n mask_headers=self.mask_headers,\\n mask_patterns=self.mask_patterns,\\n proxies=self.proxies,\\n verify=self.verify,\\n )\\n )\\n except Exception: # nosec\\n pass # logging curl command is best effort\\n\\n self.log.debug(\\n f'feature=external-session, request-url={response.request.url}, '\\n f'status_code={response.status_code}, elapsed={response.elapsed}'\\n )\\n\\n return response\",\n \"def do_request(method, url, data=None, headers=None):\\n try:\\n if method == 'GET':\\n resp = requests.get(url, headers=headers)\\n return resp\\n elif method == 'POST':\\n resp = requests.post(url, json=data, headers=headers)\\n return resp\\n elif method == 'PATCH':\\n resp = requests.patch(url, json=data, headers=headers)\\n return resp\\n except Exception, e:\\n print \\\"Retry {} with {}, {}\\\".format(str(e), url, data)\\n raise e\",\n \"def cached():\\n ##from pprint import pprint\\n # let's restrict this to the api server, to avoid shenanigans\\n root_relative_url = request.env.request_uri.split('/cached/')[-1]\\n ##pprint('ROOT-RELATIVE URL: ')\\n ##pprint(root_relative_url)\\n fetch_url = '%s://%s/%s' % (request.env.wsgi_url_scheme, request.env.http_host, root_relative_url)\\n ##pprint('PROXYING TO SIMPLE URL: ')\\n ##pprint(fetch_url)\\n\\n # permissive CORS handling of requests from another domain (e.g. tree.opentreeoflife.org)\\n if request.env.request_method == 'OPTIONS':\\n if request.env.http_access_control_request_method:\\n response.headers['Access-Control-Allow-Methods'] = request.env.http_access_control_request_method\\n if request.env.http_access_control_request_headers:\\n response.headers['Access-Control-Allow-Headers'] = request.env.http_access_control_request_headers\\n ##pprint('RESPONDING TO OPTIONS')\\n raise HTTP(200, **(response.headers))\\n\\n # N.B. This try/except block means we'll cache errors. For now, the fix is to clear the entire cache.\\n try:\\n # fetch the latest IDs as JSON from remote site\\n import simplejson\\n\\n if fetch_url.startswith('//'):\\n # Prepend scheme to a scheme-relative URL\\n fetch_url = \\\"http:%s\\\" % fetch_url\\n\\n fetch_args = request.vars # {'startingTaxonOTTId': \\\"\\\"}\\n\\n # TODO: For more flexibility, we should examine and mimic the original request (HTTP verb, headers, etc)\\n\\n # this needs to be a POST (pass fetch_args or ''); if GET, it just describes the API\\n # N.B. that gluon.tools.fetch() can't be used here, since it won't send \\\"raw\\\" JSON data as treemachine expects\\n req = urllib2.Request(url=fetch_url, data=simplejson.dumps(fetch_args), headers={\\\"Content-Type\\\": \\\"application/json\\\"}) \\n the_response = urllib2.urlopen(req).read()\\n ##pprint('RESPONSE:')\\n ##pprint(the_response)\\n return the_response\\n\\n except Exception, e:\\n # throw 403 or 500 or just leave it\\n return ('ERROR', e.message)\",\n \"def live_url_request(url, arg):\\n if arg == \\\"-m\\\":\\n json_response = requests.get(url)\\n\\n elif arg == \\\"-l\\\":\\n live_token= get_live_token()\\n json_response = requests.get(url, headers={\\\"PRIVATE-TOKEN\\\": live_token})\\n return json_response\",\n \"def _request(self, *args):\\n raise NotImplementedError\",\n \"def getFromCache(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def _get(self, url):\\n return self._request(url)\",\n \"def mock_requests_get(request, monkeypatch, mock_get_args):\\n\\n def mock_get(url, *args, **kwargs):\\n mock_get_args(url, *args, **kwargs)\\n\\n mock_resp = MagicMock()\\n if url == qml.data.data_manager.FOLDERMAP_URL:\\n json_data = _folder_map\\n elif url == qml.data.data_manager.DATA_STRUCT_URL:\\n json_data = _data_struct\\n else:\\n json_data = None\\n\\n mock_resp.json.return_value = json_data\\n if hasattr(request, \\\"param\\\"):\\n mock_resp.content = request.param\\n\\n return mock_resp\\n\\n monkeypatch.setattr(qml.data.data_manager, \\\"get\\\", mock_get)\\n\\n return mock_get\",\n \"def _call_api(self, verb, url, **request_kwargs):\\n api = 'https://api.github.com{}'.format(url)\\n auth_headers = {'Authorization': 'token {}'.format(self.api_token)}\\n headers = {**auth_headers, **request_kwargs.pop('headers', {})}\\n return getattr(requests, verb)(api, headers=headers, **request_kwargs)\",\n \"def patch_get(request):\\n try:\\n mp = request.getfixturevalue(\\\"monkeypatch\\\")\\n except AttributeError: # pytest < 3\\n mp = request.getfuncargvalue(\\\"monkeypatch\\\")\\n mp.setattr(requests.Session, 'request', get_mockreturn)\\n return mp\",\n \"def step_impl(context, query):\\n url = context.base_url+query\\n print('url:',url,'\\\\n')\\n with closing(requests.get(url)) as response:\\n context.response = response\\n context.response_json = response.json()\",\n \"def url_for_request(self, method, extras):\\n raise NotImplementedError(\\\"Should be overriden by subclass\\\")\",\n \"def test_request_extra_allowed_codes():\\n mocked_codes = {\\\"codes\\\": [HTTPCreated.code, HTTPOk.code, HTTPCreated.code]} # note: used in reverse order\\n\\n def mocked_request(*_, **__):\\n mocked_resp = Response()\\n mocked_resp.status_code = mocked_codes[\\\"codes\\\"].pop()\\n return mocked_resp\\n\\n with mock.patch(\\\"requests.Session.request\\\", side_effect=mocked_request) as mocked:\\n resp = request_extra(\\\"get\\\", \\\"http://whatever\\\", retries=3, allowed_codes=[HTTPOk.code])\\n assert resp.status_code == HTTPOk.code\\n assert mocked.call_count == 2\",\n \"def GetCustomInterest(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def _make_request_with_auth_fallback(self, url, headers=None, params=None):\\n self.log.debug(\\\"Request URL and Params: %s, %s\\\", url, params)\\n try:\\n resp = requests.get(\\n url,\\n headers=headers,\\n verify=self._ssl_verify,\\n params=params,\\n timeout=DEFAULT_API_REQUEST_TIMEOUT,\\n proxies=self.proxy_config,\\n )\\n resp.raise_for_status()\\n except requests.exceptions.HTTPError as e:\\n self.log.debug(\\\"Error contacting openstack endpoint: %s\\\", e)\\n if resp.status_code == 401:\\n self.log.info('Need to reauthenticate before next check')\\n\\n # Delete the scope, we'll populate a new one on the next run for this instance\\n self.delete_current_scope()\\n elif resp.status_code == 409:\\n raise InstancePowerOffFailure()\\n elif resp.status_code == 404:\\n raise e\\n else:\\n raise\\n\\n return resp.json()\",\n \"def __call__(self, request):\\n response = self.get_request(request)\\n return response\",\n \"def test_request_fetch(response, mocker):\\n mocker.patch(\\\"requests.get\\\", autospec=True)\\n requests.get.return_value = response\\n request.fetch(\\\"http://localhost\\\")\\n requests.get.assert_called_with(\\\"http://localhost\\\", request.headers)\",\n \"def requestURL(userID): #@NoSelf\",\n \"def _make_request(self, url: str, parameters: dict = None,\\n method: str = 'GET', *args, **kwargs):\\n response = requests.request(\\n method=method,\\n url=build_url(\\n self.BASE_API_URL, url, parameters\\n ),\\n headers={\\n 'Authorization': 'Bearer {}'.format(self._access_token)\\n }, **kwargs\\n )\\n if response.ok:\\n return response.json()\\n raise MondoApiException(response.json()['message'])\",\n \"def do_GET(self):\\n self.http_method = 'GET'\\n self.response()\",\n \"def _Dynamic_Fetch(self, request, response):\\n print \\\"Request:\\\"\\n print (\\\"Request: {}\\\").format(request)\\n response.set_content(self.mock_response_issue)\\n response.set_statuscode(200)\\n new_header = response.add_header()\\n new_header.set_key('Content-type')\\n new_header.set_value('application/json')\\n\\n response.set_finalurl(request.url)\\n response.set_contentwastruncated(False)\\n\\n # allow to query the object after it is used\\n # pylint: disable=attribute-defined-outside-init\\n self.request = request\\n self.response = response\",\n \"def _make_get_request(self,url,object_fh,params=None,return_type=None,extras=None):\\n \\n if params is None:\\n params = {}\\n \\n if extras is None:\\n extras = {}\\n \\n #Polite Pool Work\\n #---------------------------------------\\n #Example \\n #GroovyBib/1.1 (https://example.org/GroovyBib/; mailto:GroovyBib@example.org) BasedOnFunkyLib/1.4.\\n\\n #It is unclear if we need to match this format\\n #This is good enough for now\\n #Eventually we might allow a user to describe their application\\n #version, and url\\n ua_str = 'st_crossref/%s (https://github.com/ScholarTools/crossref_api_python; mailto:%s)' % (VERSION,user_config.email)\\n \\n headers = {'user-agent': ua_str}\\n \\n \\n #TODO Check params and # of results ...\\n \\n #TODO: Implement rate limits ...\\n \\n \\n #The params get passed directly\\n r = self.session.get(url,params=params,headers=headers) \\n \\n\\n #Update limits\\n #--------------------- \\n headers = r.headers\\n self.rate_limit = headers.get('X-Rate-Limit-Limit',50)\\n self.rate_limit_interval = int(headers.get('X-Rate-Limit-Interval','1s')[:-1])\\n \\n #TODO: Implement ...https://konghq.com/blog/how-to-design-a-scalable-rate-limiting-algorithm/\\n \\n\\n #These are debug only and should not be used for anything else\\n #-------------------------------------------------------------\\n self.last_url = url\\n self.last_response = r \\n self.last_params = params \\n \\n if r.status_code == 404:\\n #This typically happens when the DOI is invalid\\n #TODO: Make this a named exception\\n raise errors.RequestError(r.text)\\n \\n json_data = r.json()\\n if json_data['status'] == 'failed':\\n self.last_error = json_data\\n raise errors.CrossrefAPIError(json_data['message'])\\n \\n #Example error \\n \\\"\\\"\\\"\\n {'status': 'failed', 'message-type': 'validation-failure', \\n 'message': [{'value': 'sample', \\n 'message': 'This route does not support sample', 'type': 'parameter-not-allowed'}]}\\n \\\"\\\"\\\" \\n \\n #TODO: return_type\\n if return_type == 'json' or object_fh is None:\\n return json_data\\n else:\\n return object_fh(json_data,self)\",\n \"def request(self, flow: mitmproxy.http.HTTPFlow):\",\n \"def request(self, flow: mitmproxy.http.HTTPFlow):\",\n \"def http_get(config_args):\\n #global config_args\\n \\n \\n try:\\n #r = requests.get(config_args.address,headers=headers,verify=config_args.cacert)\\n if 'https' in config_args.address.lower() and config_args.host != None:\\n headers = {'host': config_args.host}\\n r = requests.get(config_args.address,headers=headers,verify=False)\\n #print(config_args.address.lower())\\n elif 'https' in config_args.address.lower() and config_args.host == None:\\n r = requests.get(config_args.address,verify=False)\\n print(config_args.address.lower())\\n else:\\n r = requests.get(config_args.address)\\n\\n if r.status_code != 200 and r.status_code != 301 and r.status_code != 302:\\n print(\\\"Request failed...code: {}\\\".format(r.status_code))\\n except KeyboardInterrupt:\\n print ('Stopping now....')\\n try:\\n sys.exit(0)\\n except SystemExit:\\n os._exit(0) \\n \\n return r\",\n \"def get_response(request_url):\\n return requests.get(request_url)\",\n \"def reddit_request(url, params):\\n payload = params\\n keys=payload.keys()\\n if 'user-agent' not in keys:\\n payload['user-agent'] = 'downtime'\\n else:\\n pass\\n return requests.get(url, params=payload)\",\n \"def _get(self, request_obj):\\n return self._execute_action(request_obj, 'GET')\",\n \"def fetch_requests(v1):\\n \\n #check if user has any requests\\n if len(all_requests) < 1:\\n return jsonify({\\n \\\"message\\\":\\\"You have not made any requests yet\\\"\\n })\\n \\n #if user has more than one request\\n if len(all_requests) >= 1:\\n return jsonify({\\n \\\"message\\\":\\\"Successfully fetched requests\\\",\\n \\\"requests\\\":[\\n a_request.__dict__ for a_request in all_requests\\n ]\\n })\\n return jsonify({\\\"message\\\":\\\"Can not fetch requests now\\\"})\",\n \"def do_GET(self):\\n self._try_to_process_request(self._handle_get_request)\",\n \"def basic_requests(url):\\r\\n # get requests\\r\\n response = requests.get(base_url+'/get')\\r\\n print(response.status_code)\\r\\n\\r\\n time.sleep(3)\\r\\n print(\\\"Sleep 3 seconds\\\")\\r\\n # post requests\\r\\n response = requests.post(base_url+'/post')\\r\\n print(response.status_code)\\r\\n\\r\\n time.sleep(2)\\r\\n print(\\\"Sleep 3 seconds\\\")\\r\\n response = requests.put(base_url + '/put')\\r\\n print(response.status_code)\\r\\n\\r\\n time.sleep(2)\\r\\n print(\\\"Sleep 3 seconds\\\")\\r\\n response = requests.delete(base_url + '/delete')\\r\\n print(response.status_code)\",\n \"def _req_get(self, url: str):\\n self._get_cookies()\\n if not self._cookies:\\n return\\n r = reqtry.get(url, cookies=self._cookies, allow_redirects=False, timeout=(3, 3), tries=3, delay=1,\\n backoff=1.5, jitter=(1, 1.5))\\n assert r.status_code == 200, f\\\"Get request: Invalid http status code: {r.status_code}\\\"\\n return r\",\n \"def call_api(url):\\n\\n req = requests.get(url)\\n return req\",\n \"def call_api(url):\\n\\n req = requests.get(url)\\n return req\",\n \"def base_request(url_path):\\n response = requests.get(settings.URL_API + url_path)\\n if response.status_code != 200:\\n return response\\n else:\\n return response.json()\",\n \"def access_url(context, url):\\n context.response = requests.get(context.coreapi_url + url)\",\n \"def _Get(self, url, timeout_seconds, headers): # pylint: disable=W0613, R0201\\n raise NotImplementedError() # pragma: no cover\",\n \"def do_GET(s):\\r\\n print \\\"processing get request...\\\"\\r\\n s.send_response(200)\\r\\n s.send_header(\\\"Content-type\\\", \\\"application/json\\\")\\r\\n s.send_header(\\\"Access-Control-Allow-Origin\\\", \\\"*\\\")\\r\\n s.end_headers()\\r\\n\\r\\n inputUrl = s.path\\r\\n\\r\\n print \\\"####INPUT########\\\"\\r\\n print inputUrl\\r\\n print \\\"#####INPUT#######\\\"\\r\\n\\r\\n try:\\r\\n index = string.index(inputUrl, \\\"url=\\\") + 4\\r\\n urlParam = inputUrl[index:]\\r\\n print \\\"url request: \\\" + urlParam\\r\\n response = urllib.urlopen(urlParam).read()\\r\\n s.wfile.write(response)\\r\\n except:\\r\\n print \\\"no url specified\\\"\\r\\n\\r\\n try:\\r\\n index = string.index(inputUrl, \\\"random\\\") + 6\\r\\n randomParam = inputUrl[index:]\\r\\n scientists = open(\\\"C:\\\\Users\\\\ASUS 1\\\\Documents\\\\GitHub\\\\girlsWhoCode\\\\womenScientists\\\\women_scientists.txt\\\", 'r').readlines()\\r\\n size = len(scientists)\\r\\n fileIndex = random.randint(0, size)\\r\\n scientist = scientists[fileIndex]\\r\\n print \\\"random request returning: \\\" + scientist\\r\\n response = json.dumps(scientist)\\r\\n s.wfile.write(response)\\r\\n\\r\\n except Exception as e:\\r\\n print e.message\\r\\n print \\\"no female scientist requested\\\"\\r\\n\\r\\n try:\\r\\n index = string.index(inputUrl, \\\"wiki=\\\") + 5\\r\\n scientistParam = inputUrl[index:]\\r\\n scientist = ' '.join(scientistParam.split(\\\"%20\\\"))\\r\\n print \\\"wiki request for \\\" + scientist\\r\\n page = wikipedia.page(scientist)\\r\\n summary = page.summary\\r\\n response = json.dumps(summary)\\r\\n s.wfile.write(response)\\r\\n except:\\r\\n print \\\"no wiki request\\\"\",\n \"def mock_requests_get(self, mocker):\\n mock = mocker.patch(\\\"requests.get\\\")\\n mock.return_value.__enter__.return_value.json.return_value = {\\n \\\"item\\\": {\\n \\\"icon\\\": \\\"\\\",\\n \\\"icon_large\\\": \\\"\\\",\\n \\\"id\\\": 21787,\\n \\\"type\\\": \\\"Miscellaneous\\\",\\n \\\"typeIcon\\\": \\\"\\\",\\n \\\"name\\\": \\\"Steadfast boots\\\",\\n \\\"description\\\": \\\"A pair of powerful-looking boots.\\\",\\n \\\"current\\\": {\\\"trend\\\": \\\"neutral\\\", \\\"price\\\": \\\"5.9m\\\"},\\n \\\"today\\\": {\\\"trend\\\": \\\"negative\\\", \\\"price\\\": \\\"- 138.2k\\\"},\\n \\\"members\\\": \\\"true\\\",\\n \\\"day30\\\": {\\\"trend\\\": \\\"positive\\\", \\\"change\\\": \\\"+0.0%\\\"},\\n \\\"day90\\\": {\\\"trend\\\": \\\"negative\\\", \\\"change\\\": \\\"-3.0%\\\"},\\n \\\"day180\\\": {\\\"trend\\\": \\\"negative\\\", \\\"change\\\": \\\"-4.0%\\\"},\\n }\\n }\",\n \"def __call__(self, request):\\n if request.host.startswith('127.0.0.1:'):\\n return self.real_http_fetch(request)\\n\\n response = self.http_archive.get(request)\\n\\n if self.use_closest_match and not response:\\n closest_request = self.http_archive.find_closest_request(\\n request, use_path=True)\\n if closest_request:\\n response = self.http_archive.get(closest_request)\\n if response:\\n logging.info('Request not found: %s\\\\nUsing closest match: %s',\\n request, closest_request)\\n\\n if not response:\\n reason = str(request)\\n if self.use_diff_on_unknown_requests:\\n diff = self.http_archive.diff(request)\\n if diff:\\n reason += (\\n \\\"\\\\nNearest request diff \\\"\\n \\\"('-' for archived request, '+' for current request):\\\\n%s\\\" % diff)\\n logging.warning('Could not replay: %s', reason)\\n else:\\n if self.inject_script:\\n response = _InjectScripts(response, self.inject_script)\\n if self.scramble_images:\\n response = _ScrambleImages(response)\\n return response\",\n \"def get(self, *args, **kwargs):\\n self.request(\\\"get\\\", *args, **kwargs)\",\n \"def _get(self, *args, **kwargs):\\n return self._request('get', *args, **kwargs)\",\n \"def test_client_can_load_client_requests_directly(self):\\n\\n req = self.httpbin.get_request_data('get_my_ip')\\n self.assertEqual(req, self.httpbin.client['get_my_ip'])\\n req = self.httpbin.get_request_data('get_my_headers')\\n self.assertEqual(req, self.httpbin.client['get_my_headers'])\\n\\n req = self.httpbin_2.get_request_data('get_my_ip')\\n self.assertEqual(req, self.httpbin_2.client['get_my_ip'])\\n req = self.httpbin_2.get_request_data('get_my_headers')\\n self.assertEqual(req, self.httpbin_2.client['get_my_headers'])\",\n \"def process_request(self, req, resp, resource, params):\",\n \"def _request(self, *args, **kwargs):\\n raise NotImplementedError()\",\n \"def _do_request(self, url, method='GET', body=None):\\n response, content = self.request(url, method=method, body=body, headers=self.headers)\\n if int(response['status']) != 200:\\n raise GPAPIError(response['status'], 'ERROR IN REQUEST')\\n json = simplejson.loads(content)\\n return json\",\n \"def _make_http_request_read(self, path):\\n url = self.url_base + path\\n if url not in self._requests_cache:\\n self._requests_cache[url] = self._perform_http_request(url)[2]\\n return self._requests_cache[url]\",\n \"def get(self, url: str) -> None:\\n\\n if self.number_of_requests_made % self.change_ip_after == 0:\\n self.renew_ip()\\n\\n else:\\n self.wait()\\n\\n self.last_call_timestamp = round(time.time(), 2)\\n super().get(url)\\n\\n self.number_of_requests_made += 1\",\n \"def _process_request(self, request, response):\\n ...\",\n \"def mock_requests_get(self, mocker):\\n mock = mocker.patch(\\\"requests.get\\\")\\n mock.return_value.__enter__.return_value.json.return_value = {\\n \\\"types\\\": [],\\n \\\"alpha\\\": [\\n {\\\"letter\\\": \\\"#\\\", \\\"items\\\": 0},\\n {\\\"letter\\\": \\\"a\\\", \\\"items\\\": 4},\\n {\\\"letter\\\": \\\"j\\\", \\\"items\\\": 2},\\n ],\\n }\",\n \"def _do_request(self, url: str):\\n\\n self.debug.ok('method', self.method)\\n\\n if self.client.fake_response_path:\\n with open(self.client.fake_response_path, 'r') as f:\\n return constants.ResponseCode.OK, f.read()\\n\\n elif self.method == constants.RequestConst.GET:\\n response = requests.get(\\n url, headers=self._headers(), timeout=self._timeout\\n )\\n\\n self.debug.ok(\\n constants.RequestConst.QUERY_PARAMETERS,\\n self.parameters[constants.RequestConst.QUERY]\\n )\\n self.debug.ok(constants.ResponseConst.RESPONSE_OBJECT, response)\\n\\n return response.status_code, response.text\\n\\n elif self.method in [\\n constants.RequestConst.POST,\\n constants.RequestConst.PUT,\\n constants.RequestConst.DELETE\\n ]:\\n if self.method == constants.RequestConst.POST:\\n send_request = requests.post\\n elif self.method == constants.RequestConst.PUT:\\n send_request = requests.put\\n elif self.method == constants.RequestConst.DELETE:\\n send_request = requests.delete\\n\\n response = send_request(\\n url, json=self.parameters[constants.RequestConst.QUERY],\\n headers=self._headers(), timeout=self._timeout\\n )\\n\\n self.debug.ok('payload', self.parameters[\\n constants.RequestConst.QUERY\\n ])\\n self.debug.ok(constants.ResponseConst.RESPONSE_OBJECT, response)\\n\\n return response.status_code, response.text\\n\\n else:\\n return constants.ResponseCode.NOT_FOUND, {}\",\n \"def _request(self, *args):\\n self._silent_request(*args)\\n return self._get_response()\",\n \"def access_gemini_url_patch_method(context, endpoint):\\n url = urljoin(context.gemini_api_url, endpoint)\\n context.response = requests.patch(url)\",\n \"def test_two_legged_get(self):\\n resp, content = self._two_legged(\\\"GET\\\")\\n self.assertEqual(int(resp['status']), 200)\",\n \"def _make_request(self, additional_params: dict, new_base_url: str = None) -> list:\\n if new_base_url:\\n url: str = new_base_url\\n params: dict = additional_params\\n else:\\n url: str = self.base_url\\n params: dict = dict(self.base_params, **additional_params)\\n response: requests.Response = self.session.get(url, params=params)\\n if response.status_code == 200:\\n try:\\n response_text = json.loads(response.text)\\n except ValueError:\\n response_text = response.text\\n else:\\n raise ALHTTPExceptionFromResponse(response)\\n\\n # sometimes we get a pure dictionary back, let's wrap it in a list for consistency\\n if isinstance(response_text, dict):\\n response_text = [response_text]\\n return response_text\",\n \"def test_get_request_normal_response(self, mock_get):\\n\\n # Arrange\\n # Construct our mock response object, giving it relevant expected behaviours\\n mock_resp_instance = MockResponse({\\\"msg\\\": \\\"success\\\"}, 200, content=\\\"abc\\\")\\n mock_get.return_value = mock_resp_instance\\n\\n # Act\\n response = get_request_data(self.url, json_resp=False)\\n\\n # Assert that the request-response cycle completed successfully.\\n self.assertEqual(mock_resp_instance.status_code, 200)\\n self.assertEqual(response, mock_resp_instance)\",\n \"def _get(self, url: str) -> requests.Response:\\n # todo: do some error checking here\\n if url.startswith(API_PATH['base']):\\n try:\\n # logger.debug(f\\\"RestClient._get(): {url}\\\") # log in calling function\\n response = requests.get(url, auth=self.auth)\\n rest_code = response.json()['meta']['code']\\n if rest_code not in [200, 201, 204]:\\n raise RestException(f\\\"REST API Error: {rest_code}. {response.content}\\\")\\n except RestException as e:\\n logger.error(e)\\n return None\\n return response\\n else:\\n raise ValueError(f\\\"URL is invalid: {url}\\\")\",\n \"async def _make_request(self, url: str, params, server_id: str):\\n headers = {\\n 'X-Response-Control': 'minified',\\n 'User-Agent': 'Friendly Red bot'\\n }\\n\\n if server_id in self.config:\\n if 'API_TOKEN' in self.config[server_id]:\\n headers['X-Auth-Token'] = self.config['API_TOKEN']\\n else:\\n await self.bot.say(box('Requests made without an authentication token are limited to 100 requests per 24 hours.\\\\nYou can request a key by registering at http://api.football-data.org and setting it via [p]football tokenset.'))\\n\\n async with aiohttp.get(url, headers=headers, params=params) as r:\\n if r.status == 200:\\n data = await r.json()\\n return data\\n elif r.status == 400:\\n await self.bot.say(box('Bad Request [400]:\\\\nYour request was malformed most likely the value of a Filter was not set according to the Data Type that is expected.'))\\n return\\n elif r.status == 403:\\n await self.bot.say(box('Restricted Resource [403]:\\\\nYou tried to access a resource that exists, but is not available for you. This can be out of the following reasons:\\\\n- the resource is only available to authenticated clients\\\\n- the resource is only available to donating clients\\\\n- the resource is not available in the API version you are using'))\\n return\\n elif r.status == 404:\\n await self.bot.say(box('Not found [404]\\\\nYou tried to access a resource that doesn’t exist.'))\\n return\\n elif r.status == 429:\\n await self.bot.say(box('Too many requests [429]\\\\nYou exceeded your allowed requests per minute/day depending on API version and your user status.\\\\nSee http://api.football-data.org/docs/v1/index.html#_request_throttling for more information.'))\\n await self.bot.say(box('Requests reset in ' + r.headers['X-RequestCounter-Reset'] + ' seconds.'))\\n return\\n else:\\n await self.bot.say(box('Pancake has no idea what you\\\\'ve done, seriously.'))\\n await self.bot.say(box(r.status + '\\\\n' + r.json()['error']))\\n return\",\n \"def get(self, url):\\n super().get(mfacebookToBasic(url))\",\n \"def request(self, method, url, params=None, data=None):\\n raise NotImplementedError(\\n u\\\"%s: Method not implemented\\\", self.__class__.__name__)\",\n \"def _request(self, url, method=\\\"GET\\\", data=None):\\n\\t\\t# TODO: exception handling\\n\\t\\tif self.logged_in:\\n\\t\\t\\tcookie_list = [\\\"{}={}\\\".format(k, v) for k, v in self.cookies.iteritems()]\\n\\t\\t\\theaders = {'Cookie': \\\"; \\\".join(cookie_list)}\\n\\t\\telse:\\n\\t\\t\\theaders = {}\\n\\t\\tself.connection.request(method, self.base_path + url, data, headers)\\n\\t\\treturn self.connection.getresponse()\",\n \"def handle_request_get(self, msg):\\n\\n\\t\\tfor arg in msg.arguments:\\n\\t\\t\\tmethod = {\\n\\t\\t\\t\\t'ucr': self.handle_request_get_ucr,\\n\\t\\t\\t\\t'meta': self.handle_request_get_meta,\\n\\t\\t\\t\\t'info': self.handle_request_get_info,\\n\\t\\t\\t\\t'modules/list': self.handle_request_get_modules,\\n\\t\\t\\t\\t'modules': self.handle_request_get_modules,\\n\\t\\t\\t\\t'categories/list': self.handle_request_get_categories,\\n\\t\\t\\t\\t'categories': self.handle_request_get_categories,\\n\\t\\t\\t\\t'user/preferences': self.handle_request_get_user_preferences,\\n\\t\\t\\t\\t'hosts/list': self.handle_request_get_hosts,\\n\\t\\t\\t\\t'hosts': self.handle_request_get_hosts,\\n\\t\\t\\t}.get(arg)\\n\\t\\t\\tif method:\\n\\t\\t\\t\\tself.finished(msg.id, method(msg))\\n\\t\\t\\t\\treturn\\n\\t\\traise NotFound()\",\n \"def request(self, method, url):\\n\\t\\ttr = TwitterRequest( method.upper(), url )\\n\\t\\treturn self.get_response( tr )\",\n \"def _request(self, method, uri, **kwargs):\\n url = self.url + uri\\n self.logger.debug(\\\"Requesting {} on {}\\\".format(method, url))\\n response = requests.request(method, url, verify=self.verify, **kwargs)\\n try:\\n response.raise_for_status()\\n except requests.exceptions.HTTPError:\\n self.logger.error(\\\"Bad http code {} requesting Clair\\\".format(response.status_code))\\n if response.reason == \\\"Not Found\\\":\\n raise ResourceNotFoundException(\\\"Resource not found\\\")\\n raise ClairConnectionError(response)\\n return response\",\n \"def _request(self, method, *args, **kwargs):\\n if not \\\"headers\\\" in kwargs:\\n kwargs[\\\"headers\\\"] = self._headers\\n return self._session.request(method, self._url(*args), **kwargs)\",\n \"def request(self, method, url, *args, **kwargs):\\n full_url = urljoin(self.base_url, url)\\n if 'data' in kwargs:\\n kwargs['data'] = self._encode_data(kwargs['data'])\\n return super(Client, self).request(method, full_url, *args, **kwargs)\",\n \"def start_requests(self):\\n # This predefined list of URLs is chosen to include all types of\\n # inquiries possible in the Austrian parliament in order to provide a\\n # suitable testing surface for new functions.\\n # urls = [\\\"https://www.parlament.gv.at/PAKT/VHG/XXV/JPR/JPR_00019/index.shtml\\\", \\\"https://www.parlament.gv.at/PAKT/VHG/XXV/JPR/JPR_00016/index.shtml\\\", \\\"https://www.parlament.gv.at/PAKT/VHG/XXV/J/J_06954/index.shtml\\\", \\\"https://www.parlament.gv.at/PAKT/VHG/XXV/M/M_00178/index.shtml\\\", \\\"https://www.parlament.gv.at/PAKT/VHG/XXV/JEU/JEU_00003/index.shtml\\\", \\\"https://www.parlament.gv.at/PAKT/VHG/XXV/J/J_06758/index.shtml\\\", \\\"https://www.parlament.gv.at/PAKT/VHG/BR/J-BR/J-BR_03089/index.shtml\\\",\\n # \\\"https://www.parlament.gv.at/PAKT/VHG/BR/J-BR/J-BR_03091/index.shtml\\\", \\\"http://www.parlament.gv.at/PAKT/VHG/BR/J-BR/J-BR_01155/index.shtml\\\", \\\"http://www.parlament.gv.at/PAKT/VHG/XX/J/J_06110/index.shtml\\\", \\\"http://www.parlament.gv.at/PAKT/VHG/XX/J/J_06651/index.shtml\\\", \\\"http://www.parlament.gv.at/PAKT/VHG/XX/J/J_04024/index.shtml\\\", \\\"http://www.parlament.gv.at/PAKT/VHG/XX/J/J_04025/index.shtml\\\", \\\"https://www.parlament.gv.at/PAKT/VHG/XX/M/M_00178/index.shtml\\\"]\\n urls = [] if not self.url_override else [self.url_override]\\n\\n if self.LLP and not self.url_override:\\n for i in self.LLP:\\n for nrbr in ['NR', 'BR']:\\n roman_numeral = roman.toRoman(i)\\n options = self.URLOPTIONS.copy()\\n options['GP'] = roman_numeral\\n options['NRBR'] = nrbr\\n url_options = urlencode(options)\\n url_llp = \\\"{}?{}\\\".format(self.BASE_URL, url_options)\\n rss = feedparser.parse(url_llp)\\n\\n self.logger.info(\\\"GP {}: {} inquiries from {}\\\".format(\\n roman_numeral, len(rss['entries']), nrbr)\\n )\\n urls = urls + [entry['link'] for entry in rss['entries']]\\n self.TOTAL_COUNTER = len(urls)\\n for url in urls:\\n yield self.make_requests_from_url(url)\",\n \"def _get_request(url, params):\\n request = requests.get(url, params=params)\\n\\n return request\",\n \"def challenge_get(self, environ, start_response):\\n environ['wsgiorg.routing_args'][1]['recipe_name'] = self.CHALLENGER_RECIPE\\n environ['tiddlyweb.type'] = 'text/x-tiddlywiki'\\n return get_tiddlers(environ, start_response)\",\n \"def _request(self, url):\\n response = requests.get(url, headers=self.header)\\n\\n if str(response.status_code).startswith('2'):\\n return response\\n\\n raise Exception(\\\"URI request returned an error. Error Code \\\" + str(response.status_code))\",\n \"def test_client_load_pages_request(self):\\n is_present = hasattr(self.httpbin_3, 'test_requests_patch_method')\\n\\n self.assertTrue(is_present)\",\n \"def __patch(self, url):\\n\\n res = requests.patch(url, headers=self.auth_header)\\n res.raise_for_status()\\n return res\",\n \"def get(self, request, *args, **kwargs):\\n verify_secure(request)\\n return super().get(request, args, kwargs)\",\n \"def get(self, request, *args, **kwargs):\\n verify_secure(request)\\n return super().get(request, args, kwargs)\",\n \"def get(self, request, *args, **kwargs):\\n verify_secure(request)\\n return super().get(request, args, kwargs)\",\n \"def get(self, request, *args, **kwargs):\\n verify_secure(request)\\n return super().get(request, args, kwargs)\",\n \"def _request(self, method, url, params=None, data=None, request_type=PRIVATE, headers={}):\\n self._is_valid_request_option(request_type=request_type)\\n\\n request_headers = copy.deepcopy(self.BASE_HEADERS)\\n request_headers.update(headers)\\n\\n response = getattr(requests, method.lower())(\\n url,\\n headers=request_headers,\\n params=params,\\n data=data\\n )\\n\\n return self._handle_response(response)\",\n \"def patched_request(urlpath):\\n def inner(f):\\n def wrapped(self, *args, **kwargs):\\n cookies = self.client.get(urlpath, verify=False, auth=HTTP_BASIC_AUTH_CREDENTIALS).cookies\\n token = cookies.get('csrftoken')\\n headers = {\\n 'X-CSRFToken': token,\\n 'X-Requested-With': 'XMLHttpRequest',\\n 'Content-Type': 'application/json'\\n }\\n f_kwargs = dict(verify=False, auth=HTTP_BASIC_AUTH_CREDENTIALS, headers=headers, cookies=cookies)\\n get = partial(self.client.get, **f_kwargs)\\n post = partial(self.client.post, **f_kwargs)\\n put = partial(self.client.put, **f_kwargs)\\n args += (get, post, put)\\n return f(self, *args, **kwargs)\\n return wrapped\\n return inner\",\n \"def render_GET(self, request):\\r\\n # First check if the version is ok\\r\\n try:\\r\\n version = request.args['version']\\r\\n except KeyError:\\r\\n request.setResponseCode(httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0])\\r\\n request.setHeader('content-type', 'text/plain; charset=utf-8')\\r\\n return \\\"Request is missing parameter: 'version'\\\"\\r\\n\\r\\n if len(version) != 1:\\r\\n request.setResponseCode(httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0])\\r\\n request.setHeader('content-type', 'text/plain; charset=utf-8')\\r\\n return \\\"Parameter 'version' has to be unique in request.\\\"\\r\\n\\r\\n version = version[0]\\r\\n\\r\\n if version < MINIMAL_VERSION:\\r\\n request.setResponseCode(httpstatus.HTTP_STATUS_CODE_GONE[0])\\r\\n request.setHeader('content-type', 'text/plain; charset=utf-8')\\r\\n return ('Client version is insufficient. Minimal version is '\\r\\n \\\"'{0}'.\\\".format(MINIMAL_VERSION))\\r\\n elif version > CURRENT_VERSION:\\r\\n request.setResponseCode(httpstatus.HTTP_STATUS_CODE_NOT_IMPLEMENTED[0])\\r\\n request.setHeader('content-type', 'text/plain; charset=utf-8')\\r\\n return 'Client version is newer than version supported by server.'\\r\\n\\r\\n # Version is ok, now the GET request can be processed\\r\\n # Extract and check the arguments\\r\\n try:\\r\\n userID = request.args['userID']\\r\\n except KeyError:\\r\\n request.setResponseCode(httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0])\\r\\n request.setHeader('content-type', 'text/plain; charset=utf-8')\\r\\n return \\\"Request is missing parameter: 'userID'\\\"\\r\\n\\r\\n if len(userID) != 1:\\r\\n request.setResponseCode(httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0])\\r\\n request.setHeader('content-type', 'text/plain; charset=utf-8')\\r\\n return \\\"Parameter 'userID' has to be unique in request.\\\"\\r\\n\\r\\n userID = userID[0]\\r\\n\\r\\n # Get the URL of a Robot process\\r\\n d = self._realm.requestURL(userID)\\r\\n d.addCallback(self._build_response, version, request)\\r\\n d.addErrback(self._handle_error, request)\\r\\n\\r\\n return NOT_DONE_YET\",\n \"def MutateCustomInterests(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def _api_call(self, url, response_checker):\\n self.request_compare(url)\",\n \"def test_client_can_do_get_request(self):\\n response = self.httpbin.get_my_headers(headers={'User-agent': 'Fake user agent'})\\n self.assertEqual(response.request.method, 'GET')\\n self.assertEqual(response.status_code, 200)\",\n \"def fetch_a_request(v1, requestid):\\n\\n #check if user has any requests\\n if len(all_requests) < 1:\\n return jsonify({\\n \\\"message\\\":\\\"You have not made any requests yet\\\"\\n })\\n \\n #if user has more than one request\\n if len(all_requests) >= 1:\\n returned_request = []\\n for a_request in all_requests:\\n if a_request.request_id == int(requestid):\\n returned_request.append(a_request)\\n return jsonify({\\n \\\"message\\\": \\\"Successfully fetched the request\\\",\\n \\\"request\\\": returned_request[0].__dict__\\n })\\n \\n return jsonify({\\n \\\"message\\\":\\\"Request doesnt exist\\\"\\n })\",\n \"def monkey_patch_requests_for_xray():\\n wrapt.wrap_function_wrapper(\\n \\\"requests.sessions\\\", \\\"Session.send\\\", xray_requests_send,\\n )\",\n \"def test_request(self):\\n client = RestClient(host=self.host, username='')\\n rest_url = 'some/url/'\\n\\n # Mock good get response\\n with responses.RequestsMock() as rsps:\\n rsps.add(responses.GET, f'{self.host}/{rest_url}', status=200,\\n json={'value':\\\"good!\\\"})\\n r = client.request('get', rest_url)\\n assert r.status_code == 200\\n assert r.json()['value'] == 'good!'\\n \\n # Mock bad get response\\n with responses.RequestsMock() as rsps:\\n rsps.add(responses.GET, f'{self.host}/{rest_url}', status=401,\\n json={'value':\\\"bad!\\\"})\\n with raises(requests.HTTPError):\\n r = client.request('get', rest_url)\\n r = client.request('get', rest_url, checkstatus=False)\\n assert r.status_code == 401\\n assert r.json()['value'] == 'bad!'\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6091576","0.5723631","0.5565101","0.5542613","0.55409104","0.55404246","0.5505588","0.5505458","0.54588634","0.5443315","0.5433013","0.5402714","0.5384366","0.5381944","0.5375504","0.5370188","0.5344704","0.5320391","0.5319966","0.531785","0.5312466","0.53021806","0.52882236","0.5266166","0.52658015","0.5263842","0.52623254","0.5258456","0.524351","0.52384543","0.5231183","0.5228995","0.52281874","0.5227598","0.5223713","0.522342","0.5222416","0.5217456","0.52126706","0.52126706","0.5212656","0.5210863","0.5204232","0.51968765","0.5192916","0.5190968","0.5180385","0.5177196","0.51769125","0.51769125","0.517456","0.5170755","0.51619613","0.5152714","0.5149479","0.5146963","0.5139456","0.5135463","0.51248443","0.5117607","0.5114928","0.5113999","0.51059264","0.5105139","0.5101366","0.5083382","0.50790405","0.5075156","0.50737995","0.5066479","0.5065204","0.5044489","0.50436544","0.50425375","0.5041496","0.5037819","0.503611","0.50327253","0.50323135","0.50303274","0.5029045","0.50242627","0.50229156","0.50194085","0.50181216","0.501274","0.50117266","0.5010329","0.50080234","0.50080234","0.50080234","0.50080234","0.5003852","0.5001169","0.5000345","0.49926776","0.49871254","0.49862313","0.49850047","0.49774465","0.49715942"],"string":"[\n \"0.6091576\",\n \"0.5723631\",\n \"0.5565101\",\n \"0.5542613\",\n \"0.55409104\",\n \"0.55404246\",\n \"0.5505588\",\n \"0.5505458\",\n \"0.54588634\",\n \"0.5443315\",\n \"0.5433013\",\n \"0.5402714\",\n \"0.5384366\",\n \"0.5381944\",\n \"0.5375504\",\n \"0.5370188\",\n \"0.5344704\",\n \"0.5320391\",\n \"0.5319966\",\n \"0.531785\",\n \"0.5312466\",\n \"0.53021806\",\n \"0.52882236\",\n \"0.5266166\",\n \"0.52658015\",\n \"0.5263842\",\n \"0.52623254\",\n \"0.5258456\",\n \"0.524351\",\n \"0.52384543\",\n \"0.5231183\",\n \"0.5228995\",\n \"0.52281874\",\n \"0.5227598\",\n \"0.5223713\",\n \"0.522342\",\n \"0.5222416\",\n \"0.5217456\",\n \"0.52126706\",\n \"0.52126706\",\n \"0.5212656\",\n \"0.5210863\",\n \"0.5204232\",\n \"0.51968765\",\n \"0.5192916\",\n \"0.5190968\",\n \"0.5180385\",\n \"0.5177196\",\n \"0.51769125\",\n \"0.51769125\",\n \"0.517456\",\n \"0.5170755\",\n \"0.51619613\",\n \"0.5152714\",\n \"0.5149479\",\n \"0.5146963\",\n \"0.5139456\",\n \"0.5135463\",\n \"0.51248443\",\n \"0.5117607\",\n \"0.5114928\",\n \"0.5113999\",\n \"0.51059264\",\n \"0.5105139\",\n \"0.5101366\",\n \"0.5083382\",\n \"0.50790405\",\n \"0.5075156\",\n \"0.50737995\",\n \"0.5066479\",\n \"0.5065204\",\n \"0.5044489\",\n \"0.50436544\",\n \"0.50425375\",\n \"0.5041496\",\n \"0.5037819\",\n \"0.503611\",\n \"0.50327253\",\n \"0.50323135\",\n \"0.50303274\",\n \"0.5029045\",\n \"0.50242627\",\n \"0.50229156\",\n \"0.50194085\",\n \"0.50181216\",\n \"0.501274\",\n \"0.50117266\",\n \"0.5010329\",\n \"0.50080234\",\n \"0.50080234\",\n \"0.50080234\",\n \"0.50080234\",\n \"0.5003852\",\n \"0.5001169\",\n \"0.5000345\",\n \"0.49926776\",\n \"0.49871254\",\n \"0.49862313\",\n \"0.49850047\",\n \"0.49774465\",\n \"0.49715942\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":5490,"cells":{"query":{"kind":"string","value":"Update the ElasticSearch index every hour."},"document":{"kind":"string","value":"def update_es_index():\n\n for job in scheduler.get_jobs():\n if 'task_type' in job.meta and job.meta['task_type'] == \"update_index\":\n scheduler.cancel(job)\n\n scheduler.schedule(\n scheduled_time=datetime.now(),\n func='haystack.management.commands.update_index.Command().handle()',\n interval=60 * 60,\n repeat=None,\n )\n\n for job in scheduler.get_jobs():\n index_job = job\n if index_job.func_name == 'haystack.management.commands.update_index.Command().handle()':\n break\n\n index_job.meta['task_type'] = \"update_index\"\n index_job.save()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def index_later(self):\n return","def update_time(cls, key):\n key.put()","def every_hour(self, time, function, args=None, kwargs=None, name=None):\n if args is None:\n args = list()\n if kwargs is None:\n kwargs = dict()\n if name is None:\n name = function.__name__+(f'_{len(self.config)+1}' if function.__name__ in self.config else '')\n self.config[name] = {'mode':'every_hour', 'time':time, 'function':function, 'args':args, \n 'kwargs':kwargs, 'execute_num':0, 'runner':(function, args, kwargs, name),\n 'time_init':datetime.datetime.now()}\n self.params.tracker_dict[name] = dict()","def update(self):\n if self._refreshed_at is None or (\n self._refreshed_at + self._refresh_rate <= datetime.datetime.now()):\n\n self.run()","def periodicUpdate(self):\n try:\n logging.info(f'{self.cn} periodicUpdate = Start')\n isHaz = JsonSettings.parseJson('settings.json','isHazelcast')\n if self.db.isDb():\n self.insertStats()\n self.insertPorts()\n if isHaz:\n self.insertHaz() \n else:\n self.db.initDb()\n self.insertSys()\n self.insertStats()\n self.insertPorts()\n if isHaz:\n self.insertHaz() \n except Exception as e:\n logging.critical(f'{self.cn} Exception: {e}')\n logging.critical(f'{self.cn} StackTrace: \\n', exc_info=1)\n finally:\n logging.info(f'{self.cn} periodicUpdate = End')","def do_update(url,indexHeaders,update_file):\n updateUrl=url.replace(\"buckets\",\"riak\")\n indexHeaders['content-type'] = 'application/json'\n r=requests.post(url, data=json.dumps(update_file), headers=indexHeaders)","def step010():\n logger.logMessage('Begin: Getting candidate documents from elasticsearch')\n\n def limitHour(d):\n thish = d.start_time.tz_localize(tz='UTC')\n nexth = thish + dt.timedelta(hours=1)\n return { 'range': { 'time': {'gte':thish, 'lt':nexth } } }\n \n conn = sql.create_engine(pgurl)\n client = es.Elasticsearch(hostlist)\n dupesDF = pd.read_sql_table('weather_dupes',conn).set_index('time')\n hours =dupesDF.to_period('H').reset_index()['time'].unique()\n ranges = [ limitHour(h) for h in hours ]\n query = { \n '_source': [ 'tsa','time' ],\n 'query': { \n 'bool': { 'should': ranges } \n } \n }\n #logger.logMessage(level='DEBUG',message='Query body: {0}'.format(query))\n hits = eshelp.scan(client=client,index=indexName,doc_type='doc',query=query)\n numRecs = 0\n with open(candidatesFile,'w') as f:\n for h in hits:\n src = h['_source']\n tsa = int(src['tsa'])\n time = src['time']\n docid = h['_id']\n idx = h['_index']\n f.write(f'{tsa:014d};{time:25s};{docid:32s};{idx:32s}\\n') \n numRecs += 1\n if numRecs % 1000 == 0:\n logger.logMessage(level='DEBUG',message=\"{0:9d} records written\".format(numRecs))\n logger.logMessage(message=\"{0:9d} total records written\".format(numRecs))\n logger.logMessage('End: Getting candidate documents from elasticsearch')","def cron_refresh_spacetrack_cache():\n s = SpaceTrackApi()\n updated_tles_str = s.get_all_tles()\n storage.save_tle_cache(updated_tles_str)\n last_updated[0] = int(time.time())\n metadata = {\n 'last_updated': last_updated[0],\n }\n storage.save_metadata(metadata)","def reindex(self):","def reindex(self):","def update(self, time):\n raise NotImplementedError","def update(self, time):\n raise NotImplementedError","def refresh(self):\n\n self._refreshed_on = time.time() * 1000","def _update_on_refresh():\n cities = City.query.all()\n\n #Iterates over all cities in the database and updates their value\n for city in cities:\n metric_resp, imperial_resp = _get_open_weather_requests(city.name)\n\n metric_json = metric_resp.json()\n imperial_json = imperial_resp.json()\n\n city.temp_celsius = int(metric_json[MAIN][TEMPERATURE])\n city.temp_fahrenheit = int(imperial_json[MAIN][TEMPERATURE])\n db.session.commit()","def store_elasticsearch(self, item):\n self.datastore.create(\n index=\"dminer-alphabay-{date}\".format(\n date=datetime.datetime.strptime(item[\"timestamp\"], \"%Y:%m:%d %H:%M:%S\").date().strftime(\"%Y-%m-%d\")\n ),\n doc_type= \"alphabay_listing\",\n body=item\n )","def update(self, dt):\n pass","async def afterHoursAutoPurge(self, ctx: Context):","def store_elasticsearch(self, item):\n self.datastore.create(\n index=\"dminer-dreammarket-{date}\".format(\n date=datetime.datetime.strptime(item[\"timestamp\"], \"%Y:%m:%d %H:%M:%S\").date().strftime(\"%Y-%m-%d\")\n ),\n doc_type= \"dreammarket_listing\",\n body=item\n )","async def _timein_refresh(self):\n\t\t\n\t\tawait self.refresh_cache()","def _update(self, host):\n pass","def update_news_intime(minutes):\n while True:\n db_update.update()\n time.sleep(60 * minutes)","def __setitem__(self, url, reslut):\n record = {'result': reslut, 'timestamp': datetime.datetime.utcnow()}\n try:\n self.es.index(index=self.index, doc_type=self.doc_type, id=url, body=record)\n except Exception as e:\n print e\n print url, 'failed'","def refresh():\r\n DB.drop_all()\r\n DB.create_all()\r\n # TODO Get data from OpenAQ, make Record objects with it, and add to db\r\n for i in time_x_values():\r\n DB.session.add(Record(datetime=i[0], value=i[1]))\r\n DB.session.commit()\r\n return 'Data refreshed!'","def refresh_index(self):\n synchronize()\n # TODO: add logger call here\n self._compute_embeddings()","def refresh():\r\n db.drop_all()\r\n db.create_all()\r\n for time_value in get_datetime_values('Los Angeles', 'pm25'):\r\n record = Record(datetime=str(time_value[0]), value=time_value[1])\r\n db.session.add(record)\r\n db.session.commit()\r\n return render_template('refresh.html')","def step070() -> None:\n logger.logMessage('Begin: elasticsearch bulk update')\n client = es.Elasticsearch(hostlist)\n\n def generate():\n with open(renumFile,'r') as f:\n line = f.readline().rstrip()\n while line != '':\n fields = line.split(';')\n oper = { '_index': fields[3], \n '_op_type': 'update',\n '_id': fields[2].rstrip(),\n '_type': 'doc',\n '_source:': {'doc': {'tsa': fields[0]}}}\n \n yield oper\n line = f.readline().rstrip()\n result = eshelp.bulk(client,generate())\n logger.logMessage('Bulk result: {0}'.format(result))\n logger.logMessage('End : elasticsearch bulk update')","def update(self, dt):","def update(self, dt):","def reindex(self):\n raise NotImplementedError()","def addDayHourToURange(self, dayHour, index):\n ur_hist_len = len(self.__data['updateRange'][index]['updateHistory']) - Predictor.rangeHistorySize\n if (ur_hist_len > 0):\n for i in range(ur_hist_len):\n self.__data['updateRange'][index]['updateHistory'].pop(0)\n self.__data['updateRange'][index]['updateHistory'].append(dayHour)","def every_day():\n logger.info('[ EVERY_DAY ] [ %s ]' % str(datetime.now().time()))","def increment_hourly_total(self, unique, property_id=None, value=1):\n key = (self.user_name, self.bucket_name, \"hourly_event\", self.shard)\n property_id = property_id or _32_BYTE_FILLER\n column_id = \"\".join([\n self.id,\n property_id[0:16],\n pack_hour(),\n property_id[16:32]])\n increment_counter(key, column_id=column_id, value=value)\n if unique:\n key = (\n self.user_name, \n self.bucket_name, \n \"hourly_unique_event\", \n self.shard)\n increment_counter(key, column_id=column_id)","def update_time(self):\n pass # Do nothing","def finish_hour(self):\n\t\tassert len(self.values) >= 4, 'A fully formed update date is needed.'\n\t\tself.values = self.values[:4]","def update_time(self):\n try:\n self._thread_pool_executor.submit(self._update_time_fn)\n except:\n self._logger.exception('Exception caught submitting time metrics update task.')","def do_upt(self, arg):\n self.do_timesheet('update today')","def update(self, dt):\n\t\tpass","def update_index(self, ref_gen):\n testing = True\n logging.warning('Updating index')\n es_insert.index(es, ref_gen, self.index_name, testing, action=\"update\")\n logging.warning('Finished updating')","def app_index_job(cls):\n import time\n s = time.time()\n print('init--redis')\n news = json.dumps(DB.index_news(), ensure_ascii=False)\n mvs = json.dumps(DB.index_mvs('mv'), ensure_ascii=False)\n dsjs = json.dumps(DB.index_mvs('dsj'), ensure_ascii=False)\n dms = json.dumps(DB.index_mvs('dm'), ensure_ascii=False)\n zys = json.dumps(DB.index_mvs('zy'), ensure_ascii=False)\n mv_top = json.dumps(DB.index_tops('mv')[0:6], ensure_ascii=False)\n dsj_top = json.dumps(DB.index_tops('dsj')[0:6], ensure_ascii=False)\n zy_top = json.dumps(DB.index_tops('zy')[0:6], ensure_ascii=False)\n dm_top = json.dumps(DB.index_tops('dm')[0:6], ensure_ascii=False)\n # 今日更新和总视频数量\n today, total = DB.today_total(None)\n # 淘宝广告\n ads = json.dumps(TBApi.get_tb_goods(), ensure_ascii=False)\n cls.r.set('news', news)\n cls.r.set('mvs', mvs)\n cls.r.set('dsjs', dsjs)\n cls.r.set('dms', dms)\n cls.r.set('zys', zys)\n cls.r.set('mv_top', mv_top)\n cls.r.set('dsj_top', dsj_top)\n cls.r.set('zy_top', zy_top)\n cls.r.set('dm_top', dm_top)\n cls.r.set('today', today)\n cls.r.set('total', total)\n cls.r.set('ads', ads)\n del news, mvs, dsjs, dms, zys, mv_top, dsj_top, zy_top, dm_top, ads\n print(f'{time.time() - s}')","async def send_to_elastic(self, data, index='wallarm'):\n self.es.index(body=data, index=index)\n return print('Sent successfully')","def refresh():\n DB.drop_all()\n DB.create_all()\n df_meas = open_api.measurements(city='Los Angeles', parameter='pm25', df=True)\n df_meas['date.utc'] = df_meas['date.utc'].astype(str)\n create_DB_records(df_meas)\n DB.session.commit()\n message = 'Data refreshed on: ' + str(datetime.datetime.now())\n over9s = Record.query.filter(Record.value > 9)\n recs = Record.query.filter(Record.id < 20)\n over5s = Record.query.filter(Record.value > 5)\n return render_template('base.html', message=message, over9s=over9s, over5s=over5s, recs=recs)","def solr_reindex(where=None):\n config = get_config(where)\n with settings(host_string=config['host_string']), cd(config['installation_dir']):\n cmd = 'bin/django update_index dasa --batch-size=5000 --remove --verbosity=2'\n run(cmd)","def reset_file_index_cache() -> None:\n fileindex_cache_five_minutes.invalidate()","def hour(self) -> Index:\n warnings.warn(\n \"`hour` will return int32 index instead of int 64 index in 4.0.0.\",\n FutureWarning,\n )\n return Index(self.to_series().dt.hour)","def updateDateIndex(map, accidente):\n occurreddate = accidente['Start_Time']\n accidentedate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\n entry = om.get(map, accidentedate.date())\n if entry is None:\n datentry = newDataEntry(accidente)\n om.put(map, accidentedate.date(), datentry)\n else:\n datentry = me.getValue(entry)\n addDateIndex(datentry, accidente)\n return map","def update(self, es, **kwargs):\n pass","def update(self, wiki):\n self.initialize_index()\n last_rev = self.get_last_revision()\n if last_rev == -1:\n changed = self.storage.all_pages()\n else:\n changed = self.storage.changed_since(last_rev)\n changed = list(changed)\n # six.print_('changed', changed, last_rev)\n if changed:\n self.reindex(wiki, changed)\n # if self.INDEX_THREAD and self.INDEX_THREAD.is_alive:\n # print 'alreading reindexing'\n # else:\n # self.INDEX_THREAD = threading.Thread(target=self.reindex, args=(wiki, changed))\n # self.INDEX_THREAD.daemon = True\n # self.INDEX_THREAD.start()","def refresh_index_patterns(cluster, patterns):\n _refresh_path = '/es_admin/.kibana/index-pattern/'\n _headers = {'kbn-xsrf': 'anything'}\n kbn_config = cluster['kibana']\n kbn_auth = cluster['kibana']['auth']\n kbn_url = f'{kbn_config[\"protocol\"]}://{kbn_config[\"url\"]}:{kbn_config[\"port\"]}'\n\n for pattern, timefield in patterns.items():\n quoted_pattern = quote_plus(pattern, safe='*')\n url = f'{kbn_url}{_refresh_path}{quoted_pattern}/'\n\n # if time series pattern, add timefield\n payload = {'title': pattern, 'notExpandable': True}\n if timefield:\n payload['timeFieldName'] = timefield\n\n rv = requests.post(url, json=payload, headers=_headers, auth=kbn_auth)\n log.debug('sent_refresh', pattern=pattern, payload=payload,\n url=url, response={**rv.__dict__})","def make_hourly(self,rate,name):\n id = self.find_employee_id(name)\n if id in self.clsf:\n self.emp_dict[id][5] = \"1\"\n print(\"{}{}\".format(name,\" was successfully changed to be an hourly employee\"))\n self.emp_dict[id][8] = rate\n self.classification()\n return self.emp_dict\n else:\n print(\"Error- employee not found\")\n self.employee_data()","def update_timeindex(self, day):\n self.current_positions['datetime'] = self.bars.date\n self.all_positions.append(self.current_positions.copy())\n\n self.current_prices['datetime'] = self.bars.date\n self.all_prices.append(self.current_prices.copy())\n\n self.current_holdings['datetime'] = self.bars.date\n self.all += (self.buy + self.sell)\n self.current_holdings['buy_times'] = self.buy\n self.current_holdings['sell_times'] = self.sell\n self.current_holdings['total_times'] = self.all\n\n hold = 0\n self.current_holdings['total'] = self.current_holdings['cash']\n for s in self.symbol_list:\n # Approximates the real value\n if self.current_positions[s] > 0:\n hold += 1\n market_value = self.current_positions[s] * \\\n self.bars.get_latest_bar_value(s, 'True_close')\n self.current_holdings['total'] += market_value\n\n self.current_holdings['hold'] = hold\n # Append the current holdings\n self.all_holdings.append(self.current_holdings.copy())\n\n print 'Day %s[%s]: buy=%s, sell=%s, hold=%s.' % \\\n (day, self.bars.date, self.buy, self.sell, hold)","def _update_index(self):\n start_time = datetime.datetime.now()\n sys.stdout.write(\"Updating index. Depending on the size of your music \"\n \"collection this may take some time, so please be patient. \"\n \"(Update started at %s)\\n\" % start_time)\n new_index_file = \"%s/music_index_%s.txt\" % (self.index_dir,\n start_time.strftime(\"%Y%m%d_%H%M%S\"))\n files = (os.path.join(tup[0], f) for d in self.music_dirs \n for tup in os.walk(d) \n for f in tup[2] )\n \n with open(new_index_file, \"w\") as fh:\n for filename in files:\n fh.write(\"%s\\n\" % filename)\n \n end_time = datetime.datetime.now()\n sys.stdout.write(\"Music index updated (created index file '%s')\\n\" \n \"Update duration:%s\\n\" % \n (new_index_file, end_time - start_time))","def commit(self):\n with self.lock:\n try:\n action_buffer = self.BulkBuffer.get_buffer()\n if action_buffer:\n successes, errors = bulk(self.elastic, action_buffer)\n except Exception as e:\n # Handle errors from bulk indexing request\n raise\n \n retry_until_ok(self.elastic.indices.refresh, index=\"\")","def run_indexa_update_currency(self):\n records = self.search([('indexa_currency_next_execution_date', '<=', fields.Date.today())])\n if records:\n to_update = self.env['res.company']\n for record in records:\n if record.indexa_currency_interval_unit == 'daily':\n next_update = relativedelta(days=+1)\n elif record.indexa_currency_interval_unit == 'weekly':\n next_update = relativedelta(weeks=+1)\n elif record.indexa_currency_interval_unit == 'monthly':\n next_update = relativedelta(months=+1)\n else:\n record.indexa_currency_next_execution_date = False\n continue\n record.indexa_currency_next_execution_date = datetime.date.today() + next_update\n to_update += record\n to_update.indexa_update_currency_rates()","def update_index(signum):\n cdx = redis_cli.zrange('ipfs:cdxj', 0, -1)\n cdx = ''.join(cdx)\n buff = BytesIO(cdx)\n\n # Add New Index\n res = ipfs_api.add(CustomNameStream(buff, 'index.cdxj'))\n print('Updating Index: ' + str(res))\n\n # Register with IPNS\n res = ipfs_api.name_publish(res['Hash'])\n print res","def _idx_changed(self, idx):\n self.refresh_memory()","def _Dynamic_UpdateIndex(self, index, void, request_id=None):\n self._RemoteSend(index, void, \"UpdateIndex\", request_id)\n return","def increment_hourly_path(\n self, \n event_id, \n unique, \n property_id=None, \n value=1):\n key = (self.user_name, self.bucket_name, \"hourly_path\", self.shard)\n property_id = property_id or _32_BYTE_FILLER\n column_id = \"\".join([\n self.id,\n property_id[0:16],\n pack_hour(),\n property_id[16:32],\n event_id])\n increment_counter(key, column_id=column_id, value=value)\n if unique:\n key = (\n self.user_name, \n self.bucket_name, \n \"hourly_unique_path\", \n self.shard)\n increment_counter(key, column_id=column_id)","def update(self, dt):\n\n self.collecting(dt)","def index_item(self, item):\n index_name = self.settings['ELASTICSEARCH_INDEX']\n index_suffix_format = self.settings.get(\n 'ELASTICSEARCH_INDEX_DATE_FORMAT', None)\n\n if index_suffix_format:\n index_name += \"-\" + datetime.strftime(datetime.now(),\n index_suffix_format)\n\n if isinstance(item, DocumentItem):\n index_action = {\n '_index': index_name,\n '_type': self.settings['ELASTICSEARCH_TYPE'],\n '_id': hashlib.sha1(item['url']).hexdigest(),\n '_source': dict(item)\n }\n elif isinstance(item, LinkItem):\n index_action = {\n \"_op_type\": \"update\",\n \"_index\": index_name,\n \"_type\": self.settings['ELASTICSEARCH_TYPE'],\n \"_id\": hashlib.sha1(item['target']).hexdigest(),\n \"script\": {\n \"inline\": \"\"\"ctx._source.anchors = ctx._source.anchors ?\n (ctx._source.anchors + [anchor]).unique{it}\n : [anchor]\"\"\",\n \"params\" : {\n \"anchor\" : item[\"anchor\"]\n }\n },\n \"upsert\": {\n \"anchors\": [item[\"anchor\"]],\n \"url\": item['target'],\n \"domain\": urlparse(item['target']).hostname,\n \"updated_on\": datetime.now().strftime(\n \"%Y-%m-%dT%H:%M:%S\")\n }\n }\n elif isinstance(item, AuthorityItem):\n index_action = {\n \"_op_type\": \"update\",\n \"_index\": index_name,\n \"_type\": self.settings['ELASTICSEARCH_TYPE'],\n \"_id\": item['url'],\n \"doc\": {\n \"authority\": item['score']\n }\n }\n else:\n return\n\n self.items_buffer.append(index_action)\n\n if len(self.items_buffer) >= \\\n self.settings.get('ELASTICSEARCH_BUFFER_LENGTH', 500):\n self.send_items()\n self.items_buffer = []","def every_day(self, time, function, args=None, kwargs=None, name=None):\n if args is None:\n args = list()\n if kwargs is None:\n kwargs = dict()\n if name is None:\n name = function.__name__+(f'_{len(self.config)+1}' if function.__name__ in self.config else '')\n self.config[name] = {'mode':'every_day', 'time':time, 'function':function, 'args':args, \n 'kwargs':kwargs, 'execute_num':0, 'runner':(function, args, kwargs, name),\n 'time_init':datetime.datetime.now()}\n self.params.tracker_dict[name] = dict()","def enable_index_update_feature(settings):\n settings.FEATURES[INDEX_UPDATES] = True","def update_time(self):\n time_metrics = self._fetch_time_metrics_and_clear()\n self._logger.info('update_time. time_metrics = %s', build_metrics_times_data(time_metrics))","def new_entry_update(cls, summary):\n totaltimes = [x.totaltime for x in summary.entries]\n total = sum(totaltimes, timedelta())\n average = total / len(totaltimes)\n summary.total_time = total\n summary.daily_average = average","def updateDateIndex(map, accident):\n occurreddate = accident['Start_Time']\n accidentdate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\n entry = om.get(map, accidentdate.date())\n if entry is None:\n datentry = newDataEntry2(accident)\n om.put(map, accidentdate.date(), datentry)\n else:\n datentry = me.getValue(entry)\n addDateIndex(datentry, accident)\n\n return map","def step(self):\n self.update(Options['update interval'])","def update(self, record):\n record[self.UPDATED_AT] = strftime(\"%Y-%m-%d %H:%M:%S\", gmtime())\n super(self.__class__, self).update(record)","def report_hour_distribution(self):\n self.histogram_granularities.add(histogram_granularity.HOUR)\n return self","def update_stats(self, idx, key):\n\n stats = self.stats\n if not stats.has_key(idx):\n stats[idx] = {}\n if stats[idx].has_key(key):\n stats[idx][key] += 1\n else:\n stats[idx][key] = 1","def addDayHour(self, dayHour):\n for i, uRange in enumerate(self.__data['updateRange']):\n if (Predictor.inURange(dayHour, uRange)): \n self.addDayHourToURange(dayHour, i)\n return True\n return False","def update(self):\n if self.last_update and (\n self.last_update + timedelta(hours=1)\n > datetime.utcnow().replace(tzinfo=dt_util.UTC)\n ):\n return # Not time to update yet; data is only hourly\n\n for row in self.current_observations():\n if row.get(\"Station\") == self._station_id:\n api_fields = {\n col_heading: (standard_name, dtype)\n for standard_name, (\n _,\n _,\n _,\n col_heading,\n dtype,\n ) in SENSOR_TYPES.items()\n }\n self.data = {\n api_fields.get(col_heading)[0]: api_fields.get(col_heading)[1](\n v.replace(\",\", \".\")\n )\n for col_heading, v in row.items()\n if col_heading in api_fields and v\n }\n break\n else:\n raise ValueError(f\"No weather data for station {self._station_id}\")","def updateDateIndex(map, accident):\n occurreddate = accident['End_Time']\n accidentdate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\n entry = om.get(map, accidentdate.date())\n if entry is None:\n datentry = newDataEntry(accident)\n om.put(map, accidentdate.date(), datentry)\n else:\n datentry = me.getValue(entry)\n addDateIndex(datentry, accident)\n return map","def get_hourly(self):\n pass","def update():","def update():","def build_index(self):\n self.rebuild_index()","def set_dt_index(self, dt_0=None):\r\n self.set_datetime(dt_0)\r\n dt = pd.to_timedelta(self.data['t'], unit='sec') + self.dt_0\r\n self.data.index = dt\r\n self.data.index.name = 'dt'","def update(self) -> None:\n ...","def rebuild_all_indexes():\n response = _get_lambda_client().invoke(\n FunctionName=indexer_function_name,\n InvocationType=\"Event\",\n )","def refresh():\n DB.drop_all()\n DB.create_all()\n samples = pull_pm('Los Angeles', 'pm25')\n for sample in samples:\n measure = Record(datetime = str(sample[0]), value = sample[1])\n DB.session.add(measure)\n DB.session.commit()\n return 'Data refreshed!'","def task_refresh_all_stats_score(request):\n start = time.time()\n cls_name = request.POST.get('cls') or 'Day'\n destroy = int(request.POST.get('destroy', '0'))\n cursor = datastore_query.Cursor(urlsafe=request.POST.get('cursor'))\n task_count = int(request.POST.get('task_count', '0'))\n assert cls_name in ('Day', 'Multi'), cls_name\n cls = (\n models.AccountStatsDay\n if cls_name == 'Day' else models.AccountStatsMulti)\n\n # Task queues are given 10 minutes. Do it in 9 minutes chunks to protect\n # against most timeout conditions.\n timeout = 540\n updated = 0\n skipped = 0\n try:\n futures = []\n chunk_size = 10\n items = []\n more = True\n if destroy:\n options = ndb.QueryOptions(keys_only=True)\n else:\n options = ndb.QueryOptions()\n while more:\n batch, cursor, more = cls.query(default_options=options).fetch_page(\n 20, start_cursor=cursor)\n if destroy:\n futures.extend(ndb.delete_multi_async(batch))\n updated += len(batch)\n else:\n for i in batch:\n score = models.compute_score(i)\n if i.score != score:\n items.append(i)\n if len(items) == chunk_size:\n futures.extend(ndb.put_multi_async(items))\n updated += chunk_size\n items = []\n futures = [f for f in futures if not f.done()]\n else:\n skipped += 1\n if time.time() - start >= timeout:\n break\n if items:\n futures.extend(ndb.put_multi_async(items))\n updated += chunk_size\n ndb.Future.wait_all(futures)\n if not more and cls_name == 'Day':\n # Move to the Multi instances.\n more = True\n cls_name = 'Multi'\n cursor = datastore_query.Cursor()\n if more:\n taskqueue.add(\n url=reverse(task_refresh_all_stats_score),\n params={\n 'cls': cls_name,\n 'cursor': cursor.urlsafe() if cursor else '',\n 'destroy': str(destroy),\n 'task_count': str(task_count+1),\n },\n queue_name='refresh-all-stats-score')\n result = 200\n except (db.Timeout, DeadlineExceededError):\n result = 500\n out = 'Index: %d\\nType = %s\\nStored %d items\\nSkipped %d\\nIn %.1fs\\n' % (\n task_count, cls.__name__, updated, skipped, time.time() - start)\n if result == 200:\n logging.info(out)\n else:\n logging.error(out)\n return HttpTextResponse(out, status=result)","def update(self): \n \n timeout=0\n \n while(timeout<10):\n try:\n data = pnd.read_csv(self.path,index_col=0,sep=',',names=['Values'])\n self.data['Values']=data['Values'].values\n self.data.Values.values[-1] = data.index.values[-1]\n \n# print('Updated from file:',self.data.iloc[-1].values[0])\n break\n except ValueError:\n timeout+=1\n if timeout == 10:\n print('failed to update')","def _scheduled_update(now):\n _LOGGER.debug(\"%s: executing scheduled update\", self.entity_id)\n self.async_schedule_update_ha_state(True)\n self._update_listener = None","def update_view_times(app):\n app.logger.info('Scheduler update_view_times running: %s' % post_view_times_counter)\n d = dict(post_view_times_counter)\n post_view_times_counter.clear()\n for k, v in d.items():\n p = Post.find_one({'_id': k})\n if p:\n try:\n p.viewTimes += v\n p.save()\n except:\n app.logger.exception('Failed when updating the viewTime for album %s' % p._id)","def update( ):\r\n pass","def increase_scan_interval(hass):\n hue_sensor_base.SensorManager.SCAN_INTERVAL = datetime.timedelta(days=365)","def refreshTable(self):\n ds = []\n for id in self.protocol.getRefreshIDs():\n node = Node(id)\n nearest = self.protocol.router.findNeighbors(node, self.alpha)\n spider = NodeSpiderCrawl(self.protocol, node, nearest)\n ds.append(spider.find())\n\n def republishKeys(_):\n ds = []\n # Republish keys older than one hour\n for key, value in self.storage.iteritemsOlderThan(3600):\n ds.append(self.set(key, value))\n return defer.gatherResults(ds)\n\n d = defer.gatherResults(ds)\n d.addCallback(republishKeys)\n d.addErrback(self.onError)\n return d","def _update(self, count=True, forced=False):","def update_timeindex(self, event):\n latest_datetime = self.bars.get_latest_bar_datetime(self.symbol_list[0])\n \n # Update positions\n # ================\n dp = dict((k,v) for k,v in [(s,0) for s in self.symbol_list])\n dp['datetime'] = latest_datetime\n \n for s in self.symbol_list:\n dp[s] = self.current_positions[s]\n \n # Append the current positions\n self.all_positions.append(dp)\n \n # Update holdings\n # ===============\n dh = dict((k,v) for k,v in [(s,0) for s in self.symbol_list])\n dh['datetime'] = latest_datetime\n dh['cash'] = self.current_holdings['cash']\n dh['commission'] = self.current_holdings['commission']\n dh['total'] = self.current_holdings['cash']\n \n for s in self.symbol_list:\n # Approximation to the real value\n market_value = self.current_positions[s] * self.bars.get_latest_bar_value(s, \"adj_close\")\n dh[s] = market_value\n dh['total'] += market_value\n \n # Append the current holdings\n self.all_holdings.append(dh)\n print('timeindex: ', dh)","def queriesInEachHour(self):\n hours = 0\n\n #prints out each element (with number of DB Queries) of array\n while hours < 24:\n print (hours,'to',hours+1, ' : ', self.arrayOfTimes[hours])\n hours += 1","def reschedule_active_metadata_update(key, url):\n instance = key.get()\n if not instance:\n logging.warning('Instance does not exist: %s', key)\n return\n\n if not instance.active_metadata_update:\n logging.warning('Instance active metadata operation unspecified: %s', key)\n return\n\n if instance.active_metadata_update.url != url:\n logging.warning(\n 'Instance has unexpected active metadata operation: %s', key)\n return\n\n metadata_updates = [instance.active_metadata_update]\n metadata_updates.extend(instance.pending_metadata_updates)\n instance.active_metadata_update = compress_metadata_updates(metadata_updates)\n instance.pending_metadata_updates = []\n instance.put()","def update(self, dt):\n self.level.update(self.keys, dt)","def updateIndex(ix, pool_path):\n \n logger.debug('updating search index')\n writer = ix.writer()\n \n exercise_list = [f.name for f in os.scandir(pool_path) if f.is_dir()]\n for ex in exercise_list:\n if ex == '.search_index':\n continue\n task_file = os.path.abspath(os.path.join(pool_path, ex, 'task.tex'))\n if os.path.isfile(task_file):\n logger.info('parsing ' + task_file)\n metaData, task_texcode = parseTaskFile(task_file)\n else:\n logger.warning(ex + ' does not include a task.tex file. skipping entry')\n continue\n \n solution_file = os.path.abspath(os.path.join(pool_path, ex, 'solution.tex'))\n if os.path.isfile(solution_file):\n with open(solution_file, 'r') as f:\n solution_texcode = f.read()\n else:\n logger.warning(ex + ' does not include a solution.tex file')\n solution_texcode = ''\n \n if metaData['date'] == '':\n lastupdate = datetime.datetime(1970, 1, 1, 0, 0, 0, 0)\n else:\n lastupdate = parse_date(metaData['date'])\n\n writer.add_document(\n folder_name=ex,\n task=task_texcode,\n solution=solution_texcode,\n language=metaData['language'],\n maintainer=metaData['author'],\n lastupdate=lastupdate,\n keywords=re.sub(r',\\s+', ',', metaData['keywords'])\n )\n\n writer.commit()","def es_index(data):\n doc_type = data.get('service')\n es.index(index=INDEX, doc_type=doc_type, body=data)","def one_step(self, event):\n self.refresh(self._refresh_rate, True)","def update_H(self, curl_E):","def update(self, T, num_updates=1, in_order=False, seed=None):\n self.schedule_update([(T, num_updates)], in_order, seed)","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass"],"string":"[\n \"def index_later(self):\\n return\",\n \"def update_time(cls, key):\\n key.put()\",\n \"def every_hour(self, time, function, args=None, kwargs=None, name=None):\\n if args is None:\\n args = list()\\n if kwargs is None:\\n kwargs = dict()\\n if name is None:\\n name = function.__name__+(f'_{len(self.config)+1}' if function.__name__ in self.config else '')\\n self.config[name] = {'mode':'every_hour', 'time':time, 'function':function, 'args':args, \\n 'kwargs':kwargs, 'execute_num':0, 'runner':(function, args, kwargs, name),\\n 'time_init':datetime.datetime.now()}\\n self.params.tracker_dict[name] = dict()\",\n \"def update(self):\\n if self._refreshed_at is None or (\\n self._refreshed_at + self._refresh_rate <= datetime.datetime.now()):\\n\\n self.run()\",\n \"def periodicUpdate(self):\\n try:\\n logging.info(f'{self.cn} periodicUpdate = Start')\\n isHaz = JsonSettings.parseJson('settings.json','isHazelcast')\\n if self.db.isDb():\\n self.insertStats()\\n self.insertPorts()\\n if isHaz:\\n self.insertHaz() \\n else:\\n self.db.initDb()\\n self.insertSys()\\n self.insertStats()\\n self.insertPorts()\\n if isHaz:\\n self.insertHaz() \\n except Exception as e:\\n logging.critical(f'{self.cn} Exception: {e}')\\n logging.critical(f'{self.cn} StackTrace: \\\\n', exc_info=1)\\n finally:\\n logging.info(f'{self.cn} periodicUpdate = End')\",\n \"def do_update(url,indexHeaders,update_file):\\n updateUrl=url.replace(\\\"buckets\\\",\\\"riak\\\")\\n indexHeaders['content-type'] = 'application/json'\\n r=requests.post(url, data=json.dumps(update_file), headers=indexHeaders)\",\n \"def step010():\\n logger.logMessage('Begin: Getting candidate documents from elasticsearch')\\n\\n def limitHour(d):\\n thish = d.start_time.tz_localize(tz='UTC')\\n nexth = thish + dt.timedelta(hours=1)\\n return { 'range': { 'time': {'gte':thish, 'lt':nexth } } }\\n \\n conn = sql.create_engine(pgurl)\\n client = es.Elasticsearch(hostlist)\\n dupesDF = pd.read_sql_table('weather_dupes',conn).set_index('time')\\n hours =dupesDF.to_period('H').reset_index()['time'].unique()\\n ranges = [ limitHour(h) for h in hours ]\\n query = { \\n '_source': [ 'tsa','time' ],\\n 'query': { \\n 'bool': { 'should': ranges } \\n } \\n }\\n #logger.logMessage(level='DEBUG',message='Query body: {0}'.format(query))\\n hits = eshelp.scan(client=client,index=indexName,doc_type='doc',query=query)\\n numRecs = 0\\n with open(candidatesFile,'w') as f:\\n for h in hits:\\n src = h['_source']\\n tsa = int(src['tsa'])\\n time = src['time']\\n docid = h['_id']\\n idx = h['_index']\\n f.write(f'{tsa:014d};{time:25s};{docid:32s};{idx:32s}\\\\n') \\n numRecs += 1\\n if numRecs % 1000 == 0:\\n logger.logMessage(level='DEBUG',message=\\\"{0:9d} records written\\\".format(numRecs))\\n logger.logMessage(message=\\\"{0:9d} total records written\\\".format(numRecs))\\n logger.logMessage('End: Getting candidate documents from elasticsearch')\",\n \"def cron_refresh_spacetrack_cache():\\n s = SpaceTrackApi()\\n updated_tles_str = s.get_all_tles()\\n storage.save_tle_cache(updated_tles_str)\\n last_updated[0] = int(time.time())\\n metadata = {\\n 'last_updated': last_updated[0],\\n }\\n storage.save_metadata(metadata)\",\n \"def reindex(self):\",\n \"def reindex(self):\",\n \"def update(self, time):\\n raise NotImplementedError\",\n \"def update(self, time):\\n raise NotImplementedError\",\n \"def refresh(self):\\n\\n self._refreshed_on = time.time() * 1000\",\n \"def _update_on_refresh():\\n cities = City.query.all()\\n\\n #Iterates over all cities in the database and updates their value\\n for city in cities:\\n metric_resp, imperial_resp = _get_open_weather_requests(city.name)\\n\\n metric_json = metric_resp.json()\\n imperial_json = imperial_resp.json()\\n\\n city.temp_celsius = int(metric_json[MAIN][TEMPERATURE])\\n city.temp_fahrenheit = int(imperial_json[MAIN][TEMPERATURE])\\n db.session.commit()\",\n \"def store_elasticsearch(self, item):\\n self.datastore.create(\\n index=\\\"dminer-alphabay-{date}\\\".format(\\n date=datetime.datetime.strptime(item[\\\"timestamp\\\"], \\\"%Y:%m:%d %H:%M:%S\\\").date().strftime(\\\"%Y-%m-%d\\\")\\n ),\\n doc_type= \\\"alphabay_listing\\\",\\n body=item\\n )\",\n \"def update(self, dt):\\n pass\",\n \"async def afterHoursAutoPurge(self, ctx: Context):\",\n \"def store_elasticsearch(self, item):\\n self.datastore.create(\\n index=\\\"dminer-dreammarket-{date}\\\".format(\\n date=datetime.datetime.strptime(item[\\\"timestamp\\\"], \\\"%Y:%m:%d %H:%M:%S\\\").date().strftime(\\\"%Y-%m-%d\\\")\\n ),\\n doc_type= \\\"dreammarket_listing\\\",\\n body=item\\n )\",\n \"async def _timein_refresh(self):\\n\\t\\t\\n\\t\\tawait self.refresh_cache()\",\n \"def _update(self, host):\\n pass\",\n \"def update_news_intime(minutes):\\n while True:\\n db_update.update()\\n time.sleep(60 * minutes)\",\n \"def __setitem__(self, url, reslut):\\n record = {'result': reslut, 'timestamp': datetime.datetime.utcnow()}\\n try:\\n self.es.index(index=self.index, doc_type=self.doc_type, id=url, body=record)\\n except Exception as e:\\n print e\\n print url, 'failed'\",\n \"def refresh():\\r\\n DB.drop_all()\\r\\n DB.create_all()\\r\\n # TODO Get data from OpenAQ, make Record objects with it, and add to db\\r\\n for i in time_x_values():\\r\\n DB.session.add(Record(datetime=i[0], value=i[1]))\\r\\n DB.session.commit()\\r\\n return 'Data refreshed!'\",\n \"def refresh_index(self):\\n synchronize()\\n # TODO: add logger call here\\n self._compute_embeddings()\",\n \"def refresh():\\r\\n db.drop_all()\\r\\n db.create_all()\\r\\n for time_value in get_datetime_values('Los Angeles', 'pm25'):\\r\\n record = Record(datetime=str(time_value[0]), value=time_value[1])\\r\\n db.session.add(record)\\r\\n db.session.commit()\\r\\n return render_template('refresh.html')\",\n \"def step070() -> None:\\n logger.logMessage('Begin: elasticsearch bulk update')\\n client = es.Elasticsearch(hostlist)\\n\\n def generate():\\n with open(renumFile,'r') as f:\\n line = f.readline().rstrip()\\n while line != '':\\n fields = line.split(';')\\n oper = { '_index': fields[3], \\n '_op_type': 'update',\\n '_id': fields[2].rstrip(),\\n '_type': 'doc',\\n '_source:': {'doc': {'tsa': fields[0]}}}\\n \\n yield oper\\n line = f.readline().rstrip()\\n result = eshelp.bulk(client,generate())\\n logger.logMessage('Bulk result: {0}'.format(result))\\n logger.logMessage('End : elasticsearch bulk update')\",\n \"def update(self, dt):\",\n \"def update(self, dt):\",\n \"def reindex(self):\\n raise NotImplementedError()\",\n \"def addDayHourToURange(self, dayHour, index):\\n ur_hist_len = len(self.__data['updateRange'][index]['updateHistory']) - Predictor.rangeHistorySize\\n if (ur_hist_len > 0):\\n for i in range(ur_hist_len):\\n self.__data['updateRange'][index]['updateHistory'].pop(0)\\n self.__data['updateRange'][index]['updateHistory'].append(dayHour)\",\n \"def every_day():\\n logger.info('[ EVERY_DAY ] [ %s ]' % str(datetime.now().time()))\",\n \"def increment_hourly_total(self, unique, property_id=None, value=1):\\n key = (self.user_name, self.bucket_name, \\\"hourly_event\\\", self.shard)\\n property_id = property_id or _32_BYTE_FILLER\\n column_id = \\\"\\\".join([\\n self.id,\\n property_id[0:16],\\n pack_hour(),\\n property_id[16:32]])\\n increment_counter(key, column_id=column_id, value=value)\\n if unique:\\n key = (\\n self.user_name, \\n self.bucket_name, \\n \\\"hourly_unique_event\\\", \\n self.shard)\\n increment_counter(key, column_id=column_id)\",\n \"def update_time(self):\\n pass # Do nothing\",\n \"def finish_hour(self):\\n\\t\\tassert len(self.values) >= 4, 'A fully formed update date is needed.'\\n\\t\\tself.values = self.values[:4]\",\n \"def update_time(self):\\n try:\\n self._thread_pool_executor.submit(self._update_time_fn)\\n except:\\n self._logger.exception('Exception caught submitting time metrics update task.')\",\n \"def do_upt(self, arg):\\n self.do_timesheet('update today')\",\n \"def update(self, dt):\\n\\t\\tpass\",\n \"def update_index(self, ref_gen):\\n testing = True\\n logging.warning('Updating index')\\n es_insert.index(es, ref_gen, self.index_name, testing, action=\\\"update\\\")\\n logging.warning('Finished updating')\",\n \"def app_index_job(cls):\\n import time\\n s = time.time()\\n print('init--redis')\\n news = json.dumps(DB.index_news(), ensure_ascii=False)\\n mvs = json.dumps(DB.index_mvs('mv'), ensure_ascii=False)\\n dsjs = json.dumps(DB.index_mvs('dsj'), ensure_ascii=False)\\n dms = json.dumps(DB.index_mvs('dm'), ensure_ascii=False)\\n zys = json.dumps(DB.index_mvs('zy'), ensure_ascii=False)\\n mv_top = json.dumps(DB.index_tops('mv')[0:6], ensure_ascii=False)\\n dsj_top = json.dumps(DB.index_tops('dsj')[0:6], ensure_ascii=False)\\n zy_top = json.dumps(DB.index_tops('zy')[0:6], ensure_ascii=False)\\n dm_top = json.dumps(DB.index_tops('dm')[0:6], ensure_ascii=False)\\n # 今日更新和总视频数量\\n today, total = DB.today_total(None)\\n # 淘宝广告\\n ads = json.dumps(TBApi.get_tb_goods(), ensure_ascii=False)\\n cls.r.set('news', news)\\n cls.r.set('mvs', mvs)\\n cls.r.set('dsjs', dsjs)\\n cls.r.set('dms', dms)\\n cls.r.set('zys', zys)\\n cls.r.set('mv_top', mv_top)\\n cls.r.set('dsj_top', dsj_top)\\n cls.r.set('zy_top', zy_top)\\n cls.r.set('dm_top', dm_top)\\n cls.r.set('today', today)\\n cls.r.set('total', total)\\n cls.r.set('ads', ads)\\n del news, mvs, dsjs, dms, zys, mv_top, dsj_top, zy_top, dm_top, ads\\n print(f'{time.time() - s}')\",\n \"async def send_to_elastic(self, data, index='wallarm'):\\n self.es.index(body=data, index=index)\\n return print('Sent successfully')\",\n \"def refresh():\\n DB.drop_all()\\n DB.create_all()\\n df_meas = open_api.measurements(city='Los Angeles', parameter='pm25', df=True)\\n df_meas['date.utc'] = df_meas['date.utc'].astype(str)\\n create_DB_records(df_meas)\\n DB.session.commit()\\n message = 'Data refreshed on: ' + str(datetime.datetime.now())\\n over9s = Record.query.filter(Record.value > 9)\\n recs = Record.query.filter(Record.id < 20)\\n over5s = Record.query.filter(Record.value > 5)\\n return render_template('base.html', message=message, over9s=over9s, over5s=over5s, recs=recs)\",\n \"def solr_reindex(where=None):\\n config = get_config(where)\\n with settings(host_string=config['host_string']), cd(config['installation_dir']):\\n cmd = 'bin/django update_index dasa --batch-size=5000 --remove --verbosity=2'\\n run(cmd)\",\n \"def reset_file_index_cache() -> None:\\n fileindex_cache_five_minutes.invalidate()\",\n \"def hour(self) -> Index:\\n warnings.warn(\\n \\\"`hour` will return int32 index instead of int 64 index in 4.0.0.\\\",\\n FutureWarning,\\n )\\n return Index(self.to_series().dt.hour)\",\n \"def updateDateIndex(map, accidente):\\n occurreddate = accidente['Start_Time']\\n accidentedate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\\n entry = om.get(map, accidentedate.date())\\n if entry is None:\\n datentry = newDataEntry(accidente)\\n om.put(map, accidentedate.date(), datentry)\\n else:\\n datentry = me.getValue(entry)\\n addDateIndex(datentry, accidente)\\n return map\",\n \"def update(self, es, **kwargs):\\n pass\",\n \"def update(self, wiki):\\n self.initialize_index()\\n last_rev = self.get_last_revision()\\n if last_rev == -1:\\n changed = self.storage.all_pages()\\n else:\\n changed = self.storage.changed_since(last_rev)\\n changed = list(changed)\\n # six.print_('changed', changed, last_rev)\\n if changed:\\n self.reindex(wiki, changed)\\n # if self.INDEX_THREAD and self.INDEX_THREAD.is_alive:\\n # print 'alreading reindexing'\\n # else:\\n # self.INDEX_THREAD = threading.Thread(target=self.reindex, args=(wiki, changed))\\n # self.INDEX_THREAD.daemon = True\\n # self.INDEX_THREAD.start()\",\n \"def refresh_index_patterns(cluster, patterns):\\n _refresh_path = '/es_admin/.kibana/index-pattern/'\\n _headers = {'kbn-xsrf': 'anything'}\\n kbn_config = cluster['kibana']\\n kbn_auth = cluster['kibana']['auth']\\n kbn_url = f'{kbn_config[\\\"protocol\\\"]}://{kbn_config[\\\"url\\\"]}:{kbn_config[\\\"port\\\"]}'\\n\\n for pattern, timefield in patterns.items():\\n quoted_pattern = quote_plus(pattern, safe='*')\\n url = f'{kbn_url}{_refresh_path}{quoted_pattern}/'\\n\\n # if time series pattern, add timefield\\n payload = {'title': pattern, 'notExpandable': True}\\n if timefield:\\n payload['timeFieldName'] = timefield\\n\\n rv = requests.post(url, json=payload, headers=_headers, auth=kbn_auth)\\n log.debug('sent_refresh', pattern=pattern, payload=payload,\\n url=url, response={**rv.__dict__})\",\n \"def make_hourly(self,rate,name):\\n id = self.find_employee_id(name)\\n if id in self.clsf:\\n self.emp_dict[id][5] = \\\"1\\\"\\n print(\\\"{}{}\\\".format(name,\\\" was successfully changed to be an hourly employee\\\"))\\n self.emp_dict[id][8] = rate\\n self.classification()\\n return self.emp_dict\\n else:\\n print(\\\"Error- employee not found\\\")\\n self.employee_data()\",\n \"def update_timeindex(self, day):\\n self.current_positions['datetime'] = self.bars.date\\n self.all_positions.append(self.current_positions.copy())\\n\\n self.current_prices['datetime'] = self.bars.date\\n self.all_prices.append(self.current_prices.copy())\\n\\n self.current_holdings['datetime'] = self.bars.date\\n self.all += (self.buy + self.sell)\\n self.current_holdings['buy_times'] = self.buy\\n self.current_holdings['sell_times'] = self.sell\\n self.current_holdings['total_times'] = self.all\\n\\n hold = 0\\n self.current_holdings['total'] = self.current_holdings['cash']\\n for s in self.symbol_list:\\n # Approximates the real value\\n if self.current_positions[s] > 0:\\n hold += 1\\n market_value = self.current_positions[s] * \\\\\\n self.bars.get_latest_bar_value(s, 'True_close')\\n self.current_holdings['total'] += market_value\\n\\n self.current_holdings['hold'] = hold\\n # Append the current holdings\\n self.all_holdings.append(self.current_holdings.copy())\\n\\n print 'Day %s[%s]: buy=%s, sell=%s, hold=%s.' % \\\\\\n (day, self.bars.date, self.buy, self.sell, hold)\",\n \"def _update_index(self):\\n start_time = datetime.datetime.now()\\n sys.stdout.write(\\\"Updating index. Depending on the size of your music \\\"\\n \\\"collection this may take some time, so please be patient. \\\"\\n \\\"(Update started at %s)\\\\n\\\" % start_time)\\n new_index_file = \\\"%s/music_index_%s.txt\\\" % (self.index_dir,\\n start_time.strftime(\\\"%Y%m%d_%H%M%S\\\"))\\n files = (os.path.join(tup[0], f) for d in self.music_dirs \\n for tup in os.walk(d) \\n for f in tup[2] )\\n \\n with open(new_index_file, \\\"w\\\") as fh:\\n for filename in files:\\n fh.write(\\\"%s\\\\n\\\" % filename)\\n \\n end_time = datetime.datetime.now()\\n sys.stdout.write(\\\"Music index updated (created index file '%s')\\\\n\\\" \\n \\\"Update duration:%s\\\\n\\\" % \\n (new_index_file, end_time - start_time))\",\n \"def commit(self):\\n with self.lock:\\n try:\\n action_buffer = self.BulkBuffer.get_buffer()\\n if action_buffer:\\n successes, errors = bulk(self.elastic, action_buffer)\\n except Exception as e:\\n # Handle errors from bulk indexing request\\n raise\\n \\n retry_until_ok(self.elastic.indices.refresh, index=\\\"\\\")\",\n \"def run_indexa_update_currency(self):\\n records = self.search([('indexa_currency_next_execution_date', '<=', fields.Date.today())])\\n if records:\\n to_update = self.env['res.company']\\n for record in records:\\n if record.indexa_currency_interval_unit == 'daily':\\n next_update = relativedelta(days=+1)\\n elif record.indexa_currency_interval_unit == 'weekly':\\n next_update = relativedelta(weeks=+1)\\n elif record.indexa_currency_interval_unit == 'monthly':\\n next_update = relativedelta(months=+1)\\n else:\\n record.indexa_currency_next_execution_date = False\\n continue\\n record.indexa_currency_next_execution_date = datetime.date.today() + next_update\\n to_update += record\\n to_update.indexa_update_currency_rates()\",\n \"def update_index(signum):\\n cdx = redis_cli.zrange('ipfs:cdxj', 0, -1)\\n cdx = ''.join(cdx)\\n buff = BytesIO(cdx)\\n\\n # Add New Index\\n res = ipfs_api.add(CustomNameStream(buff, 'index.cdxj'))\\n print('Updating Index: ' + str(res))\\n\\n # Register with IPNS\\n res = ipfs_api.name_publish(res['Hash'])\\n print res\",\n \"def _idx_changed(self, idx):\\n self.refresh_memory()\",\n \"def _Dynamic_UpdateIndex(self, index, void, request_id=None):\\n self._RemoteSend(index, void, \\\"UpdateIndex\\\", request_id)\\n return\",\n \"def increment_hourly_path(\\n self, \\n event_id, \\n unique, \\n property_id=None, \\n value=1):\\n key = (self.user_name, self.bucket_name, \\\"hourly_path\\\", self.shard)\\n property_id = property_id or _32_BYTE_FILLER\\n column_id = \\\"\\\".join([\\n self.id,\\n property_id[0:16],\\n pack_hour(),\\n property_id[16:32],\\n event_id])\\n increment_counter(key, column_id=column_id, value=value)\\n if unique:\\n key = (\\n self.user_name, \\n self.bucket_name, \\n \\\"hourly_unique_path\\\", \\n self.shard)\\n increment_counter(key, column_id=column_id)\",\n \"def update(self, dt):\\n\\n self.collecting(dt)\",\n \"def index_item(self, item):\\n index_name = self.settings['ELASTICSEARCH_INDEX']\\n index_suffix_format = self.settings.get(\\n 'ELASTICSEARCH_INDEX_DATE_FORMAT', None)\\n\\n if index_suffix_format:\\n index_name += \\\"-\\\" + datetime.strftime(datetime.now(),\\n index_suffix_format)\\n\\n if isinstance(item, DocumentItem):\\n index_action = {\\n '_index': index_name,\\n '_type': self.settings['ELASTICSEARCH_TYPE'],\\n '_id': hashlib.sha1(item['url']).hexdigest(),\\n '_source': dict(item)\\n }\\n elif isinstance(item, LinkItem):\\n index_action = {\\n \\\"_op_type\\\": \\\"update\\\",\\n \\\"_index\\\": index_name,\\n \\\"_type\\\": self.settings['ELASTICSEARCH_TYPE'],\\n \\\"_id\\\": hashlib.sha1(item['target']).hexdigest(),\\n \\\"script\\\": {\\n \\\"inline\\\": \\\"\\\"\\\"ctx._source.anchors = ctx._source.anchors ?\\n (ctx._source.anchors + [anchor]).unique{it}\\n : [anchor]\\\"\\\"\\\",\\n \\\"params\\\" : {\\n \\\"anchor\\\" : item[\\\"anchor\\\"]\\n }\\n },\\n \\\"upsert\\\": {\\n \\\"anchors\\\": [item[\\\"anchor\\\"]],\\n \\\"url\\\": item['target'],\\n \\\"domain\\\": urlparse(item['target']).hostname,\\n \\\"updated_on\\\": datetime.now().strftime(\\n \\\"%Y-%m-%dT%H:%M:%S\\\")\\n }\\n }\\n elif isinstance(item, AuthorityItem):\\n index_action = {\\n \\\"_op_type\\\": \\\"update\\\",\\n \\\"_index\\\": index_name,\\n \\\"_type\\\": self.settings['ELASTICSEARCH_TYPE'],\\n \\\"_id\\\": item['url'],\\n \\\"doc\\\": {\\n \\\"authority\\\": item['score']\\n }\\n }\\n else:\\n return\\n\\n self.items_buffer.append(index_action)\\n\\n if len(self.items_buffer) >= \\\\\\n self.settings.get('ELASTICSEARCH_BUFFER_LENGTH', 500):\\n self.send_items()\\n self.items_buffer = []\",\n \"def every_day(self, time, function, args=None, kwargs=None, name=None):\\n if args is None:\\n args = list()\\n if kwargs is None:\\n kwargs = dict()\\n if name is None:\\n name = function.__name__+(f'_{len(self.config)+1}' if function.__name__ in self.config else '')\\n self.config[name] = {'mode':'every_day', 'time':time, 'function':function, 'args':args, \\n 'kwargs':kwargs, 'execute_num':0, 'runner':(function, args, kwargs, name),\\n 'time_init':datetime.datetime.now()}\\n self.params.tracker_dict[name] = dict()\",\n \"def enable_index_update_feature(settings):\\n settings.FEATURES[INDEX_UPDATES] = True\",\n \"def update_time(self):\\n time_metrics = self._fetch_time_metrics_and_clear()\\n self._logger.info('update_time. time_metrics = %s', build_metrics_times_data(time_metrics))\",\n \"def new_entry_update(cls, summary):\\n totaltimes = [x.totaltime for x in summary.entries]\\n total = sum(totaltimes, timedelta())\\n average = total / len(totaltimes)\\n summary.total_time = total\\n summary.daily_average = average\",\n \"def updateDateIndex(map, accident):\\n occurreddate = accident['Start_Time']\\n accidentdate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\\n entry = om.get(map, accidentdate.date())\\n if entry is None:\\n datentry = newDataEntry2(accident)\\n om.put(map, accidentdate.date(), datentry)\\n else:\\n datentry = me.getValue(entry)\\n addDateIndex(datentry, accident)\\n\\n return map\",\n \"def step(self):\\n self.update(Options['update interval'])\",\n \"def update(self, record):\\n record[self.UPDATED_AT] = strftime(\\\"%Y-%m-%d %H:%M:%S\\\", gmtime())\\n super(self.__class__, self).update(record)\",\n \"def report_hour_distribution(self):\\n self.histogram_granularities.add(histogram_granularity.HOUR)\\n return self\",\n \"def update_stats(self, idx, key):\\n\\n stats = self.stats\\n if not stats.has_key(idx):\\n stats[idx] = {}\\n if stats[idx].has_key(key):\\n stats[idx][key] += 1\\n else:\\n stats[idx][key] = 1\",\n \"def addDayHour(self, dayHour):\\n for i, uRange in enumerate(self.__data['updateRange']):\\n if (Predictor.inURange(dayHour, uRange)): \\n self.addDayHourToURange(dayHour, i)\\n return True\\n return False\",\n \"def update(self):\\n if self.last_update and (\\n self.last_update + timedelta(hours=1)\\n > datetime.utcnow().replace(tzinfo=dt_util.UTC)\\n ):\\n return # Not time to update yet; data is only hourly\\n\\n for row in self.current_observations():\\n if row.get(\\\"Station\\\") == self._station_id:\\n api_fields = {\\n col_heading: (standard_name, dtype)\\n for standard_name, (\\n _,\\n _,\\n _,\\n col_heading,\\n dtype,\\n ) in SENSOR_TYPES.items()\\n }\\n self.data = {\\n api_fields.get(col_heading)[0]: api_fields.get(col_heading)[1](\\n v.replace(\\\",\\\", \\\".\\\")\\n )\\n for col_heading, v in row.items()\\n if col_heading in api_fields and v\\n }\\n break\\n else:\\n raise ValueError(f\\\"No weather data for station {self._station_id}\\\")\",\n \"def updateDateIndex(map, accident):\\n occurreddate = accident['End_Time']\\n accidentdate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\\n entry = om.get(map, accidentdate.date())\\n if entry is None:\\n datentry = newDataEntry(accident)\\n om.put(map, accidentdate.date(), datentry)\\n else:\\n datentry = me.getValue(entry)\\n addDateIndex(datentry, accident)\\n return map\",\n \"def get_hourly(self):\\n pass\",\n \"def update():\",\n \"def update():\",\n \"def build_index(self):\\n self.rebuild_index()\",\n \"def set_dt_index(self, dt_0=None):\\r\\n self.set_datetime(dt_0)\\r\\n dt = pd.to_timedelta(self.data['t'], unit='sec') + self.dt_0\\r\\n self.data.index = dt\\r\\n self.data.index.name = 'dt'\",\n \"def update(self) -> None:\\n ...\",\n \"def rebuild_all_indexes():\\n response = _get_lambda_client().invoke(\\n FunctionName=indexer_function_name,\\n InvocationType=\\\"Event\\\",\\n )\",\n \"def refresh():\\n DB.drop_all()\\n DB.create_all()\\n samples = pull_pm('Los Angeles', 'pm25')\\n for sample in samples:\\n measure = Record(datetime = str(sample[0]), value = sample[1])\\n DB.session.add(measure)\\n DB.session.commit()\\n return 'Data refreshed!'\",\n \"def task_refresh_all_stats_score(request):\\n start = time.time()\\n cls_name = request.POST.get('cls') or 'Day'\\n destroy = int(request.POST.get('destroy', '0'))\\n cursor = datastore_query.Cursor(urlsafe=request.POST.get('cursor'))\\n task_count = int(request.POST.get('task_count', '0'))\\n assert cls_name in ('Day', 'Multi'), cls_name\\n cls = (\\n models.AccountStatsDay\\n if cls_name == 'Day' else models.AccountStatsMulti)\\n\\n # Task queues are given 10 minutes. Do it in 9 minutes chunks to protect\\n # against most timeout conditions.\\n timeout = 540\\n updated = 0\\n skipped = 0\\n try:\\n futures = []\\n chunk_size = 10\\n items = []\\n more = True\\n if destroy:\\n options = ndb.QueryOptions(keys_only=True)\\n else:\\n options = ndb.QueryOptions()\\n while more:\\n batch, cursor, more = cls.query(default_options=options).fetch_page(\\n 20, start_cursor=cursor)\\n if destroy:\\n futures.extend(ndb.delete_multi_async(batch))\\n updated += len(batch)\\n else:\\n for i in batch:\\n score = models.compute_score(i)\\n if i.score != score:\\n items.append(i)\\n if len(items) == chunk_size:\\n futures.extend(ndb.put_multi_async(items))\\n updated += chunk_size\\n items = []\\n futures = [f for f in futures if not f.done()]\\n else:\\n skipped += 1\\n if time.time() - start >= timeout:\\n break\\n if items:\\n futures.extend(ndb.put_multi_async(items))\\n updated += chunk_size\\n ndb.Future.wait_all(futures)\\n if not more and cls_name == 'Day':\\n # Move to the Multi instances.\\n more = True\\n cls_name = 'Multi'\\n cursor = datastore_query.Cursor()\\n if more:\\n taskqueue.add(\\n url=reverse(task_refresh_all_stats_score),\\n params={\\n 'cls': cls_name,\\n 'cursor': cursor.urlsafe() if cursor else '',\\n 'destroy': str(destroy),\\n 'task_count': str(task_count+1),\\n },\\n queue_name='refresh-all-stats-score')\\n result = 200\\n except (db.Timeout, DeadlineExceededError):\\n result = 500\\n out = 'Index: %d\\\\nType = %s\\\\nStored %d items\\\\nSkipped %d\\\\nIn %.1fs\\\\n' % (\\n task_count, cls.__name__, updated, skipped, time.time() - start)\\n if result == 200:\\n logging.info(out)\\n else:\\n logging.error(out)\\n return HttpTextResponse(out, status=result)\",\n \"def update(self): \\n \\n timeout=0\\n \\n while(timeout<10):\\n try:\\n data = pnd.read_csv(self.path,index_col=0,sep=',',names=['Values'])\\n self.data['Values']=data['Values'].values\\n self.data.Values.values[-1] = data.index.values[-1]\\n \\n# print('Updated from file:',self.data.iloc[-1].values[0])\\n break\\n except ValueError:\\n timeout+=1\\n if timeout == 10:\\n print('failed to update')\",\n \"def _scheduled_update(now):\\n _LOGGER.debug(\\\"%s: executing scheduled update\\\", self.entity_id)\\n self.async_schedule_update_ha_state(True)\\n self._update_listener = None\",\n \"def update_view_times(app):\\n app.logger.info('Scheduler update_view_times running: %s' % post_view_times_counter)\\n d = dict(post_view_times_counter)\\n post_view_times_counter.clear()\\n for k, v in d.items():\\n p = Post.find_one({'_id': k})\\n if p:\\n try:\\n p.viewTimes += v\\n p.save()\\n except:\\n app.logger.exception('Failed when updating the viewTime for album %s' % p._id)\",\n \"def update( ):\\r\\n pass\",\n \"def increase_scan_interval(hass):\\n hue_sensor_base.SensorManager.SCAN_INTERVAL = datetime.timedelta(days=365)\",\n \"def refreshTable(self):\\n ds = []\\n for id in self.protocol.getRefreshIDs():\\n node = Node(id)\\n nearest = self.protocol.router.findNeighbors(node, self.alpha)\\n spider = NodeSpiderCrawl(self.protocol, node, nearest)\\n ds.append(spider.find())\\n\\n def republishKeys(_):\\n ds = []\\n # Republish keys older than one hour\\n for key, value in self.storage.iteritemsOlderThan(3600):\\n ds.append(self.set(key, value))\\n return defer.gatherResults(ds)\\n\\n d = defer.gatherResults(ds)\\n d.addCallback(republishKeys)\\n d.addErrback(self.onError)\\n return d\",\n \"def _update(self, count=True, forced=False):\",\n \"def update_timeindex(self, event):\\n latest_datetime = self.bars.get_latest_bar_datetime(self.symbol_list[0])\\n \\n # Update positions\\n # ================\\n dp = dict((k,v) for k,v in [(s,0) for s in self.symbol_list])\\n dp['datetime'] = latest_datetime\\n \\n for s in self.symbol_list:\\n dp[s] = self.current_positions[s]\\n \\n # Append the current positions\\n self.all_positions.append(dp)\\n \\n # Update holdings\\n # ===============\\n dh = dict((k,v) for k,v in [(s,0) for s in self.symbol_list])\\n dh['datetime'] = latest_datetime\\n dh['cash'] = self.current_holdings['cash']\\n dh['commission'] = self.current_holdings['commission']\\n dh['total'] = self.current_holdings['cash']\\n \\n for s in self.symbol_list:\\n # Approximation to the real value\\n market_value = self.current_positions[s] * self.bars.get_latest_bar_value(s, \\\"adj_close\\\")\\n dh[s] = market_value\\n dh['total'] += market_value\\n \\n # Append the current holdings\\n self.all_holdings.append(dh)\\n print('timeindex: ', dh)\",\n \"def queriesInEachHour(self):\\n hours = 0\\n\\n #prints out each element (with number of DB Queries) of array\\n while hours < 24:\\n print (hours,'to',hours+1, ' : ', self.arrayOfTimes[hours])\\n hours += 1\",\n \"def reschedule_active_metadata_update(key, url):\\n instance = key.get()\\n if not instance:\\n logging.warning('Instance does not exist: %s', key)\\n return\\n\\n if not instance.active_metadata_update:\\n logging.warning('Instance active metadata operation unspecified: %s', key)\\n return\\n\\n if instance.active_metadata_update.url != url:\\n logging.warning(\\n 'Instance has unexpected active metadata operation: %s', key)\\n return\\n\\n metadata_updates = [instance.active_metadata_update]\\n metadata_updates.extend(instance.pending_metadata_updates)\\n instance.active_metadata_update = compress_metadata_updates(metadata_updates)\\n instance.pending_metadata_updates = []\\n instance.put()\",\n \"def update(self, dt):\\n self.level.update(self.keys, dt)\",\n \"def updateIndex(ix, pool_path):\\n \\n logger.debug('updating search index')\\n writer = ix.writer()\\n \\n exercise_list = [f.name for f in os.scandir(pool_path) if f.is_dir()]\\n for ex in exercise_list:\\n if ex == '.search_index':\\n continue\\n task_file = os.path.abspath(os.path.join(pool_path, ex, 'task.tex'))\\n if os.path.isfile(task_file):\\n logger.info('parsing ' + task_file)\\n metaData, task_texcode = parseTaskFile(task_file)\\n else:\\n logger.warning(ex + ' does not include a task.tex file. skipping entry')\\n continue\\n \\n solution_file = os.path.abspath(os.path.join(pool_path, ex, 'solution.tex'))\\n if os.path.isfile(solution_file):\\n with open(solution_file, 'r') as f:\\n solution_texcode = f.read()\\n else:\\n logger.warning(ex + ' does not include a solution.tex file')\\n solution_texcode = ''\\n \\n if metaData['date'] == '':\\n lastupdate = datetime.datetime(1970, 1, 1, 0, 0, 0, 0)\\n else:\\n lastupdate = parse_date(metaData['date'])\\n\\n writer.add_document(\\n folder_name=ex,\\n task=task_texcode,\\n solution=solution_texcode,\\n language=metaData['language'],\\n maintainer=metaData['author'],\\n lastupdate=lastupdate,\\n keywords=re.sub(r',\\\\s+', ',', metaData['keywords'])\\n )\\n\\n writer.commit()\",\n \"def es_index(data):\\n doc_type = data.get('service')\\n es.index(index=INDEX, doc_type=doc_type, body=data)\",\n \"def one_step(self, event):\\n self.refresh(self._refresh_rate, True)\",\n \"def update_H(self, curl_E):\",\n \"def update(self, T, num_updates=1, in_order=False, seed=None):\\n self.schedule_update([(T, num_updates)], in_order, seed)\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59411937","0.57995015","0.56473935","0.5602451","0.558092","0.551876","0.5453459","0.5422525","0.54206413","0.54206413","0.5394929","0.5394929","0.53662395","0.53635","0.53479695","0.53402996","0.532217","0.53142494","0.5309737","0.5285711","0.52673167","0.525103","0.5217854","0.5209786","0.5201052","0.5197442","0.5189252","0.5189252","0.5187253","0.51755565","0.5174961","0.5164124","0.5163411","0.5148543","0.514248","0.5121596","0.5120403","0.51189524","0.50978506","0.50734687","0.5058177","0.5056586","0.504522","0.50417787","0.50363314","0.50325537","0.501305","0.49975574","0.4973511","0.4957602","0.49574998","0.49559468","0.49520752","0.49465966","0.49267802","0.4926275","0.4920178","0.49162498","0.4907312","0.49041682","0.4895208","0.48940438","0.48928663","0.4888886","0.4883144","0.48739564","0.48724464","0.48682138","0.4867852","0.4857211","0.48531112","0.48528945","0.4852077","0.4852077","0.48514396","0.48505488","0.4838406","0.48327112","0.4830933","0.4823441","0.48096028","0.4809106","0.48055875","0.48042142","0.48034","0.4801502","0.4793459","0.47934362","0.4787651","0.47824427","0.47774798","0.47765908","0.47748932","0.47730464","0.47696146","0.47676218","0.47621673","0.47621673","0.47621673","0.47621673"],"string":"[\n \"0.59411937\",\n \"0.57995015\",\n \"0.56473935\",\n \"0.5602451\",\n \"0.558092\",\n \"0.551876\",\n \"0.5453459\",\n \"0.5422525\",\n \"0.54206413\",\n \"0.54206413\",\n \"0.5394929\",\n \"0.5394929\",\n \"0.53662395\",\n \"0.53635\",\n \"0.53479695\",\n \"0.53402996\",\n \"0.532217\",\n \"0.53142494\",\n \"0.5309737\",\n \"0.5285711\",\n \"0.52673167\",\n \"0.525103\",\n \"0.5217854\",\n \"0.5209786\",\n \"0.5201052\",\n \"0.5197442\",\n \"0.5189252\",\n \"0.5189252\",\n \"0.5187253\",\n \"0.51755565\",\n \"0.5174961\",\n \"0.5164124\",\n \"0.5163411\",\n \"0.5148543\",\n \"0.514248\",\n \"0.5121596\",\n \"0.5120403\",\n \"0.51189524\",\n \"0.50978506\",\n \"0.50734687\",\n \"0.5058177\",\n \"0.5056586\",\n \"0.504522\",\n \"0.50417787\",\n \"0.50363314\",\n \"0.50325537\",\n \"0.501305\",\n \"0.49975574\",\n \"0.4973511\",\n \"0.4957602\",\n \"0.49574998\",\n \"0.49559468\",\n \"0.49520752\",\n \"0.49465966\",\n \"0.49267802\",\n \"0.4926275\",\n \"0.4920178\",\n \"0.49162498\",\n \"0.4907312\",\n \"0.49041682\",\n \"0.4895208\",\n \"0.48940438\",\n \"0.48928663\",\n \"0.4888886\",\n \"0.4883144\",\n \"0.48739564\",\n \"0.48724464\",\n \"0.48682138\",\n \"0.4867852\",\n \"0.4857211\",\n \"0.48531112\",\n \"0.48528945\",\n \"0.4852077\",\n \"0.4852077\",\n \"0.48514396\",\n \"0.48505488\",\n \"0.4838406\",\n \"0.48327112\",\n \"0.4830933\",\n \"0.4823441\",\n \"0.48096028\",\n \"0.4809106\",\n \"0.48055875\",\n \"0.48042142\",\n \"0.48034\",\n \"0.4801502\",\n \"0.4793459\",\n \"0.47934362\",\n \"0.4787651\",\n \"0.47824427\",\n \"0.47774798\",\n \"0.47765908\",\n \"0.47748932\",\n \"0.47730464\",\n \"0.47696146\",\n \"0.47676218\",\n \"0.47621673\",\n \"0.47621673\",\n \"0.47621673\",\n \"0.47621673\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6486948"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":5491,"cells":{"query":{"kind":"string","value":"JavaProcess.__init__(self, class_loc, args=[]) Initializes an external Java process."},"document":{"kind":"string","value":"def __init__(self, config, class_loc, args=[]):\n JavaProcess.config = JavaProcessConfig.configFrom_dict(config)\n \n \n self._cp = self._construct_classpath_str()\n self.class_loc = class_loc\n self.args = args\n \n self._process = None\n self._stdout = None\n self._stderr = None\n\n LOG.debug(\"JavaProcess constructed for %s\", self.class_loc)\n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __init__(self, paths):\n Process.__init__(self)\n self.paths = paths","def __init__(self, host=\"\", port=8432):\n Process.__init__(self)\n self.host, self.port = host, port\n self._Handler.annotator = self","def __init__(self):\n self._recording = None\n self._java_call = get_config_str(\"Java\", \"java_call\")\n result = subprocess.call([self._java_call, '-version'])\n if result != 0:\n raise ConfigurationException(\n f\" {self._java_call} -version failed. \"\n \"Please set [Java] java_call to the absolute path \"\n \"to start java. (in config file)\")\n\n self._find_java_jar()\n\n self._machine_json_path = None\n self._placement_json = None\n self._monitor_cores = None\n self._gatherer_iptags = None\n self._gatherer_cores = None\n self._java_properties = get_config_str(\"Java\", \"java_properties\")\n self._chipxy_by_ethernet = None\n if self._java_properties is not None:\n self._java_properties = self._java_properties.split()\n # pylint: disable=not-an-iterable\n for _property in self._java_properties:\n if _property[:2] != \"-D\":\n raise ConfigurationException(\n \"Java Properties must start with -D \"\n f\"found at {_property}\")","def __init__(self, process=None, parent=None, **kwargs):\n super(ProcessIO, self).__init__(**kwargs)\n self.process = process\n self.parent = parent\n self.default_output = process.default_output","def _run_java(self, *args):\n if self._java_properties is None:\n params = [self._java_call, '-jar', self._jar_file]\n else:\n params = [self._java_call] + self._java_properties \\\n + ['-jar', self._jar_file]\n params.extend(args)\n return subprocess.call(params)","def __init__(self):\n self._process = None\n self._nm = PortScanner()","def __init__(self, binPath, numProc, wd, platform):\n self.binPath = binPath\n self.numProc = numProc\n self.wd = wd\n self.platform = platform","def _runner(self, classpath, main, jvm_options, args):","def __init__(self, task_queue, result_queue):\n multiprocessing.Process.__init__(self)\n self.task_queue = task_queue\n self.result_queue = result_queue","def __init__(self, args, shell, userns):\n super(BasicMgr, self).__init__(args, shell, userns)\n self.cmd = self._wlbin + args\n\n # Build Popen instance\n try:\n self.p = Popen(self.cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE,)\n except OSError as e:\n if e.errno == errno.ENOENT:\n print(\"Couldn't find program: %r\" % self.cmd[0])\n return\n else:\n raise e","def __init__(self, stub_class, cmd, port=None):\n self._process_lock = threading.RLock()\n self._process = None\n self._stub_class = stub_class\n self._cmd = [str(arg) for arg in cmd]\n self._port = port","def __init__(self, *args, **kwargs):\n super(PythonTaskWrapper, self).__init__(*args, **kwargs)\n\n self.setOption(\n 'executableName',\n self.__pythonExecutable\n )","def __init__(self, program, args):\n self.__program = program\n self.__args = args","def _launch(self):\n annotators = ['tokenize', 'ssplit']\n if 'ner' in self.annotators:\n annotators.extend(['pos', 'lemma', 'ner'])\n elif 'lemma' in self.annotators:\n annotators.extend(['pos', 'lemma'])\n elif 'pos' in self.annotators:\n annotators.extend(['pos'])\n annotators = ','.join(annotators)\n options = ','.join(['untokenizable=noneDelete',\n 'invertible=true'])\n # if you work on English, use this this command\n cmd = ['java', '-mx' + self.mem, '-cp', '\"%s\"' % self.classpath,\n 'edu.stanford.nlp.pipeline.StanfordCoreNLP', '-annotators',\n annotators, '-tokenize.options', options,\n '-outputFormat', 'json', '-prettyPrint', 'false']\n \n # if you work on arabic, use this this command\n \n # cmd = ['java', '-mx' + self.mem, '-cp', '\"%s\"' % self.classpath,\n # # 'edu.stanford.nlp.pipeline.StanfordCoreNLP','-annotators',\n # 'edu.stanford.nlp.pipeline.StanfordCoreNLP', '-props', 'StanfordCoreNLP-arabic.properties','-annotators',\n # annotators, '-tokenize.options', options, #'-tokenize.whitespace', 'true',\n # '-outputFormat', 'json', '-prettyPrint', 'false']\n print(' '.join(cmd))\n\n # We use pexpect to keep the subprocess alive and feed it commands.\n # Because we don't want to get hit by the max terminal buffer size,\n # we turn off canonical input processing to have unlimited bytes.\n self.corenlp = pexpect.spawn('/bin/bash', maxread=100000, timeout=60)\n self.corenlp.setecho(False)\n self.corenlp.sendline('stty -icanon')\n self.corenlp.sendline(' '.join(cmd))\n self.corenlp.delaybeforesend = 0\n self.corenlp.delayafterread = 0\n self.corenlp.expect_exact('NLP>', searchwindowsize=100)","def __init__(self, *args, **kwargs):\n mp.Process.__init__(self)\n self._args = args\n self._kwargs = kwargs\n self._host_conn, self._proc_conn = mp.Pipe()\n self.daemon = True\n self.start()\n reply = self._host_conn.recv()\n if isinstance(reply, Exception):\n raise reply","def Start(self):\n\n\n\n assert not self._process, 'Start() can only be called once'\n self._process = subprocess.Popen(self._args)","def _from_java(cls, java_obj):\n # Create a new instance of this stage.\n py_obj = cls()\n py_obj._java_obj = java_obj\n if java_obj is None and java_obj.parentPipeline().isDefined():\n py_parent = MLPipeline()\n py_parent._java_obj = java_obj.parentPipeline().get()\n py_obj._parent = py_parent\n return py_obj","def __init__(self, target=None, *args, **kwargs):\n super(PyonThread, self).__init__()\n\n if target is not None or not hasattr(self, 'target'): # Allow setting target at class level\n self.target = target\n self.spawn_args = args\n self.spawn_kwargs = kwargs\n\n # The instance of Greenlet or subprocess or similar\n self.proc = None\n self.supervisor = None\n\n self.ev_exit = Event()","def __init__(self, proc_args: Optional[List[str]]):\n if proc_args:\n self.proc = subprocess.Popen(\n proc_args,\n universal_newlines=True,\n stdin=subprocess.PIPE, # pipe STDIN and STDOUT to send and receive messages\n stdout=subprocess.PIPE\n )\n self.outward_comm_stream = self.proc.stdin\n self.inward_comm_stream = self.proc.stdout\n else:\n self.proc = None\n self.outward_comm_stream = sys.stdout\n self.inward_comm_stream = sys.stdin","def __init__(self, args, env=None):\n self.args = args\n if env:\n self.env = env\n else:\n self.env = os.environ\n self.stdout = None\n self.stderr = None\n self._process = None","def __init__(self, program):\r\n self._program = program","def __init__(self):\n super(MultiProcessEngine, self).__init__()\n self._debug_output = False\n self._name = 'Main'\n self._last_worker_number = 0\n self._log_filename = None\n self._pid = os.getpid()\n self._process_information = process_info.ProcessInfo(self._pid)\n self._process_information_per_pid = {}\n self._processes_per_pid = {}\n self._quiet_mode = False\n self._rpc_clients_per_pid = {}\n self._rpc_errors_per_pid = {}\n self._status_update_active = False\n self._status_update_thread = None\n self._storage_writer = None\n self._worker_memory_limit = definitions.DEFAULT_WORKER_MEMORY_LIMIT","def __init__(self, com: AbsCommunicationProcess):\n super().__init__()\n self.__com = com\n self.__is_started = False","def __init__(self, pid, binary_path, host_name, node_name, telemetry):\n self.pid = pid\n self.binary_path = binary_path\n self.host_name = host_name\n self.node_name = node_name\n self.telemetry = telemetry","def __init__(self, args, shell, userns):\n super(SSHMgr, self).__init__(args, shell, userns)\n parser = MagicArgumentParser()\n parser.add_argument('--host', type=str, default='localhost',\n help='Machine to reach (default = localhost)')\n parser.add_argument('--pid', type=str,\n help='Variable to store SSH process pid')\n _args, cmd = parser.parse_known_args(args)\n self.cmd = self._wlbin + [_args.host, ] + cmd\n # SSH Cannot fork into background without a command to execute.\n # Popen instance is created in submit","def __init__(self, argv):\n self._argv = argv","def __init__(self, readhandle):\n # Name our self\n threading.Thread.__init__(self, name=\"ParentProcessChecker\")\n\n # Store the handle\n self.readhandle = readhandle","def start(self) -> None:\n JavaGate().exec_process_instance(\n self._user,\n self._project,\n self.name,\n \"\",\n self.worker_group,\n self.warning_type,\n self.warning_group_id,\n 24 * 3600,\n )","def spawn(self, classpath, main, jvm_options=None, args=None, **subprocess_args):\r\n cmd = self._create_command(*self._scrub_args(classpath, main, jvm_options, args))\r\n return self._spawn(cmd, **subprocess_args)","def __init__(self):\n self.buienradar_rpc = {\"rain_at\": self.rain_at,\n \"rain_max\": self.rain_max\n }\n\n multiprocessing.Process.__init__(self)\n self.name = 'buienradar'\n self.shutdown = False\n self._sched = None\n self._rain = []","def __init__(self, class_name='gumtree.GumTreeApi'):\n if Gumtree.gumtree is None:\n # class path\n jvm_arg = \"-Djava.class.path=\" + my_constant.JAVA_CLASS_PATH\n startJVM(getDefaultJVMPath(), '-d64', jvm_arg)\n # initial class and object\n GumtreeApi = JClass(class_name)\n Gumtree.gumtree = GumtreeApi()","def __init__(self, connected, jlink_exe=None, jlink_path='', params=None):\n self._connected = connected\n # If not provided, pick the appropriate JLinkExe name based on the\n # platform:\n # - Linux = JLinkExe\n # - Mac = JLinkExe\n # - Windows = JLink.exe\n if jlink_exe is None:\n system = platform.system()\n if system == 'Linux':\n jlink_exe = 'JLinkExe'\n elif system == 'Windows':\n jlink_exe = 'JLink.exe'\n elif system == 'Darwin':\n jlink_exe = 'JLinkExe'\n else:\n raise AdaLinkError('Unsupported system: {0}'.format(system))\n # Store the path to the JLinkExe tool so it can later be run.\n self._jlink_path = os.path.join(jlink_path, jlink_exe)\n logger.info('Using path to JLinkExe: {0}'.format(self._jlink_path))\n # Apply command line parameters if specified.\n self._jlink_params = []\n if params is not None:\n self._jlink_params.extend(params.split())\n logger.info('Using parameters to JLinkExe: {0}'.format(params))\n # Make sure we have the J-Link executable in the system path\n self._test_jlinkexe()","def __init__(self, isParent):\n UTIL.TASK.ProcessingTask.__init__(self, isParent=isParent)","def _from_java(cls, java_obj):\n # Create a new instance of this stage.\n py_obj = cls()\n py_obj._java_obj = java_obj\n return py_obj","def __init__(self, program, *args):\n\n for argument in args:\n if not isinstance(argument, str):\n raise TypeError(\"Arguments to exec should be a string\")\n\n reader, writer = os.pipe2(0)\n pid = os.fork()\n\n if pid == 0:\n os.close(writer)\n os.close(1)\n os.close(2)\n os.dup2(reader, 0)\n\n os.execlp(program, program, *args)\n\n sys.exit(1)\n else:\n os.close(reader)\n self.__pipe = writer\n self.__pid = pid","def __init__(self): \n\t\n\t # get the environment\n\t\tself.env = env()","def __init__(self, classpath, java_executor=None, ivy_settings=None, ivy_cache_dir=None):\r\n\r\n self._classpath = maybe_list(classpath)\r\n\r\n self._java = java_executor or SubprocessExecutor()\r\n if not isinstance(self._java, Executor):\r\n raise ValueError('java_executor must be an Executor instance, given %s of type %s'\r\n % (self._java, type(self._java)))\r\n\r\n self._ivy_settings = ivy_settings\r\n if self._ivy_settings and not isinstance(self._ivy_settings, Compatibility.string):\r\n raise ValueError('ivy_settings must be a string, given %s of type %s'\r\n % (self._ivy_settings, type(self._ivy_settings)))\r\n\r\n self._ivy_cache_dir = ivy_cache_dir\r\n if self._ivy_cache_dir and not isinstance(self._ivy_cache_dir, Compatibility.string):\r\n raise ValueError('ivy_cache_dir must be a string, given %s of type %s'\r\n % (self._ivy_cache_dir, type(self._ivy_cache_dir)))","def compile_java(self):\n if(self.input == \"\"):\n stderr = subprocess.run(\n [\"javac\", self.id+\".java\"], stderr=subprocess.PIPE).stderr.decode('utf-8')\n if(len(stderr) == 0):\n self.status = 1\n stdout = subprocess.run(\n [\"java\"+self.id], stdout=subprocess.PIPE).stdout.decode('utf-8')\n self.output = stdout\n else:\n self.status = 0\n self.output = stderr\n else:\n pass","def __init__(self, task, queue, semaphore=None, task_args=None,\n task_kwargs=None):\n multiprocessing.Process.__init__(self)\n self._task = task\n self._queue = queue\n self._semaphore = semaphore\n self._started = multiprocessing.Event()\n self._killing = multiprocessing.Event()\n self._output = None\n self._parent_pid = None\n self._task_args = task_args if task_args else ()\n self._task_kwargs = task_kwargs if task_kwargs else {}","def __init__(self, task_queue, results_queue, individuals):\n Process.__init__(self)\n \n self.proc_name = self.name\n \n logger.info(\"Setting up variant_annotator: {0}\".format(\n self.proc_name))\n \n logger.debug(\"Setting up task queue\")\n self.task_queue = task_queue\n \n logger.debug(\"Setting up results queue\")\n self.results_queue = results_queue\n\n logger.debug(\"Setting up individuals\")\n self.individuals = individuals\n \n if len(self.individuals) == 1:\n self.models = ['AR_comp', 'AR_comp_dn', 'AD', 'AD_dn']\n else:\n self.models = ['AR_comp', 'AR_comp_dn']","def __init__(self, process_name=sys.argv[0], transport_factory=transport.TransportUnixFactory()):\n self.factory = transport_factory\n self.server = self.factory.serve()\n self.server.addEndpoint(general.EndpointIntrospect())\n processinfo = general.EndpointProcessInfo()\n processinfo.setProcessName(process_name)\n self.server.addEndpoint(processinfo)\n self.server.addEndpoint(tracing.EndpointTraceMapping())\n self.server.addEndpoint(tracing.EndpointNativeTraceSender())","def __init__(self, ghidraUrl: java.net.URL):\n ...","def __init__(\n self, process_name: str = \"Process\", is_ms: bool = False, verbose: bool = True\n ):\n self.verbose = verbose\n self.is_ms = is_ms\n self.process_name = process_name\n self.start = -1\n self.end = -1\n self.elapsed_time_ms = -1","def __init__(self):\n super(PreProcess, self).__init__()","def __call__(self, basepath: str, scriptpath: str) -> Process:\n ...","def start(self):\n self._proc = self._get_subprocess()\n self._pid = self._proc.pid\n self._return_code = None","def __init__(self, master):\n super().__init__()\n self.master = master\n self.proc = None\n self.start()","def __init__(self,cmd=sys.argv[0]):\n\n # Name of the current script's main file without the directory.\n self.name=os.path.basename(sys.argv[0])\n\n # The numeric PID (program ID) of the currently running script.\n self.pid=os.getpid()\n\n # The full, absolute path to the directory given when the current\n # script was run.\n self.dir=os.path.abspath(os.path.dirname(sys.argv[0]))\n\n # Like name and dir, but these follow any symlinks to find the real name.\n # Also, real_dir holds the full, absolute path.\n self.real_dir,self.real_name=os.path.split(os.path.realpath(sys.argv[0]))\n\n # A decent choice of temp file or directory for this program, if\n # needed.\n self.tempdir=self.findMainTempDir()\n self.temp=os.path.join(self.tempdir,'%s.%d'%(self.name,self.pid))\n\n # Get the terminal width and and height, or default to 25x80.\n self.getTerminalSize()","def __init__(self, *args):\n self.env = os.environ.copy()\n \"\"\"Environment variables (:class:`dict`)\"\"\"\n command = \"modulecmd python \"+' '.join(args)\n p = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)\n retval = p.communicate()\n self._parse(retval)","def __init__(self, status_in, data_out):\n Process.__init__(self)\n self.input_stream = status_in\n self.data_out = data_out\n self._UPDATE_INTERVAL_MS = 10\n self._status_labels = {} # A dictionary, whose keys are strings and whose values are Tkinter label variables","def __init__(self, process, thread=None):\n\n self._process = process\n self._thread = thread\n self.__project = None\n self.__sim_procedures_resolved = False\n\n self.load_options = {'auto_load_libs': False}\n self.support_selfmodifying_code = False\n self.use_sim_procedures = True\n self.exclude_sim_procedures_list = []\n self.add_options = set([])\n self.remove_options = set([])\n\n if ANGR_OK:\n try:\n self._process.threads._register_plugin(Angr._thread_plugin, \"angr\")\n except RevengeModulePluginAlreadyRegistered:\n # This will error out if we're already registered\n pass","def __init__(self, command, **kwds):\n ## default properties\n self.__updater__ = None\n self.__threads__ = weakref.WeakSet()\n self.__kwds = kwds\n\n args = shlex.split(command) if isinstance(command, six.string_types) else command[:]\n command = args.pop(0)\n self.command = command, args[:]\n\n self.eventWorking = Asynchronous.Event()\n self.__taskQueue = Asynchronous.Queue()\n self.__exceptionQueue = Asynchronous.Queue()\n\n self.codec = codecs.lookup(kwds.get('encoding', 'iso8859-1' if sys.getdefaultencoding() == 'ascii' else sys.getdefaultencoding()))\n self.stdout = kwds.pop('stdout')\n self.stderr = kwds.pop('stderr')\n\n ## start the process\n not kwds.get('paused', False) and self.start()","def __init__(self, args):\n super(SubProcessTransport, self).__init__()\n\n self._args = args\n\n # The value of `._connect_future` and `._proc` determine the state of\n # the connection:\n # - If `_connect_future` is None and `_proc` is None the transport is\n # not connected, and a connection attempt is not in-flight.\n # - If `_connect_future` is not None and `_proc` is None then a\n # connection attempt is in process.\n # - If `_connect_future is None` and `_proc` is not None then a\n # connection is established.\n # - It is invalid for both `_connect_future` and `_proc` to be not\n # None, or for _connect_future to be done (except transiently within\n # callbacks).\n self._connect_future = None\n self._proc = None\n\n # `_wait_future` is not None if and only if `_proc` is not None. It is\n # used to reset `_proc` to None when the process terminates.\n self._wait_future = None","def __init__(\n self,\n script: Dict[str, Any],\n **kwargs: Any,\n ):\n Module.__init__(self, **kwargs)\n\n # store\n self.script = script\n if 'comm' in script.keys():\n copy_comm = False\n else:\n copy_comm = True\n self._script = self.add_child_object(script, Script, configuration={}, copy_comm=copy_comm)\n\n # add thread func\n self.add_background_task(self._run_thread, False)","def __init__(self, *args, **kwargs):\n super(PythonTaskWrapper, self).__init__(*args, **kwargs)\n\n self.setOption(\n 'executableName',\n os.environ.get(\n 'KOMBI_PYTHON2_EXECUTABLE',\n 'python2'\n )\n )","def __init__(self,\n executable,\n host,\n port,\n app_id,\n script=None,\n application_host=None,\n application_port=None,\n application_root=None,\n auto_id_policy=None,\n blobstore_path=None,\n clear_datastore=None,\n clear_prospective_search=None,\n datastore_path=None,\n enable_sendmail=None,\n enable_task_running=None,\n high_replication=None,\n logs_path=None,\n prospective_search_path=None,\n require_indexes=None,\n show_mail_body=None,\n smtp_host=None,\n smtp_password=None,\n smtp_port=None,\n smtp_user=None,\n task_retry_seconds=None,\n trusted=None,\n use_sqlite=None,\n default_gcs_bucket_name=None):\n self._process = None\n self._host = host\n self._port = port\n if script:\n self._args = [executable, script]\n else:\n self._args = [executable]\n self._BindArgument('--api_host', host)\n self._BindArgument('--api_port', port)\n self._BindArgument('--application_host', application_host)\n self._BindArgument('--application_port', application_port)\n self._BindArgument('--application_root', application_root)\n self._BindArgument('--application', app_id)\n self._BindArgument('--auto_id_policy', auto_id_policy)\n self._BindArgument('--blobstore_path', blobstore_path)\n self._BindArgument('--clear_datastore', clear_datastore)\n self._BindArgument('--clear_prospective_search', clear_prospective_search)\n self._BindArgument('--datastore_path', datastore_path)\n self._BindArgument('--enable_sendmail', enable_sendmail)\n self._BindArgument('--enable_task_running', enable_task_running)\n self._BindArgument('--high_replication', high_replication)\n self._BindArgument('--logs_path', logs_path)\n self._BindArgument('--prospective_search_path', prospective_search_path)\n self._BindArgument('--require_indexes', require_indexes)\n self._BindArgument('--show_mail_body', show_mail_body)\n self._BindArgument('--smtp_host', smtp_host)\n self._BindArgument('--smtp_password', smtp_password)\n self._BindArgument('--smtp_port', smtp_port)\n self._BindArgument('--smtp_user', smtp_user)\n self._BindArgument('--task_retry_seconds', task_retry_seconds)\n self._BindArgument('--trusted', trusted)\n self._BindArgument('--use_sqlite', use_sqlite)\n self._BindArgument('--default_gcs_bucket_name', default_gcs_bucket_name)","def __init__(self, *args, **kwargs):\n super(PythonTaskWrapper, self).__init__(*args, **kwargs)\n\n self.setOption(\n 'executableName',\n os.environ.get(\n 'KOMBI_PYTHON3_EXECUTABLE',\n 'python3'\n )\n )","def addProcess(self, name, args, uid=None, gid=None, env={}):\n class SimpleProcessObject(object):\n\n def starting(self):\n pass\n\n def stopped(self):\n pass\n\n def getName(self):\n return name\n\n def getCommandLine(self):\n return args\n\n def getFileDescriptors(self):\n return []\n\n self.addProcessObject(SimpleProcessObject(), env, uid, gid)","def __init__(self, user=None, java_home=None, compss_home=DEFAULT_COMPSS_HOME, target_base_dir=None,\n comm=DEFAULT_COMM, runcompss_opts=None, execution_envs=DEFAULT_EXECUTION_ENVS):\n\n # Either we receive a user from cfg or we load it from current user (always defined)\n if user is None:\n import getpass\n self.user = getpass.getuser()\n else:\n self.user = user\n\n # Either we receive a java_home or we load it from environment, if not defined we raise an exception\n if java_home is not None:\n self.java_home = java_home\n else:\n # Load from env\n self.java_home = os.getenv(\"JAVA_HOME\", None)\n if self.java_home is None:\n raise ConfigurationError(\n \"[ERROR] Undefined variable JAVA_HOME in both the configuration file and the environment\")\n\n # Store COMPSs_HOME (always defined because it has a default value)\n self.compss_home = compss_home\n\n # Define compss_log_dir\n user_home = os.path.expanduser(\"~\")\n self.compss_log_dir = os.path.join(user_home, DEFAULT_REL_COMPSS_LOG_DIR)\n\n # Either we receive the target_base_dir or we compute it from user home\n if target_base_dir is None:\n self.target_base_dir = os.path.join(user_home, DEFAULT_REL_TARGET_TESTS_DIR)\n else:\n self.target_base_dir = target_base_dir\n\n # Receive comm (always defined, has default value)\n self.comm = comm\n # Receive comm (can be None)\n self.runcompss_opts = runcompss_opts\n # Receive comm (always defined, has default value)\n self.execution_envs = execution_envs","def __init__(self, args, shell, userns):\n self._waiting_steps = 0\n self._running_steps = 0\n self.shebang = (\"#!{0} \\n\".format(shell)).encode('utf8', 'replace')\n # Cell output\n self.out, self.err = None, None\n self._userns = userns","def new_process() -> Process:\n return multiprocessing.Process()","def __init__(self, senna_path, executable):\n self.senna_path = senna_path\n self.p = sp.Popen(['blabla', '-path', senna_path],\n executable=os.path.join(senna_path, executable),\n stdin=sp.PIPE,\n stdout=sp.PIPE)","def __init__(self, ospl_home_bin = \"\", uri = \"\"):\r\n\r\n # OSPL uri:\r\n self.uri = uri\r\n # OSPL HOME binary folder:\r\n self.ospl_home_bin = ospl_home_bin\r\n\r\n # OSPL command process:\r\n self.process = Process(OSPL.command)\r\n # Point OSPL command to the OSPL HOME:\r\n self.reset_ospl_command()","def __init__(self):\n self.read_input()\n self.update_binaries()","def start_process(self, args):\n try:\n with open(os.devnull, 'w') as devnull:\n popenObj = subprocess.Popen(\n args, stdout=devnull, stderr=subprocess.PIPE, cwd=\"/tmp/\")\n popenObj.name = args\n return popenObj\n except Exception as e:\n self.logger.error(\n \"Cannot start process %s due to reason:%s\", args, e)\n raise e","def __init__(self, execute_call):\n self._exe = execute_call","def __init__(self, cmd, **kwargs):\n # Init method - should be subclassed!\n # \n # The subclass methods should look like this:\n # \n # def __init__(self, cmd=\"muscle\", **kwargs):\n # self.parameters = [...]\n # AbstractCommandline.__init__(self, cmd, **kwargs)\n # \n # i.e. There should have an optional argument \"cmd\" to set the location\n # of the executable (with a sensible default which should work if the\n # command is on the path on Unix), and keyword arguments. It should\n # then define a list of parameters, all objects derived from the base\n # class _AbstractParameter.\n # \n # The keyword arguments should be any valid parameter name, and will\n # be used to set the associated parameter.\n self.program_name = cmd\n try:\n parameters = self.parameters\n except AttributeError:\n raise AttributeError(\"Subclass should have defined self.parameters\")\n #Create properties for each parameter at run time\n aliases = set()\n for p in parameters:\n for name in p.names:\n if name in aliases:\n raise ValueError(\"Parameter alias %s multiply defined\" \\\n % name)\n aliases.add(name)\n name = p.names[-1]\n if _re_prop_name.match(name) is None:\n raise ValueError(\"Final parameter name %s cannot be used as \"\n \"an argument or property name in python\"\n % repr(name))\n if name in _reserved_names:\n raise ValueError(\"Final parameter name %s cannot be used as \"\n \"an argument or property name because it is \"\n \"a reserved word in python\" % repr(name))\n if name in _local_reserved_names:\n raise ValueError(\"Final parameter name %s cannot be used as \"\n \"an argument or property name due to the \"\n \"way the AbstractCommandline class works\"\n % repr(name))\n #Beware of binding-versus-assignment confusion issues\n def getter(name):\n return lambda x : x._get_parameter(name)\n def setter(name):\n return lambda x, value : x.set_parameter(name, value)\n def deleter(name):\n return lambda x : x._clear_parameter(name)\n doc = p.description\n if isinstance(p, _Switch):\n doc += \"\\n\\nThis property controls the addition of the %s \" \\\n \"switch, treat this property as a boolean.\" % p.names[0]\n else:\n doc += \"\\n\\nThis controls the addition of the %s parameter \" \\\n \"and its associated value. Set this property to the \" \\\n \"argument value required.\" % p.names[0]\n prop = property(getter(name), setter(name), deleter(name), doc)\n setattr(self.__class__, name, prop) #magic!\n for key, value in kwargs.iteritems():\n self.set_parameter(key, value)","def __init__(self, args, shell, userns):\n super(SlurmMgr, self).__init__(args, shell, userns)\n\n from . import _DEFAULT_SLURM_OUTERR_FILE\n if _DEFAULT_SLURM_OUTERR_FILE is None:\n self._outerr_files = os.path.join(os.environ['HOME'], \"python-execute-slurm.%J\")\n else:\n self._outerr_files = _DEFAULT_SLURM_OUTERR_FILE\n _outerr_pardir = os.path.abspath(os.path.join(self._outerr_files, os.pardir))\n if not os.path.exists(_outerr_pardir):\n os.makedirs(_outerr_pardir)\n\n parser = MagicArgumentParser()\n parser.add_argument('--jobid', type=str,\n help='Variable to store Slurm Job Id')\n _args, cmd = parser.parse_known_args(args)\n self.cmd = self._wlbin + cmd + [\n '--output=' + self._outerr_files + '.out',\n '--error=' + self._outerr_files + '.err']\n self._is_started = False\n self._is_terminated = False\n self._args_jobid = _args.jobid\n\n # Build Popen instance\n try:\n self.p = Popen(self.cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE,)\n except OSError as e:\n if e.errno == errno.ENOENT:\n print(\"Couldn't find program: %r\" % self.cmd[0])\n return\n else:\n raise e","def __init__(self, check):\n\n self.check = check\n self.proc = subprocess.Popen(\n shlex.split(check.command),\n stdout=subprocess.PIPE, stderr=subprocess.STDOUT)\n self.fd = self.proc.stdout.fileno()\n self.stream = self.proc.stdout\n self.output = ''\n\n self.started = time.time()\n self.ended = None","def __init__(self, svc_name: str, svc_type: str, svc_port: str, svc_txt: str = None):\n\n\t\tpltfm = platform.system()\n\n\t\tif pltfm == 'Linux':\n\t\t\twhat = 'Linux'\n\t\t\targs = self.linux_args + [svc_name, svc_type, svc_port]\n\t\t\tif svc_txt != None:\n\t\t\t\targs = args + [svc_txt] # avahi-publish doesn't like empty txt input!\n\n\t\telif pltfm == 'Darwin':\n\t\t\twhat = 'macOS'\n\t\t\targs = self.macos_args + [svc_name, svc_type, \"local\", svc_port]\n\t\t\tif svc_txt != None:\n\t\t\t\targs = args + [svc_txt] # just to keep consistent with Linux path\n\n\t\telse:\n\t\t\tprint(f'Unknown platform \"{pltfm}\"')\n\t\t\tsys.exit(-1)\n\n\t\tprint(f'Platform \"{pltfm}\" assumed to be {what}, using {args} ...')\n\n\t\ttry:\n\t\t\tself.process = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE)\n\t\texcept Exception as e:\n\t\t\tprint(f'Cannot invoke registration command: {e}')\n\t\t\tsys.exit(-1)","def __init__( self ):\n self._env = None\n self._steps = None\n\n self._initialize( )","def __init__(self, serverUrl, databaseName, changeHandlers=None, changeOptions=None, *args, **kwargs):\n Process.__init__(self, None, None, \"learningRegistryChangeMonitor\", args, kwargs)\n self._database = couchdb.Server(serverUrl)[databaseName]\n self._callerThread = None\n self._addHandlerQueue = Queue()\n self._removeHandlerQueue = Queue()\n self._initOptions(changeOptions)\n self._initLastChangeSequence()\n self._initChangeHandlers(changeHandlers)","def spawn(self):\n self._proc = subprocess.Popen(\n self._args, stdout=subprocess.PIPE, stderr=subprocess.PIPE\n )","def __init__(self):\n rospy.logdebug(\"Start ParrotDroneEnv INIT...\")\n\n #Spawn Parrot AR Drone through launch file\n self.ros_pkg_name=\"drone_construct\"\n self.launch_file_name=\"put_drone_in_world.launch\"\n \n super(ParrotDroneEnv, self).__init__(\n ros_pkg_name=self.ros_pkg_name,\n launch_file=self.launch_file_name,\n start_init_physics_parameters=True,\n reset_world_or_sim='WORLD')\n\n rospy.logdebug(\"Finished ParrotDroneEnv INIT...\")","def __init__(__self__, *,\n type: pulumi.Input[str],\n jvm_options: Optional[pulumi.Input[str]] = None,\n relative_path: Optional[pulumi.Input[str]] = None,\n runtime_version: Optional[pulumi.Input[str]] = None,\n version: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"type\", 'Jar')\n if jvm_options is not None:\n pulumi.set(__self__, \"jvm_options\", jvm_options)\n if relative_path is not None:\n pulumi.set(__self__, \"relative_path\", relative_path)\n if runtime_version is not None:\n pulumi.set(__self__, \"runtime_version\", runtime_version)\n if version is not None:\n pulumi.set(__self__, \"version\", version)","def __init__(self, name, args):\n self._proc = None\n self._args = [f\"/{name}\"]\n self._args.extend(args)","def __init__(self, argv, stdin, stdout, stderr):\n self._argv = argv\n self._stdin = stdin\n self._stdout = stdout\n self._stderr = stderr","def __init__(self,\n input_queue: JoinableQueue,\n output_queue: JoinableQueue,\n error_queue: JoinableQueue,\n slack_queue: 'SlackBot.SlackQueue',\n logging_queue: JoinableQueue,\n process_job: Callable[[Type['Task.Task']], Type['Task.Task']],\n name: str =\"PipelineManager\",\n num_processes: int = 1,\n timeout_duration: int = 1) -> None:\n\n self.name = name\n #An attempt to idiot-proof the PipelineManager by instantiating a JoinableQueue() if one didn't exist already.\n self.input_queue = input_queue if input_queue else JoinableQueue()\n self.output_queue = output_queue if output_queue else JoinableQueue()\n self.error_queue = error_queue if error_queue else JoinableQueue()\n self.slack_queue = slack_queue\n self.logging_queue = logging_queue\n self.num_processes = num_processes\n self.process_job = process_job\n self.timeout_duration = timeout_duration\n #A list of active processes comprised of Process objects\n self.process_list: List[Process] = []\n #An internal restart flag (used when all processes managed die)\n self.restart_required = False\n self.logger = logging.getLogger(self.name)\n self.logger.setLevel(logging.DEBUG)","def __init__(self, options, positionals):\n\n print \"* Starting up LOPHI Master Process\"\n\n self.COMMANDS = {G.CTRL_CMD_START: self.command_start,\n G.CTRL_CMD_LIST: self.command_list,\n G.CTRL_CMD_PAUSE: self.command_abstract,\n G.CTRL_CMD_UNPAUSE: self.command_abstract,\n G.CTRL_CMD_SPLASH: self.command_splash,\n G.CTRL_CMD_UPDATE_HW: self.command_update_hw,\n G.CTRL_CMD_STOP: self.command_abstract,\n G.CTRL_CMD_DIE: self.command_abstract,\n G.CTRL_CMD_ATTACH: self.command_abstract,\n G.CTRL_CMD_EXECUTE: self.command_abstract}\n\n self.MSG_TYPES = set([G.CTRL_TYPE, G.REG_TYPE])\n\n # response header\n self.RESP_HEADER = \"[LOPHI Master] \"\n\n logger.debug(\"Importing config files...\")\n\n # Save our config file\n self.master_config_file = options.config_file\n\n # Save our config file\n self.analysis_directory = options.analysis_directory\n\n # Read our config into an internal structure \n self.config_list = Configs.import_from_config(self.master_config_file,\n \"controller\")\n\n # Read our analysis scripts into an internal structure\n self.update_analysis()\n\n # Connect to our database\n self.DB_analysis = DB.DatastoreAnalysis(options.services_host)\n\n # Set our RabbitMQ host\n self.amqp_host = options.services_host","def __init__(self, allowed_processes=None, crypto_miner=None, custom_feed=None, denied_processes=None, detect_compiler_generated_binary=None, encrypted_binaries=None, execution_flow_hijack=None, intelligence_feed=None, reverse_shell=None, service_unknown_origin_binary=None, skip_ssh_tracking=None, suspicious_elf_headers=None, temp_fs_proc=None, user_unknown_origin_binary=None, web_shell=None, wild_fire_analysis=None, local_vars_configuration=None): # noqa: E501 # noqa: E501\n if local_vars_configuration is None:\n local_vars_configuration = Configuration.get_default_copy()\n self.local_vars_configuration = local_vars_configuration\n\n self._allowed_processes = None\n self._crypto_miner = None\n self._custom_feed = None\n self._denied_processes = None\n self._detect_compiler_generated_binary = None\n self._encrypted_binaries = None\n self._execution_flow_hijack = None\n self._intelligence_feed = None\n self._reverse_shell = None\n self._service_unknown_origin_binary = None\n self._skip_ssh_tracking = None\n self._suspicious_elf_headers = None\n self._temp_fs_proc = None\n self._user_unknown_origin_binary = None\n self._web_shell = None\n self._wild_fire_analysis = None\n self.discriminator = None\n\n if allowed_processes is not None:\n self.allowed_processes = allowed_processes\n if crypto_miner is not None:\n self.crypto_miner = crypto_miner\n if custom_feed is not None:\n self.custom_feed = custom_feed\n if denied_processes is not None:\n self.denied_processes = denied_processes\n if detect_compiler_generated_binary is not None:\n self.detect_compiler_generated_binary = detect_compiler_generated_binary\n if encrypted_binaries is not None:\n self.encrypted_binaries = encrypted_binaries\n if execution_flow_hijack is not None:\n self.execution_flow_hijack = execution_flow_hijack\n if intelligence_feed is not None:\n self.intelligence_feed = intelligence_feed\n if reverse_shell is not None:\n self.reverse_shell = reverse_shell\n if service_unknown_origin_binary is not None:\n self.service_unknown_origin_binary = service_unknown_origin_binary\n if skip_ssh_tracking is not None:\n self.skip_ssh_tracking = skip_ssh_tracking\n if suspicious_elf_headers is not None:\n self.suspicious_elf_headers = suspicious_elf_headers\n if temp_fs_proc is not None:\n self.temp_fs_proc = temp_fs_proc\n if user_unknown_origin_binary is not None:\n self.user_unknown_origin_binary = user_unknown_origin_binary\n if web_shell is not None:\n self.web_shell = web_shell\n if wild_fire_analysis is not None:\n self.wild_fire_analysis = wild_fire_analysis","def __init__(self, WORKDIR, JOBNAME, debug):\n #read in parameters\n self.workdir = WORKDIR\n self.jobname = JOBNAME","def create_process( # type: ignore[override]\n self,\n python_setup: PythonSetup,\n subprocess_encoding_environment: SubprocessEncodingEnvironment,\n pex_build_environment: PexBuildEnvironment,\n *,\n pex_args: Iterable[str],\n description: str,\n input_files: Optional[Digest] = None,\n env: Optional[Mapping[str, str]] = None,\n **kwargs: Any,\n ) -> Process:\n\n env = dict(env) if env else {}\n env.update(**pex_build_environment.invocation_environment_dict,)\n\n return super().create_process(\n python_setup=python_setup,\n subprocess_encoding_environment=subprocess_encoding_environment,\n pex_path=self.executable,\n pex_args=pex_args,\n description=description,\n input_files=input_files or self.digest,\n env=env,\n **kwargs,\n )","def __init__(self, name, jar, main_class=None,\r\n action_on_failure='TERMINATE_JOB_FLOW', step_args=None):\r\n self.name = name\r\n self._jar = jar\r\n self._main_class = main_class\r\n self.action_on_failure = action_on_failure\r\n\r\n if isinstance(step_args, basestring):\r\n step_args = [step_args]\r\n\r\n self.step_args = step_args","def __init__(self, queue, video_file, export_interval, export_directory):\n Process.__init__(self)\n self.queue = queue\n self.video_file = video_file\n self.export_interval = export_interval\n self.export_directory = export_directory\n self.current_state = None\n self.constants = CollisionConstants()\n signal.signal(signal.SIGINT, self.signal_handler)","def __init__(self):#, username):\n# self.username = username\n self.pid = os.getpid()","def __init__(self):\n\n self.arg = None\n self.output = None","def __init__(self, logfile):\r\n super(PopenWrapper, self).__init__()\r\n self.logfile = logfile","def __init__(self, do_fork=True):\n\n self.msg = \"Test msg %d\"\n self.do_fork = do_fork\n try:\n # Store the Fork PID\n with open(\"/tmp/daemon.pids\", \"w\") as f:\n self.pid = os.fork()\n f.write(f\"{self.pid}|{os.getpid()}\\n\")\n\n if self.pid == 0:\n print(\"PID: %d\" % self.pid)\n if not do_fork:\n os._exit(0)\n\n except OSError as error:\n print(\"Unable to fork. Error: %d (%s)\" % (error.errno, error.strerror))\n os._exit(1)\n\n self.doTask()","def __init__(\n self,\n output_dir=\"output\",\n resources_dir=\"resources\",\n parallelize=False,\n processes=os.cpu_count(),\n ):\n self._output_dir = output_dir\n self._resources_dir = resources_dir\n self._resources = Resources(resources_dir=resources_dir)\n self._parallelizer = Parallelizer(parallelize=parallelize, processes=processes)","def __init__(\n self, env, link,\n transmitter_port, receiver_port):\n self.env = env\n self.link = link\n self._transmitter_port = transmitter_port\n self._receiver_port = receiver_port\n env.process(self.run())","def __init__(self, shared, subbed, G, solver, istart, cutoff):\n\n # Extract the data and save to self\n self.shared = shared\n self.bool_list, self.north, self.east, self.up = subbed[:4]\n self.wn, self.we, self.wu = subbed[4:7]\n self.penn, self.pene, self.penu = subbed[7:]\n self.G, self.solver, self.istart = G, solver, istart\n self.cutoff = cutoff\n # Init the parent Process class\n Process.__init__(self)","def __init__(self,\n root: Path = None,\n resources_dir: Path = None,\n slave_configuration_path : Path = None,\n binaries_dir : Path = None,\n wrapper_win64 : Path = None,\n wrapper_linux64: Path = None,\n main_script_path : Path = None,\n model_description: Path = None,\n model_description_path : Path = None,\n main_script: Path = None,\n main_class : Path = None,\n pyfmu_dir : Path = None\n ):\n self.model_description = model_description\n\n self.main_script = main_script\n self.main_class = main_class\n self.slave_configuration = None\n\n # paths\n self.root = root\n self.resources_dir = resources_dir\n self.slave_configuration_path = slave_configuration_path\n self.main_script_path = main_script_path\n self.model_description_path = model_description_path\n self.binaries_dir = binaries_dir\n self.wrapper_win64 = wrapper_win64\n self.wrapper_linux64 = wrapper_linux64\n self.pyfmu_dir = pyfmu_dir","def __init__(self, args):\n self.args = args\n self.sender, receiver = mp.Pipe()\n self.plotter = RealPlotter()\n self.plot_process = mp.Process(\n target=self.plotter, args=(receiver,), daemon=True)\n self.plot_process.start()","def _spawn_agent_process(self, process_id, name, module, cls, config, proc_attr):\n process_instance = self._create_process_instance(process_id, name, module, cls, config, proc_attr)\n if not isinstance(process_instance, ResourceAgent) and not isinstance(process_instance, SimpleResourceAgent):\n raise ContainerConfigError(\"Agent process must extend ResourceAgent\")\n listeners = []\n\n # Set the resource ID if we get it through the config\n resource_id = get_safe(process_instance.CFG, \"agent.resource_id\")\n if resource_id:\n process_instance.resource_id = resource_id\n\n alistener = self._create_listening_endpoint(node=self.container.node,\n from_name=resource_id,\n process=process_instance)\n\n listeners.append(alistener)\n\n rsvc = self._create_listening_endpoint(node=self.container.node,\n from_name=process_instance.id,\n process=process_instance)\n\n listeners.append(rsvc)\n\n # cleanup method to delete process/agent queue (@TODO: leaks a bit here - should use XOs)\n def agent_cleanup(x):\n self._cleanup_method(process_instance.id, rsvc)\n if resource_id:\n self._cleanup_method(resource_id, alistener)\n\n proc = self.proc_sup.spawn(name=process_instance.id,\n service=process_instance,\n listeners=listeners,\n proc_name=process_instance._proc_name,\n cleanup_method=agent_cleanup)\n proc.proc._glname = \"ION Proc %s\" % process_instance._proc_name\n self.proc_sup.ensure_ready(proc, \"_spawn_agent_process for %s\" % process_instance.id)\n\n # map gproc to process_instance\n self._spawned_proc_to_process[proc.proc] = process_instance\n\n # set service's reference to process\n process_instance._process = proc\n\n # Now call the on_init of the agent.\n self._process_init(process_instance)\n\n if not process_instance.resource_id:\n log.warn(\"New agent pid=%s has no resource_id set\" % process_id)\n\n self._process_start(process_instance)\n\n try:\n proc.start_listeners()\n except IonProcessError:\n self._process_quit(process_instance)\n self._call_proc_state_changed(process_instance, ProcessStateEnum.FAILED)\n raise\n\n if not process_instance.resource_id:\n log.warn(\"Agent process id=%s does not define resource_id!!\" % process_instance.id)\n\n return process_instance","def __init__(self, cfg, commands, audio_record, audio_play, close_event):\n\n multiprocessing.Process.__init__(self)\n\n self.cfg = cfg\n self.acc = None\n self.acc_cb = None\n self.call = None\n\n self.commands = commands\n self.local_commands = deque()\n\n self.audio_record = audio_record\n self.audio_recording = False\n\n self.audio_play = audio_play\n self.audio_playing = False\n self.local_audio_play = deque()\n\n self.last_frame_id = 1\n self.message_queue = []\n\n self.close_event = close_event\n\n self.black_list = defaultdict(int)","def __init__(self, configpath):\n super().__init__('master process')\n self._configpath = configpath\n self._children = []","def __init__(self):\n self.write_queue = Manager().Queue()\n\n BaseManager.register('Arduino',Arduino)\n BaseManager.register('Algorithm',Algorithm)\n BaseManager.register('Android',Android)\n BaseManager.register('ImageCV', ImageCV)\n manager = BaseManager()\n manager.start()\n shared_ard = manager.Arduino()\n shared_alg = manager.Algorithm()\n shared_and = manager.Android()\n shared_icv = manager.ImageCV()\n \n p1 = Process(target=self.read_algorithm, args=(shared_alg, shared_icv))\n p1.start()\n p2 = Process(target=self.read_arduino, args=[shared_ard])\n p2.start()\n p3 = Process(target=self.read_android, args=[shared_and])\n p3.start()\n p4 = Process(target=self.read_imagecv, args=[shared_icv])\n p4.start()\n p5 = Process(target=self.write_target, args=(shared_ard, shared_alg, shared_and, shared_icv))\n p5.start()\n p5.join()","def __init__(self, process_name, target_function, tasks):\n self.pipe_start, self.pipe_end = multiprocessing.Pipe()\n printnflush (\"Process started: %s\"%process_name)\n self.process = multiprocessing.Process(group=None,\n target=target_function,\n name=process_name,\n args = (process_name, tasks, self.pipe_end))\n self.busy = False","def __init__(self, *args, **kwargs):\n super(ParentProcessAwareSyncManager, self).__init__(*args, **kwargs)\n # the instance of the ProcessWatchDog class which is responsible for the detection of the killed parent process.\n self._watchdog = None\n\n # time which is given to shutdown everything gracefully before the SIGKILL is sent.\n self._time_before_kill = 10","def __init__(self, command_list, seed_index=None, stdin=None, ignore_output=None):\n if not isinstance(command_list, list):\n command_list = [command_list]\n command_list = [str(x) for x in command_list]\n # Set up messages to ignore\n if ignore_output is not None:\n self.__ignore_output = ignore_output\n # Usual case, where no open file handle is provided\n if stdin is None:\n self.__process = subprocess.Popen(command_list, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)\n # Write seed to stdin\n if seed_index is not None:\n self.__output_prefix += \"Process #{}: \".format(seed_index)\n self.__process.stdin.write(str(seed_index))\n self.__process.stdin.close()\n with open(\"pwgseeds.dat\", \"rb\") as seed_file:\n random_seed_list = seed_file.read().splitlines()\n self.log(\"Providing random seed: {}\".format(random_seed_list[seed_index - 1]))\n # Using an open file handle to provide input to stdin: remember to close this later\n else:\n self.__process = subprocess.Popen(command_list, stdout=subprocess.PIPE, stdin=stdin, stderr=subprocess.PIPE)\n # Setup non-blocking stream readers for stdout and stderr\n self.__stdout = NonBlockingStreamReader(self.__process.stdout)\n self.__stderr = NonBlockingStreamReader(self.__process.stderr)"],"string":"[\n \"def __init__(self, paths):\\n Process.__init__(self)\\n self.paths = paths\",\n \"def __init__(self, host=\\\"\\\", port=8432):\\n Process.__init__(self)\\n self.host, self.port = host, port\\n self._Handler.annotator = self\",\n \"def __init__(self):\\n self._recording = None\\n self._java_call = get_config_str(\\\"Java\\\", \\\"java_call\\\")\\n result = subprocess.call([self._java_call, '-version'])\\n if result != 0:\\n raise ConfigurationException(\\n f\\\" {self._java_call} -version failed. \\\"\\n \\\"Please set [Java] java_call to the absolute path \\\"\\n \\\"to start java. (in config file)\\\")\\n\\n self._find_java_jar()\\n\\n self._machine_json_path = None\\n self._placement_json = None\\n self._monitor_cores = None\\n self._gatherer_iptags = None\\n self._gatherer_cores = None\\n self._java_properties = get_config_str(\\\"Java\\\", \\\"java_properties\\\")\\n self._chipxy_by_ethernet = None\\n if self._java_properties is not None:\\n self._java_properties = self._java_properties.split()\\n # pylint: disable=not-an-iterable\\n for _property in self._java_properties:\\n if _property[:2] != \\\"-D\\\":\\n raise ConfigurationException(\\n \\\"Java Properties must start with -D \\\"\\n f\\\"found at {_property}\\\")\",\n \"def __init__(self, process=None, parent=None, **kwargs):\\n super(ProcessIO, self).__init__(**kwargs)\\n self.process = process\\n self.parent = parent\\n self.default_output = process.default_output\",\n \"def _run_java(self, *args):\\n if self._java_properties is None:\\n params = [self._java_call, '-jar', self._jar_file]\\n else:\\n params = [self._java_call] + self._java_properties \\\\\\n + ['-jar', self._jar_file]\\n params.extend(args)\\n return subprocess.call(params)\",\n \"def __init__(self):\\n self._process = None\\n self._nm = PortScanner()\",\n \"def __init__(self, binPath, numProc, wd, platform):\\n self.binPath = binPath\\n self.numProc = numProc\\n self.wd = wd\\n self.platform = platform\",\n \"def _runner(self, classpath, main, jvm_options, args):\",\n \"def __init__(self, task_queue, result_queue):\\n multiprocessing.Process.__init__(self)\\n self.task_queue = task_queue\\n self.result_queue = result_queue\",\n \"def __init__(self, args, shell, userns):\\n super(BasicMgr, self).__init__(args, shell, userns)\\n self.cmd = self._wlbin + args\\n\\n # Build Popen instance\\n try:\\n self.p = Popen(self.cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE,)\\n except OSError as e:\\n if e.errno == errno.ENOENT:\\n print(\\\"Couldn't find program: %r\\\" % self.cmd[0])\\n return\\n else:\\n raise e\",\n \"def __init__(self, stub_class, cmd, port=None):\\n self._process_lock = threading.RLock()\\n self._process = None\\n self._stub_class = stub_class\\n self._cmd = [str(arg) for arg in cmd]\\n self._port = port\",\n \"def __init__(self, *args, **kwargs):\\n super(PythonTaskWrapper, self).__init__(*args, **kwargs)\\n\\n self.setOption(\\n 'executableName',\\n self.__pythonExecutable\\n )\",\n \"def __init__(self, program, args):\\n self.__program = program\\n self.__args = args\",\n \"def _launch(self):\\n annotators = ['tokenize', 'ssplit']\\n if 'ner' in self.annotators:\\n annotators.extend(['pos', 'lemma', 'ner'])\\n elif 'lemma' in self.annotators:\\n annotators.extend(['pos', 'lemma'])\\n elif 'pos' in self.annotators:\\n annotators.extend(['pos'])\\n annotators = ','.join(annotators)\\n options = ','.join(['untokenizable=noneDelete',\\n 'invertible=true'])\\n # if you work on English, use this this command\\n cmd = ['java', '-mx' + self.mem, '-cp', '\\\"%s\\\"' % self.classpath,\\n 'edu.stanford.nlp.pipeline.StanfordCoreNLP', '-annotators',\\n annotators, '-tokenize.options', options,\\n '-outputFormat', 'json', '-prettyPrint', 'false']\\n \\n # if you work on arabic, use this this command\\n \\n # cmd = ['java', '-mx' + self.mem, '-cp', '\\\"%s\\\"' % self.classpath,\\n # # 'edu.stanford.nlp.pipeline.StanfordCoreNLP','-annotators',\\n # 'edu.stanford.nlp.pipeline.StanfordCoreNLP', '-props', 'StanfordCoreNLP-arabic.properties','-annotators',\\n # annotators, '-tokenize.options', options, #'-tokenize.whitespace', 'true',\\n # '-outputFormat', 'json', '-prettyPrint', 'false']\\n print(' '.join(cmd))\\n\\n # We use pexpect to keep the subprocess alive and feed it commands.\\n # Because we don't want to get hit by the max terminal buffer size,\\n # we turn off canonical input processing to have unlimited bytes.\\n self.corenlp = pexpect.spawn('/bin/bash', maxread=100000, timeout=60)\\n self.corenlp.setecho(False)\\n self.corenlp.sendline('stty -icanon')\\n self.corenlp.sendline(' '.join(cmd))\\n self.corenlp.delaybeforesend = 0\\n self.corenlp.delayafterread = 0\\n self.corenlp.expect_exact('NLP>', searchwindowsize=100)\",\n \"def __init__(self, *args, **kwargs):\\n mp.Process.__init__(self)\\n self._args = args\\n self._kwargs = kwargs\\n self._host_conn, self._proc_conn = mp.Pipe()\\n self.daemon = True\\n self.start()\\n reply = self._host_conn.recv()\\n if isinstance(reply, Exception):\\n raise reply\",\n \"def Start(self):\\n\\n\\n\\n assert not self._process, 'Start() can only be called once'\\n self._process = subprocess.Popen(self._args)\",\n \"def _from_java(cls, java_obj):\\n # Create a new instance of this stage.\\n py_obj = cls()\\n py_obj._java_obj = java_obj\\n if java_obj is None and java_obj.parentPipeline().isDefined():\\n py_parent = MLPipeline()\\n py_parent._java_obj = java_obj.parentPipeline().get()\\n py_obj._parent = py_parent\\n return py_obj\",\n \"def __init__(self, target=None, *args, **kwargs):\\n super(PyonThread, self).__init__()\\n\\n if target is not None or not hasattr(self, 'target'): # Allow setting target at class level\\n self.target = target\\n self.spawn_args = args\\n self.spawn_kwargs = kwargs\\n\\n # The instance of Greenlet or subprocess or similar\\n self.proc = None\\n self.supervisor = None\\n\\n self.ev_exit = Event()\",\n \"def __init__(self, proc_args: Optional[List[str]]):\\n if proc_args:\\n self.proc = subprocess.Popen(\\n proc_args,\\n universal_newlines=True,\\n stdin=subprocess.PIPE, # pipe STDIN and STDOUT to send and receive messages\\n stdout=subprocess.PIPE\\n )\\n self.outward_comm_stream = self.proc.stdin\\n self.inward_comm_stream = self.proc.stdout\\n else:\\n self.proc = None\\n self.outward_comm_stream = sys.stdout\\n self.inward_comm_stream = sys.stdin\",\n \"def __init__(self, args, env=None):\\n self.args = args\\n if env:\\n self.env = env\\n else:\\n self.env = os.environ\\n self.stdout = None\\n self.stderr = None\\n self._process = None\",\n \"def __init__(self, program):\\r\\n self._program = program\",\n \"def __init__(self):\\n super(MultiProcessEngine, self).__init__()\\n self._debug_output = False\\n self._name = 'Main'\\n self._last_worker_number = 0\\n self._log_filename = None\\n self._pid = os.getpid()\\n self._process_information = process_info.ProcessInfo(self._pid)\\n self._process_information_per_pid = {}\\n self._processes_per_pid = {}\\n self._quiet_mode = False\\n self._rpc_clients_per_pid = {}\\n self._rpc_errors_per_pid = {}\\n self._status_update_active = False\\n self._status_update_thread = None\\n self._storage_writer = None\\n self._worker_memory_limit = definitions.DEFAULT_WORKER_MEMORY_LIMIT\",\n \"def __init__(self, com: AbsCommunicationProcess):\\n super().__init__()\\n self.__com = com\\n self.__is_started = False\",\n \"def __init__(self, pid, binary_path, host_name, node_name, telemetry):\\n self.pid = pid\\n self.binary_path = binary_path\\n self.host_name = host_name\\n self.node_name = node_name\\n self.telemetry = telemetry\",\n \"def __init__(self, args, shell, userns):\\n super(SSHMgr, self).__init__(args, shell, userns)\\n parser = MagicArgumentParser()\\n parser.add_argument('--host', type=str, default='localhost',\\n help='Machine to reach (default = localhost)')\\n parser.add_argument('--pid', type=str,\\n help='Variable to store SSH process pid')\\n _args, cmd = parser.parse_known_args(args)\\n self.cmd = self._wlbin + [_args.host, ] + cmd\\n # SSH Cannot fork into background without a command to execute.\\n # Popen instance is created in submit\",\n \"def __init__(self, argv):\\n self._argv = argv\",\n \"def __init__(self, readhandle):\\n # Name our self\\n threading.Thread.__init__(self, name=\\\"ParentProcessChecker\\\")\\n\\n # Store the handle\\n self.readhandle = readhandle\",\n \"def start(self) -> None:\\n JavaGate().exec_process_instance(\\n self._user,\\n self._project,\\n self.name,\\n \\\"\\\",\\n self.worker_group,\\n self.warning_type,\\n self.warning_group_id,\\n 24 * 3600,\\n )\",\n \"def spawn(self, classpath, main, jvm_options=None, args=None, **subprocess_args):\\r\\n cmd = self._create_command(*self._scrub_args(classpath, main, jvm_options, args))\\r\\n return self._spawn(cmd, **subprocess_args)\",\n \"def __init__(self):\\n self.buienradar_rpc = {\\\"rain_at\\\": self.rain_at,\\n \\\"rain_max\\\": self.rain_max\\n }\\n\\n multiprocessing.Process.__init__(self)\\n self.name = 'buienradar'\\n self.shutdown = False\\n self._sched = None\\n self._rain = []\",\n \"def __init__(self, class_name='gumtree.GumTreeApi'):\\n if Gumtree.gumtree is None:\\n # class path\\n jvm_arg = \\\"-Djava.class.path=\\\" + my_constant.JAVA_CLASS_PATH\\n startJVM(getDefaultJVMPath(), '-d64', jvm_arg)\\n # initial class and object\\n GumtreeApi = JClass(class_name)\\n Gumtree.gumtree = GumtreeApi()\",\n \"def __init__(self, connected, jlink_exe=None, jlink_path='', params=None):\\n self._connected = connected\\n # If not provided, pick the appropriate JLinkExe name based on the\\n # platform:\\n # - Linux = JLinkExe\\n # - Mac = JLinkExe\\n # - Windows = JLink.exe\\n if jlink_exe is None:\\n system = platform.system()\\n if system == 'Linux':\\n jlink_exe = 'JLinkExe'\\n elif system == 'Windows':\\n jlink_exe = 'JLink.exe'\\n elif system == 'Darwin':\\n jlink_exe = 'JLinkExe'\\n else:\\n raise AdaLinkError('Unsupported system: {0}'.format(system))\\n # Store the path to the JLinkExe tool so it can later be run.\\n self._jlink_path = os.path.join(jlink_path, jlink_exe)\\n logger.info('Using path to JLinkExe: {0}'.format(self._jlink_path))\\n # Apply command line parameters if specified.\\n self._jlink_params = []\\n if params is not None:\\n self._jlink_params.extend(params.split())\\n logger.info('Using parameters to JLinkExe: {0}'.format(params))\\n # Make sure we have the J-Link executable in the system path\\n self._test_jlinkexe()\",\n \"def __init__(self, isParent):\\n UTIL.TASK.ProcessingTask.__init__(self, isParent=isParent)\",\n \"def _from_java(cls, java_obj):\\n # Create a new instance of this stage.\\n py_obj = cls()\\n py_obj._java_obj = java_obj\\n return py_obj\",\n \"def __init__(self, program, *args):\\n\\n for argument in args:\\n if not isinstance(argument, str):\\n raise TypeError(\\\"Arguments to exec should be a string\\\")\\n\\n reader, writer = os.pipe2(0)\\n pid = os.fork()\\n\\n if pid == 0:\\n os.close(writer)\\n os.close(1)\\n os.close(2)\\n os.dup2(reader, 0)\\n\\n os.execlp(program, program, *args)\\n\\n sys.exit(1)\\n else:\\n os.close(reader)\\n self.__pipe = writer\\n self.__pid = pid\",\n \"def __init__(self): \\n\\t\\n\\t # get the environment\\n\\t\\tself.env = env()\",\n \"def __init__(self, classpath, java_executor=None, ivy_settings=None, ivy_cache_dir=None):\\r\\n\\r\\n self._classpath = maybe_list(classpath)\\r\\n\\r\\n self._java = java_executor or SubprocessExecutor()\\r\\n if not isinstance(self._java, Executor):\\r\\n raise ValueError('java_executor must be an Executor instance, given %s of type %s'\\r\\n % (self._java, type(self._java)))\\r\\n\\r\\n self._ivy_settings = ivy_settings\\r\\n if self._ivy_settings and not isinstance(self._ivy_settings, Compatibility.string):\\r\\n raise ValueError('ivy_settings must be a string, given %s of type %s'\\r\\n % (self._ivy_settings, type(self._ivy_settings)))\\r\\n\\r\\n self._ivy_cache_dir = ivy_cache_dir\\r\\n if self._ivy_cache_dir and not isinstance(self._ivy_cache_dir, Compatibility.string):\\r\\n raise ValueError('ivy_cache_dir must be a string, given %s of type %s'\\r\\n % (self._ivy_cache_dir, type(self._ivy_cache_dir)))\",\n \"def compile_java(self):\\n if(self.input == \\\"\\\"):\\n stderr = subprocess.run(\\n [\\\"javac\\\", self.id+\\\".java\\\"], stderr=subprocess.PIPE).stderr.decode('utf-8')\\n if(len(stderr) == 0):\\n self.status = 1\\n stdout = subprocess.run(\\n [\\\"java\\\"+self.id], stdout=subprocess.PIPE).stdout.decode('utf-8')\\n self.output = stdout\\n else:\\n self.status = 0\\n self.output = stderr\\n else:\\n pass\",\n \"def __init__(self, task, queue, semaphore=None, task_args=None,\\n task_kwargs=None):\\n multiprocessing.Process.__init__(self)\\n self._task = task\\n self._queue = queue\\n self._semaphore = semaphore\\n self._started = multiprocessing.Event()\\n self._killing = multiprocessing.Event()\\n self._output = None\\n self._parent_pid = None\\n self._task_args = task_args if task_args else ()\\n self._task_kwargs = task_kwargs if task_kwargs else {}\",\n \"def __init__(self, task_queue, results_queue, individuals):\\n Process.__init__(self)\\n \\n self.proc_name = self.name\\n \\n logger.info(\\\"Setting up variant_annotator: {0}\\\".format(\\n self.proc_name))\\n \\n logger.debug(\\\"Setting up task queue\\\")\\n self.task_queue = task_queue\\n \\n logger.debug(\\\"Setting up results queue\\\")\\n self.results_queue = results_queue\\n\\n logger.debug(\\\"Setting up individuals\\\")\\n self.individuals = individuals\\n \\n if len(self.individuals) == 1:\\n self.models = ['AR_comp', 'AR_comp_dn', 'AD', 'AD_dn']\\n else:\\n self.models = ['AR_comp', 'AR_comp_dn']\",\n \"def __init__(self, process_name=sys.argv[0], transport_factory=transport.TransportUnixFactory()):\\n self.factory = transport_factory\\n self.server = self.factory.serve()\\n self.server.addEndpoint(general.EndpointIntrospect())\\n processinfo = general.EndpointProcessInfo()\\n processinfo.setProcessName(process_name)\\n self.server.addEndpoint(processinfo)\\n self.server.addEndpoint(tracing.EndpointTraceMapping())\\n self.server.addEndpoint(tracing.EndpointNativeTraceSender())\",\n \"def __init__(self, ghidraUrl: java.net.URL):\\n ...\",\n \"def __init__(\\n self, process_name: str = \\\"Process\\\", is_ms: bool = False, verbose: bool = True\\n ):\\n self.verbose = verbose\\n self.is_ms = is_ms\\n self.process_name = process_name\\n self.start = -1\\n self.end = -1\\n self.elapsed_time_ms = -1\",\n \"def __init__(self):\\n super(PreProcess, self).__init__()\",\n \"def __call__(self, basepath: str, scriptpath: str) -> Process:\\n ...\",\n \"def start(self):\\n self._proc = self._get_subprocess()\\n self._pid = self._proc.pid\\n self._return_code = None\",\n \"def __init__(self, master):\\n super().__init__()\\n self.master = master\\n self.proc = None\\n self.start()\",\n \"def __init__(self,cmd=sys.argv[0]):\\n\\n # Name of the current script's main file without the directory.\\n self.name=os.path.basename(sys.argv[0])\\n\\n # The numeric PID (program ID) of the currently running script.\\n self.pid=os.getpid()\\n\\n # The full, absolute path to the directory given when the current\\n # script was run.\\n self.dir=os.path.abspath(os.path.dirname(sys.argv[0]))\\n\\n # Like name and dir, but these follow any symlinks to find the real name.\\n # Also, real_dir holds the full, absolute path.\\n self.real_dir,self.real_name=os.path.split(os.path.realpath(sys.argv[0]))\\n\\n # A decent choice of temp file or directory for this program, if\\n # needed.\\n self.tempdir=self.findMainTempDir()\\n self.temp=os.path.join(self.tempdir,'%s.%d'%(self.name,self.pid))\\n\\n # Get the terminal width and and height, or default to 25x80.\\n self.getTerminalSize()\",\n \"def __init__(self, *args):\\n self.env = os.environ.copy()\\n \\\"\\\"\\\"Environment variables (:class:`dict`)\\\"\\\"\\\"\\n command = \\\"modulecmd python \\\"+' '.join(args)\\n p = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)\\n retval = p.communicate()\\n self._parse(retval)\",\n \"def __init__(self, status_in, data_out):\\n Process.__init__(self)\\n self.input_stream = status_in\\n self.data_out = data_out\\n self._UPDATE_INTERVAL_MS = 10\\n self._status_labels = {} # A dictionary, whose keys are strings and whose values are Tkinter label variables\",\n \"def __init__(self, process, thread=None):\\n\\n self._process = process\\n self._thread = thread\\n self.__project = None\\n self.__sim_procedures_resolved = False\\n\\n self.load_options = {'auto_load_libs': False}\\n self.support_selfmodifying_code = False\\n self.use_sim_procedures = True\\n self.exclude_sim_procedures_list = []\\n self.add_options = set([])\\n self.remove_options = set([])\\n\\n if ANGR_OK:\\n try:\\n self._process.threads._register_plugin(Angr._thread_plugin, \\\"angr\\\")\\n except RevengeModulePluginAlreadyRegistered:\\n # This will error out if we're already registered\\n pass\",\n \"def __init__(self, command, **kwds):\\n ## default properties\\n self.__updater__ = None\\n self.__threads__ = weakref.WeakSet()\\n self.__kwds = kwds\\n\\n args = shlex.split(command) if isinstance(command, six.string_types) else command[:]\\n command = args.pop(0)\\n self.command = command, args[:]\\n\\n self.eventWorking = Asynchronous.Event()\\n self.__taskQueue = Asynchronous.Queue()\\n self.__exceptionQueue = Asynchronous.Queue()\\n\\n self.codec = codecs.lookup(kwds.get('encoding', 'iso8859-1' if sys.getdefaultencoding() == 'ascii' else sys.getdefaultencoding()))\\n self.stdout = kwds.pop('stdout')\\n self.stderr = kwds.pop('stderr')\\n\\n ## start the process\\n not kwds.get('paused', False) and self.start()\",\n \"def __init__(self, args):\\n super(SubProcessTransport, self).__init__()\\n\\n self._args = args\\n\\n # The value of `._connect_future` and `._proc` determine the state of\\n # the connection:\\n # - If `_connect_future` is None and `_proc` is None the transport is\\n # not connected, and a connection attempt is not in-flight.\\n # - If `_connect_future` is not None and `_proc` is None then a\\n # connection attempt is in process.\\n # - If `_connect_future is None` and `_proc` is not None then a\\n # connection is established.\\n # - It is invalid for both `_connect_future` and `_proc` to be not\\n # None, or for _connect_future to be done (except transiently within\\n # callbacks).\\n self._connect_future = None\\n self._proc = None\\n\\n # `_wait_future` is not None if and only if `_proc` is not None. It is\\n # used to reset `_proc` to None when the process terminates.\\n self._wait_future = None\",\n \"def __init__(\\n self,\\n script: Dict[str, Any],\\n **kwargs: Any,\\n ):\\n Module.__init__(self, **kwargs)\\n\\n # store\\n self.script = script\\n if 'comm' in script.keys():\\n copy_comm = False\\n else:\\n copy_comm = True\\n self._script = self.add_child_object(script, Script, configuration={}, copy_comm=copy_comm)\\n\\n # add thread func\\n self.add_background_task(self._run_thread, False)\",\n \"def __init__(self, *args, **kwargs):\\n super(PythonTaskWrapper, self).__init__(*args, **kwargs)\\n\\n self.setOption(\\n 'executableName',\\n os.environ.get(\\n 'KOMBI_PYTHON2_EXECUTABLE',\\n 'python2'\\n )\\n )\",\n \"def __init__(self,\\n executable,\\n host,\\n port,\\n app_id,\\n script=None,\\n application_host=None,\\n application_port=None,\\n application_root=None,\\n auto_id_policy=None,\\n blobstore_path=None,\\n clear_datastore=None,\\n clear_prospective_search=None,\\n datastore_path=None,\\n enable_sendmail=None,\\n enable_task_running=None,\\n high_replication=None,\\n logs_path=None,\\n prospective_search_path=None,\\n require_indexes=None,\\n show_mail_body=None,\\n smtp_host=None,\\n smtp_password=None,\\n smtp_port=None,\\n smtp_user=None,\\n task_retry_seconds=None,\\n trusted=None,\\n use_sqlite=None,\\n default_gcs_bucket_name=None):\\n self._process = None\\n self._host = host\\n self._port = port\\n if script:\\n self._args = [executable, script]\\n else:\\n self._args = [executable]\\n self._BindArgument('--api_host', host)\\n self._BindArgument('--api_port', port)\\n self._BindArgument('--application_host', application_host)\\n self._BindArgument('--application_port', application_port)\\n self._BindArgument('--application_root', application_root)\\n self._BindArgument('--application', app_id)\\n self._BindArgument('--auto_id_policy', auto_id_policy)\\n self._BindArgument('--blobstore_path', blobstore_path)\\n self._BindArgument('--clear_datastore', clear_datastore)\\n self._BindArgument('--clear_prospective_search', clear_prospective_search)\\n self._BindArgument('--datastore_path', datastore_path)\\n self._BindArgument('--enable_sendmail', enable_sendmail)\\n self._BindArgument('--enable_task_running', enable_task_running)\\n self._BindArgument('--high_replication', high_replication)\\n self._BindArgument('--logs_path', logs_path)\\n self._BindArgument('--prospective_search_path', prospective_search_path)\\n self._BindArgument('--require_indexes', require_indexes)\\n self._BindArgument('--show_mail_body', show_mail_body)\\n self._BindArgument('--smtp_host', smtp_host)\\n self._BindArgument('--smtp_password', smtp_password)\\n self._BindArgument('--smtp_port', smtp_port)\\n self._BindArgument('--smtp_user', smtp_user)\\n self._BindArgument('--task_retry_seconds', task_retry_seconds)\\n self._BindArgument('--trusted', trusted)\\n self._BindArgument('--use_sqlite', use_sqlite)\\n self._BindArgument('--default_gcs_bucket_name', default_gcs_bucket_name)\",\n \"def __init__(self, *args, **kwargs):\\n super(PythonTaskWrapper, self).__init__(*args, **kwargs)\\n\\n self.setOption(\\n 'executableName',\\n os.environ.get(\\n 'KOMBI_PYTHON3_EXECUTABLE',\\n 'python3'\\n )\\n )\",\n \"def addProcess(self, name, args, uid=None, gid=None, env={}):\\n class SimpleProcessObject(object):\\n\\n def starting(self):\\n pass\\n\\n def stopped(self):\\n pass\\n\\n def getName(self):\\n return name\\n\\n def getCommandLine(self):\\n return args\\n\\n def getFileDescriptors(self):\\n return []\\n\\n self.addProcessObject(SimpleProcessObject(), env, uid, gid)\",\n \"def __init__(self, user=None, java_home=None, compss_home=DEFAULT_COMPSS_HOME, target_base_dir=None,\\n comm=DEFAULT_COMM, runcompss_opts=None, execution_envs=DEFAULT_EXECUTION_ENVS):\\n\\n # Either we receive a user from cfg or we load it from current user (always defined)\\n if user is None:\\n import getpass\\n self.user = getpass.getuser()\\n else:\\n self.user = user\\n\\n # Either we receive a java_home or we load it from environment, if not defined we raise an exception\\n if java_home is not None:\\n self.java_home = java_home\\n else:\\n # Load from env\\n self.java_home = os.getenv(\\\"JAVA_HOME\\\", None)\\n if self.java_home is None:\\n raise ConfigurationError(\\n \\\"[ERROR] Undefined variable JAVA_HOME in both the configuration file and the environment\\\")\\n\\n # Store COMPSs_HOME (always defined because it has a default value)\\n self.compss_home = compss_home\\n\\n # Define compss_log_dir\\n user_home = os.path.expanduser(\\\"~\\\")\\n self.compss_log_dir = os.path.join(user_home, DEFAULT_REL_COMPSS_LOG_DIR)\\n\\n # Either we receive the target_base_dir or we compute it from user home\\n if target_base_dir is None:\\n self.target_base_dir = os.path.join(user_home, DEFAULT_REL_TARGET_TESTS_DIR)\\n else:\\n self.target_base_dir = target_base_dir\\n\\n # Receive comm (always defined, has default value)\\n self.comm = comm\\n # Receive comm (can be None)\\n self.runcompss_opts = runcompss_opts\\n # Receive comm (always defined, has default value)\\n self.execution_envs = execution_envs\",\n \"def __init__(self, args, shell, userns):\\n self._waiting_steps = 0\\n self._running_steps = 0\\n self.shebang = (\\\"#!{0} \\\\n\\\".format(shell)).encode('utf8', 'replace')\\n # Cell output\\n self.out, self.err = None, None\\n self._userns = userns\",\n \"def new_process() -> Process:\\n return multiprocessing.Process()\",\n \"def __init__(self, senna_path, executable):\\n self.senna_path = senna_path\\n self.p = sp.Popen(['blabla', '-path', senna_path],\\n executable=os.path.join(senna_path, executable),\\n stdin=sp.PIPE,\\n stdout=sp.PIPE)\",\n \"def __init__(self, ospl_home_bin = \\\"\\\", uri = \\\"\\\"):\\r\\n\\r\\n # OSPL uri:\\r\\n self.uri = uri\\r\\n # OSPL HOME binary folder:\\r\\n self.ospl_home_bin = ospl_home_bin\\r\\n\\r\\n # OSPL command process:\\r\\n self.process = Process(OSPL.command)\\r\\n # Point OSPL command to the OSPL HOME:\\r\\n self.reset_ospl_command()\",\n \"def __init__(self):\\n self.read_input()\\n self.update_binaries()\",\n \"def start_process(self, args):\\n try:\\n with open(os.devnull, 'w') as devnull:\\n popenObj = subprocess.Popen(\\n args, stdout=devnull, stderr=subprocess.PIPE, cwd=\\\"/tmp/\\\")\\n popenObj.name = args\\n return popenObj\\n except Exception as e:\\n self.logger.error(\\n \\\"Cannot start process %s due to reason:%s\\\", args, e)\\n raise e\",\n \"def __init__(self, execute_call):\\n self._exe = execute_call\",\n \"def __init__(self, cmd, **kwargs):\\n # Init method - should be subclassed!\\n # \\n # The subclass methods should look like this:\\n # \\n # def __init__(self, cmd=\\\"muscle\\\", **kwargs):\\n # self.parameters = [...]\\n # AbstractCommandline.__init__(self, cmd, **kwargs)\\n # \\n # i.e. There should have an optional argument \\\"cmd\\\" to set the location\\n # of the executable (with a sensible default which should work if the\\n # command is on the path on Unix), and keyword arguments. It should\\n # then define a list of parameters, all objects derived from the base\\n # class _AbstractParameter.\\n # \\n # The keyword arguments should be any valid parameter name, and will\\n # be used to set the associated parameter.\\n self.program_name = cmd\\n try:\\n parameters = self.parameters\\n except AttributeError:\\n raise AttributeError(\\\"Subclass should have defined self.parameters\\\")\\n #Create properties for each parameter at run time\\n aliases = set()\\n for p in parameters:\\n for name in p.names:\\n if name in aliases:\\n raise ValueError(\\\"Parameter alias %s multiply defined\\\" \\\\\\n % name)\\n aliases.add(name)\\n name = p.names[-1]\\n if _re_prop_name.match(name) is None:\\n raise ValueError(\\\"Final parameter name %s cannot be used as \\\"\\n \\\"an argument or property name in python\\\"\\n % repr(name))\\n if name in _reserved_names:\\n raise ValueError(\\\"Final parameter name %s cannot be used as \\\"\\n \\\"an argument or property name because it is \\\"\\n \\\"a reserved word in python\\\" % repr(name))\\n if name in _local_reserved_names:\\n raise ValueError(\\\"Final parameter name %s cannot be used as \\\"\\n \\\"an argument or property name due to the \\\"\\n \\\"way the AbstractCommandline class works\\\"\\n % repr(name))\\n #Beware of binding-versus-assignment confusion issues\\n def getter(name):\\n return lambda x : x._get_parameter(name)\\n def setter(name):\\n return lambda x, value : x.set_parameter(name, value)\\n def deleter(name):\\n return lambda x : x._clear_parameter(name)\\n doc = p.description\\n if isinstance(p, _Switch):\\n doc += \\\"\\\\n\\\\nThis property controls the addition of the %s \\\" \\\\\\n \\\"switch, treat this property as a boolean.\\\" % p.names[0]\\n else:\\n doc += \\\"\\\\n\\\\nThis controls the addition of the %s parameter \\\" \\\\\\n \\\"and its associated value. Set this property to the \\\" \\\\\\n \\\"argument value required.\\\" % p.names[0]\\n prop = property(getter(name), setter(name), deleter(name), doc)\\n setattr(self.__class__, name, prop) #magic!\\n for key, value in kwargs.iteritems():\\n self.set_parameter(key, value)\",\n \"def __init__(self, args, shell, userns):\\n super(SlurmMgr, self).__init__(args, shell, userns)\\n\\n from . import _DEFAULT_SLURM_OUTERR_FILE\\n if _DEFAULT_SLURM_OUTERR_FILE is None:\\n self._outerr_files = os.path.join(os.environ['HOME'], \\\"python-execute-slurm.%J\\\")\\n else:\\n self._outerr_files = _DEFAULT_SLURM_OUTERR_FILE\\n _outerr_pardir = os.path.abspath(os.path.join(self._outerr_files, os.pardir))\\n if not os.path.exists(_outerr_pardir):\\n os.makedirs(_outerr_pardir)\\n\\n parser = MagicArgumentParser()\\n parser.add_argument('--jobid', type=str,\\n help='Variable to store Slurm Job Id')\\n _args, cmd = parser.parse_known_args(args)\\n self.cmd = self._wlbin + cmd + [\\n '--output=' + self._outerr_files + '.out',\\n '--error=' + self._outerr_files + '.err']\\n self._is_started = False\\n self._is_terminated = False\\n self._args_jobid = _args.jobid\\n\\n # Build Popen instance\\n try:\\n self.p = Popen(self.cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE,)\\n except OSError as e:\\n if e.errno == errno.ENOENT:\\n print(\\\"Couldn't find program: %r\\\" % self.cmd[0])\\n return\\n else:\\n raise e\",\n \"def __init__(self, check):\\n\\n self.check = check\\n self.proc = subprocess.Popen(\\n shlex.split(check.command),\\n stdout=subprocess.PIPE, stderr=subprocess.STDOUT)\\n self.fd = self.proc.stdout.fileno()\\n self.stream = self.proc.stdout\\n self.output = ''\\n\\n self.started = time.time()\\n self.ended = None\",\n \"def __init__(self, svc_name: str, svc_type: str, svc_port: str, svc_txt: str = None):\\n\\n\\t\\tpltfm = platform.system()\\n\\n\\t\\tif pltfm == 'Linux':\\n\\t\\t\\twhat = 'Linux'\\n\\t\\t\\targs = self.linux_args + [svc_name, svc_type, svc_port]\\n\\t\\t\\tif svc_txt != None:\\n\\t\\t\\t\\targs = args + [svc_txt] # avahi-publish doesn't like empty txt input!\\n\\n\\t\\telif pltfm == 'Darwin':\\n\\t\\t\\twhat = 'macOS'\\n\\t\\t\\targs = self.macos_args + [svc_name, svc_type, \\\"local\\\", svc_port]\\n\\t\\t\\tif svc_txt != None:\\n\\t\\t\\t\\targs = args + [svc_txt] # just to keep consistent with Linux path\\n\\n\\t\\telse:\\n\\t\\t\\tprint(f'Unknown platform \\\"{pltfm}\\\"')\\n\\t\\t\\tsys.exit(-1)\\n\\n\\t\\tprint(f'Platform \\\"{pltfm}\\\" assumed to be {what}, using {args} ...')\\n\\n\\t\\ttry:\\n\\t\\t\\tself.process = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE)\\n\\t\\texcept Exception as e:\\n\\t\\t\\tprint(f'Cannot invoke registration command: {e}')\\n\\t\\t\\tsys.exit(-1)\",\n \"def __init__( self ):\\n self._env = None\\n self._steps = None\\n\\n self._initialize( )\",\n \"def __init__(self, serverUrl, databaseName, changeHandlers=None, changeOptions=None, *args, **kwargs):\\n Process.__init__(self, None, None, \\\"learningRegistryChangeMonitor\\\", args, kwargs)\\n self._database = couchdb.Server(serverUrl)[databaseName]\\n self._callerThread = None\\n self._addHandlerQueue = Queue()\\n self._removeHandlerQueue = Queue()\\n self._initOptions(changeOptions)\\n self._initLastChangeSequence()\\n self._initChangeHandlers(changeHandlers)\",\n \"def spawn(self):\\n self._proc = subprocess.Popen(\\n self._args, stdout=subprocess.PIPE, stderr=subprocess.PIPE\\n )\",\n \"def __init__(self):\\n rospy.logdebug(\\\"Start ParrotDroneEnv INIT...\\\")\\n\\n #Spawn Parrot AR Drone through launch file\\n self.ros_pkg_name=\\\"drone_construct\\\"\\n self.launch_file_name=\\\"put_drone_in_world.launch\\\"\\n \\n super(ParrotDroneEnv, self).__init__(\\n ros_pkg_name=self.ros_pkg_name,\\n launch_file=self.launch_file_name,\\n start_init_physics_parameters=True,\\n reset_world_or_sim='WORLD')\\n\\n rospy.logdebug(\\\"Finished ParrotDroneEnv INIT...\\\")\",\n \"def __init__(__self__, *,\\n type: pulumi.Input[str],\\n jvm_options: Optional[pulumi.Input[str]] = None,\\n relative_path: Optional[pulumi.Input[str]] = None,\\n runtime_version: Optional[pulumi.Input[str]] = None,\\n version: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"type\\\", 'Jar')\\n if jvm_options is not None:\\n pulumi.set(__self__, \\\"jvm_options\\\", jvm_options)\\n if relative_path is not None:\\n pulumi.set(__self__, \\\"relative_path\\\", relative_path)\\n if runtime_version is not None:\\n pulumi.set(__self__, \\\"runtime_version\\\", runtime_version)\\n if version is not None:\\n pulumi.set(__self__, \\\"version\\\", version)\",\n \"def __init__(self, name, args):\\n self._proc = None\\n self._args = [f\\\"/{name}\\\"]\\n self._args.extend(args)\",\n \"def __init__(self, argv, stdin, stdout, stderr):\\n self._argv = argv\\n self._stdin = stdin\\n self._stdout = stdout\\n self._stderr = stderr\",\n \"def __init__(self,\\n input_queue: JoinableQueue,\\n output_queue: JoinableQueue,\\n error_queue: JoinableQueue,\\n slack_queue: 'SlackBot.SlackQueue',\\n logging_queue: JoinableQueue,\\n process_job: Callable[[Type['Task.Task']], Type['Task.Task']],\\n name: str =\\\"PipelineManager\\\",\\n num_processes: int = 1,\\n timeout_duration: int = 1) -> None:\\n\\n self.name = name\\n #An attempt to idiot-proof the PipelineManager by instantiating a JoinableQueue() if one didn't exist already.\\n self.input_queue = input_queue if input_queue else JoinableQueue()\\n self.output_queue = output_queue if output_queue else JoinableQueue()\\n self.error_queue = error_queue if error_queue else JoinableQueue()\\n self.slack_queue = slack_queue\\n self.logging_queue = logging_queue\\n self.num_processes = num_processes\\n self.process_job = process_job\\n self.timeout_duration = timeout_duration\\n #A list of active processes comprised of Process objects\\n self.process_list: List[Process] = []\\n #An internal restart flag (used when all processes managed die)\\n self.restart_required = False\\n self.logger = logging.getLogger(self.name)\\n self.logger.setLevel(logging.DEBUG)\",\n \"def __init__(self, options, positionals):\\n\\n print \\\"* Starting up LOPHI Master Process\\\"\\n\\n self.COMMANDS = {G.CTRL_CMD_START: self.command_start,\\n G.CTRL_CMD_LIST: self.command_list,\\n G.CTRL_CMD_PAUSE: self.command_abstract,\\n G.CTRL_CMD_UNPAUSE: self.command_abstract,\\n G.CTRL_CMD_SPLASH: self.command_splash,\\n G.CTRL_CMD_UPDATE_HW: self.command_update_hw,\\n G.CTRL_CMD_STOP: self.command_abstract,\\n G.CTRL_CMD_DIE: self.command_abstract,\\n G.CTRL_CMD_ATTACH: self.command_abstract,\\n G.CTRL_CMD_EXECUTE: self.command_abstract}\\n\\n self.MSG_TYPES = set([G.CTRL_TYPE, G.REG_TYPE])\\n\\n # response header\\n self.RESP_HEADER = \\\"[LOPHI Master] \\\"\\n\\n logger.debug(\\\"Importing config files...\\\")\\n\\n # Save our config file\\n self.master_config_file = options.config_file\\n\\n # Save our config file\\n self.analysis_directory = options.analysis_directory\\n\\n # Read our config into an internal structure \\n self.config_list = Configs.import_from_config(self.master_config_file,\\n \\\"controller\\\")\\n\\n # Read our analysis scripts into an internal structure\\n self.update_analysis()\\n\\n # Connect to our database\\n self.DB_analysis = DB.DatastoreAnalysis(options.services_host)\\n\\n # Set our RabbitMQ host\\n self.amqp_host = options.services_host\",\n \"def __init__(self, allowed_processes=None, crypto_miner=None, custom_feed=None, denied_processes=None, detect_compiler_generated_binary=None, encrypted_binaries=None, execution_flow_hijack=None, intelligence_feed=None, reverse_shell=None, service_unknown_origin_binary=None, skip_ssh_tracking=None, suspicious_elf_headers=None, temp_fs_proc=None, user_unknown_origin_binary=None, web_shell=None, wild_fire_analysis=None, local_vars_configuration=None): # noqa: E501 # noqa: E501\\n if local_vars_configuration is None:\\n local_vars_configuration = Configuration.get_default_copy()\\n self.local_vars_configuration = local_vars_configuration\\n\\n self._allowed_processes = None\\n self._crypto_miner = None\\n self._custom_feed = None\\n self._denied_processes = None\\n self._detect_compiler_generated_binary = None\\n self._encrypted_binaries = None\\n self._execution_flow_hijack = None\\n self._intelligence_feed = None\\n self._reverse_shell = None\\n self._service_unknown_origin_binary = None\\n self._skip_ssh_tracking = None\\n self._suspicious_elf_headers = None\\n self._temp_fs_proc = None\\n self._user_unknown_origin_binary = None\\n self._web_shell = None\\n self._wild_fire_analysis = None\\n self.discriminator = None\\n\\n if allowed_processes is not None:\\n self.allowed_processes = allowed_processes\\n if crypto_miner is not None:\\n self.crypto_miner = crypto_miner\\n if custom_feed is not None:\\n self.custom_feed = custom_feed\\n if denied_processes is not None:\\n self.denied_processes = denied_processes\\n if detect_compiler_generated_binary is not None:\\n self.detect_compiler_generated_binary = detect_compiler_generated_binary\\n if encrypted_binaries is not None:\\n self.encrypted_binaries = encrypted_binaries\\n if execution_flow_hijack is not None:\\n self.execution_flow_hijack = execution_flow_hijack\\n if intelligence_feed is not None:\\n self.intelligence_feed = intelligence_feed\\n if reverse_shell is not None:\\n self.reverse_shell = reverse_shell\\n if service_unknown_origin_binary is not None:\\n self.service_unknown_origin_binary = service_unknown_origin_binary\\n if skip_ssh_tracking is not None:\\n self.skip_ssh_tracking = skip_ssh_tracking\\n if suspicious_elf_headers is not None:\\n self.suspicious_elf_headers = suspicious_elf_headers\\n if temp_fs_proc is not None:\\n self.temp_fs_proc = temp_fs_proc\\n if user_unknown_origin_binary is not None:\\n self.user_unknown_origin_binary = user_unknown_origin_binary\\n if web_shell is not None:\\n self.web_shell = web_shell\\n if wild_fire_analysis is not None:\\n self.wild_fire_analysis = wild_fire_analysis\",\n \"def __init__(self, WORKDIR, JOBNAME, debug):\\n #read in parameters\\n self.workdir = WORKDIR\\n self.jobname = JOBNAME\",\n \"def create_process( # type: ignore[override]\\n self,\\n python_setup: PythonSetup,\\n subprocess_encoding_environment: SubprocessEncodingEnvironment,\\n pex_build_environment: PexBuildEnvironment,\\n *,\\n pex_args: Iterable[str],\\n description: str,\\n input_files: Optional[Digest] = None,\\n env: Optional[Mapping[str, str]] = None,\\n **kwargs: Any,\\n ) -> Process:\\n\\n env = dict(env) if env else {}\\n env.update(**pex_build_environment.invocation_environment_dict,)\\n\\n return super().create_process(\\n python_setup=python_setup,\\n subprocess_encoding_environment=subprocess_encoding_environment,\\n pex_path=self.executable,\\n pex_args=pex_args,\\n description=description,\\n input_files=input_files or self.digest,\\n env=env,\\n **kwargs,\\n )\",\n \"def __init__(self, name, jar, main_class=None,\\r\\n action_on_failure='TERMINATE_JOB_FLOW', step_args=None):\\r\\n self.name = name\\r\\n self._jar = jar\\r\\n self._main_class = main_class\\r\\n self.action_on_failure = action_on_failure\\r\\n\\r\\n if isinstance(step_args, basestring):\\r\\n step_args = [step_args]\\r\\n\\r\\n self.step_args = step_args\",\n \"def __init__(self, queue, video_file, export_interval, export_directory):\\n Process.__init__(self)\\n self.queue = queue\\n self.video_file = video_file\\n self.export_interval = export_interval\\n self.export_directory = export_directory\\n self.current_state = None\\n self.constants = CollisionConstants()\\n signal.signal(signal.SIGINT, self.signal_handler)\",\n \"def __init__(self):#, username):\\n# self.username = username\\n self.pid = os.getpid()\",\n \"def __init__(self):\\n\\n self.arg = None\\n self.output = None\",\n \"def __init__(self, logfile):\\r\\n super(PopenWrapper, self).__init__()\\r\\n self.logfile = logfile\",\n \"def __init__(self, do_fork=True):\\n\\n self.msg = \\\"Test msg %d\\\"\\n self.do_fork = do_fork\\n try:\\n # Store the Fork PID\\n with open(\\\"/tmp/daemon.pids\\\", \\\"w\\\") as f:\\n self.pid = os.fork()\\n f.write(f\\\"{self.pid}|{os.getpid()}\\\\n\\\")\\n\\n if self.pid == 0:\\n print(\\\"PID: %d\\\" % self.pid)\\n if not do_fork:\\n os._exit(0)\\n\\n except OSError as error:\\n print(\\\"Unable to fork. Error: %d (%s)\\\" % (error.errno, error.strerror))\\n os._exit(1)\\n\\n self.doTask()\",\n \"def __init__(\\n self,\\n output_dir=\\\"output\\\",\\n resources_dir=\\\"resources\\\",\\n parallelize=False,\\n processes=os.cpu_count(),\\n ):\\n self._output_dir = output_dir\\n self._resources_dir = resources_dir\\n self._resources = Resources(resources_dir=resources_dir)\\n self._parallelizer = Parallelizer(parallelize=parallelize, processes=processes)\",\n \"def __init__(\\n self, env, link,\\n transmitter_port, receiver_port):\\n self.env = env\\n self.link = link\\n self._transmitter_port = transmitter_port\\n self._receiver_port = receiver_port\\n env.process(self.run())\",\n \"def __init__(self, shared, subbed, G, solver, istart, cutoff):\\n\\n # Extract the data and save to self\\n self.shared = shared\\n self.bool_list, self.north, self.east, self.up = subbed[:4]\\n self.wn, self.we, self.wu = subbed[4:7]\\n self.penn, self.pene, self.penu = subbed[7:]\\n self.G, self.solver, self.istart = G, solver, istart\\n self.cutoff = cutoff\\n # Init the parent Process class\\n Process.__init__(self)\",\n \"def __init__(self,\\n root: Path = None,\\n resources_dir: Path = None,\\n slave_configuration_path : Path = None,\\n binaries_dir : Path = None,\\n wrapper_win64 : Path = None,\\n wrapper_linux64: Path = None,\\n main_script_path : Path = None,\\n model_description: Path = None,\\n model_description_path : Path = None,\\n main_script: Path = None,\\n main_class : Path = None,\\n pyfmu_dir : Path = None\\n ):\\n self.model_description = model_description\\n\\n self.main_script = main_script\\n self.main_class = main_class\\n self.slave_configuration = None\\n\\n # paths\\n self.root = root\\n self.resources_dir = resources_dir\\n self.slave_configuration_path = slave_configuration_path\\n self.main_script_path = main_script_path\\n self.model_description_path = model_description_path\\n self.binaries_dir = binaries_dir\\n self.wrapper_win64 = wrapper_win64\\n self.wrapper_linux64 = wrapper_linux64\\n self.pyfmu_dir = pyfmu_dir\",\n \"def __init__(self, args):\\n self.args = args\\n self.sender, receiver = mp.Pipe()\\n self.plotter = RealPlotter()\\n self.plot_process = mp.Process(\\n target=self.plotter, args=(receiver,), daemon=True)\\n self.plot_process.start()\",\n \"def _spawn_agent_process(self, process_id, name, module, cls, config, proc_attr):\\n process_instance = self._create_process_instance(process_id, name, module, cls, config, proc_attr)\\n if not isinstance(process_instance, ResourceAgent) and not isinstance(process_instance, SimpleResourceAgent):\\n raise ContainerConfigError(\\\"Agent process must extend ResourceAgent\\\")\\n listeners = []\\n\\n # Set the resource ID if we get it through the config\\n resource_id = get_safe(process_instance.CFG, \\\"agent.resource_id\\\")\\n if resource_id:\\n process_instance.resource_id = resource_id\\n\\n alistener = self._create_listening_endpoint(node=self.container.node,\\n from_name=resource_id,\\n process=process_instance)\\n\\n listeners.append(alistener)\\n\\n rsvc = self._create_listening_endpoint(node=self.container.node,\\n from_name=process_instance.id,\\n process=process_instance)\\n\\n listeners.append(rsvc)\\n\\n # cleanup method to delete process/agent queue (@TODO: leaks a bit here - should use XOs)\\n def agent_cleanup(x):\\n self._cleanup_method(process_instance.id, rsvc)\\n if resource_id:\\n self._cleanup_method(resource_id, alistener)\\n\\n proc = self.proc_sup.spawn(name=process_instance.id,\\n service=process_instance,\\n listeners=listeners,\\n proc_name=process_instance._proc_name,\\n cleanup_method=agent_cleanup)\\n proc.proc._glname = \\\"ION Proc %s\\\" % process_instance._proc_name\\n self.proc_sup.ensure_ready(proc, \\\"_spawn_agent_process for %s\\\" % process_instance.id)\\n\\n # map gproc to process_instance\\n self._spawned_proc_to_process[proc.proc] = process_instance\\n\\n # set service's reference to process\\n process_instance._process = proc\\n\\n # Now call the on_init of the agent.\\n self._process_init(process_instance)\\n\\n if not process_instance.resource_id:\\n log.warn(\\\"New agent pid=%s has no resource_id set\\\" % process_id)\\n\\n self._process_start(process_instance)\\n\\n try:\\n proc.start_listeners()\\n except IonProcessError:\\n self._process_quit(process_instance)\\n self._call_proc_state_changed(process_instance, ProcessStateEnum.FAILED)\\n raise\\n\\n if not process_instance.resource_id:\\n log.warn(\\\"Agent process id=%s does not define resource_id!!\\\" % process_instance.id)\\n\\n return process_instance\",\n \"def __init__(self, cfg, commands, audio_record, audio_play, close_event):\\n\\n multiprocessing.Process.__init__(self)\\n\\n self.cfg = cfg\\n self.acc = None\\n self.acc_cb = None\\n self.call = None\\n\\n self.commands = commands\\n self.local_commands = deque()\\n\\n self.audio_record = audio_record\\n self.audio_recording = False\\n\\n self.audio_play = audio_play\\n self.audio_playing = False\\n self.local_audio_play = deque()\\n\\n self.last_frame_id = 1\\n self.message_queue = []\\n\\n self.close_event = close_event\\n\\n self.black_list = defaultdict(int)\",\n \"def __init__(self, configpath):\\n super().__init__('master process')\\n self._configpath = configpath\\n self._children = []\",\n \"def __init__(self):\\n self.write_queue = Manager().Queue()\\n\\n BaseManager.register('Arduino',Arduino)\\n BaseManager.register('Algorithm',Algorithm)\\n BaseManager.register('Android',Android)\\n BaseManager.register('ImageCV', ImageCV)\\n manager = BaseManager()\\n manager.start()\\n shared_ard = manager.Arduino()\\n shared_alg = manager.Algorithm()\\n shared_and = manager.Android()\\n shared_icv = manager.ImageCV()\\n \\n p1 = Process(target=self.read_algorithm, args=(shared_alg, shared_icv))\\n p1.start()\\n p2 = Process(target=self.read_arduino, args=[shared_ard])\\n p2.start()\\n p3 = Process(target=self.read_android, args=[shared_and])\\n p3.start()\\n p4 = Process(target=self.read_imagecv, args=[shared_icv])\\n p4.start()\\n p5 = Process(target=self.write_target, args=(shared_ard, shared_alg, shared_and, shared_icv))\\n p5.start()\\n p5.join()\",\n \"def __init__(self, process_name, target_function, tasks):\\n self.pipe_start, self.pipe_end = multiprocessing.Pipe()\\n printnflush (\\\"Process started: %s\\\"%process_name)\\n self.process = multiprocessing.Process(group=None,\\n target=target_function,\\n name=process_name,\\n args = (process_name, tasks, self.pipe_end))\\n self.busy = False\",\n \"def __init__(self, *args, **kwargs):\\n super(ParentProcessAwareSyncManager, self).__init__(*args, **kwargs)\\n # the instance of the ProcessWatchDog class which is responsible for the detection of the killed parent process.\\n self._watchdog = None\\n\\n # time which is given to shutdown everything gracefully before the SIGKILL is sent.\\n self._time_before_kill = 10\",\n \"def __init__(self, command_list, seed_index=None, stdin=None, ignore_output=None):\\n if not isinstance(command_list, list):\\n command_list = [command_list]\\n command_list = [str(x) for x in command_list]\\n # Set up messages to ignore\\n if ignore_output is not None:\\n self.__ignore_output = ignore_output\\n # Usual case, where no open file handle is provided\\n if stdin is None:\\n self.__process = subprocess.Popen(command_list, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)\\n # Write seed to stdin\\n if seed_index is not None:\\n self.__output_prefix += \\\"Process #{}: \\\".format(seed_index)\\n self.__process.stdin.write(str(seed_index))\\n self.__process.stdin.close()\\n with open(\\\"pwgseeds.dat\\\", \\\"rb\\\") as seed_file:\\n random_seed_list = seed_file.read().splitlines()\\n self.log(\\\"Providing random seed: {}\\\".format(random_seed_list[seed_index - 1]))\\n # Using an open file handle to provide input to stdin: remember to close this later\\n else:\\n self.__process = subprocess.Popen(command_list, stdout=subprocess.PIPE, stdin=stdin, stderr=subprocess.PIPE)\\n # Setup non-blocking stream readers for stdout and stderr\\n self.__stdout = NonBlockingStreamReader(self.__process.stdout)\\n self.__stderr = NonBlockingStreamReader(self.__process.stderr)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6975941","0.6958235","0.67394876","0.6490618","0.6321262","0.6161817","0.612476","0.6118696","0.6096931","0.6078772","0.60693926","0.60651165","0.60423166","0.60343724","0.6023563","0.600156","0.5997967","0.5996555","0.5996109","0.5992397","0.59232205","0.5911356","0.5887123","0.58784014","0.58750504","0.5862586","0.5821235","0.58133376","0.580679","0.5776895","0.5772634","0.5767489","0.5766778","0.5746678","0.5743888","0.57207537","0.5697409","0.56906766","0.5669662","0.56688017","0.5661704","0.56599146","0.56578314","0.5643581","0.5626292","0.56133413","0.55959857","0.5583519","0.5575963","0.5573424","0.55565506","0.55485016","0.5539343","0.55319566","0.55318147","0.55256504","0.552013","0.55161864","0.54897183","0.5487508","0.5475878","0.54602474","0.5458723","0.5447629","0.5441156","0.54286337","0.5428051","0.5424346","0.54215777","0.5420897","0.5418543","0.54173446","0.5415367","0.5402114","0.54004645","0.53956383","0.53883564","0.53766406","0.5376354","0.5370152","0.5369299","0.53685945","0.536283","0.5357425","0.5348491","0.5336658","0.53350246","0.53304887","0.53295434","0.5319991","0.531698","0.531043","0.5309474","0.5308306","0.5303908","0.5297841","0.5284864","0.5283084","0.52805424","0.5269254"],"string":"[\n \"0.6975941\",\n \"0.6958235\",\n \"0.67394876\",\n \"0.6490618\",\n \"0.6321262\",\n \"0.6161817\",\n \"0.612476\",\n \"0.6118696\",\n \"0.6096931\",\n \"0.6078772\",\n \"0.60693926\",\n \"0.60651165\",\n \"0.60423166\",\n \"0.60343724\",\n \"0.6023563\",\n \"0.600156\",\n \"0.5997967\",\n \"0.5996555\",\n \"0.5996109\",\n \"0.5992397\",\n \"0.59232205\",\n \"0.5911356\",\n \"0.5887123\",\n \"0.58784014\",\n \"0.58750504\",\n \"0.5862586\",\n \"0.5821235\",\n \"0.58133376\",\n \"0.580679\",\n \"0.5776895\",\n \"0.5772634\",\n \"0.5767489\",\n \"0.5766778\",\n \"0.5746678\",\n \"0.5743888\",\n \"0.57207537\",\n \"0.5697409\",\n \"0.56906766\",\n \"0.5669662\",\n \"0.56688017\",\n \"0.5661704\",\n \"0.56599146\",\n \"0.56578314\",\n \"0.5643581\",\n \"0.5626292\",\n \"0.56133413\",\n \"0.55959857\",\n \"0.5583519\",\n \"0.5575963\",\n \"0.5573424\",\n \"0.55565506\",\n \"0.55485016\",\n \"0.5539343\",\n \"0.55319566\",\n \"0.55318147\",\n \"0.55256504\",\n \"0.552013\",\n \"0.55161864\",\n \"0.54897183\",\n \"0.5487508\",\n \"0.5475878\",\n \"0.54602474\",\n \"0.5458723\",\n \"0.5447629\",\n \"0.5441156\",\n \"0.54286337\",\n \"0.5428051\",\n \"0.5424346\",\n \"0.54215777\",\n \"0.5420897\",\n \"0.5418543\",\n \"0.54173446\",\n \"0.5415367\",\n \"0.5402114\",\n \"0.54004645\",\n \"0.53956383\",\n \"0.53883564\",\n \"0.53766406\",\n \"0.5376354\",\n \"0.5370152\",\n \"0.5369299\",\n \"0.53685945\",\n \"0.536283\",\n \"0.5357425\",\n \"0.5348491\",\n \"0.5336658\",\n \"0.53350246\",\n \"0.53304887\",\n \"0.53295434\",\n \"0.5319991\",\n \"0.531698\",\n \"0.531043\",\n \"0.5309474\",\n \"0.5308306\",\n \"0.5303908\",\n \"0.5297841\",\n \"0.5284864\",\n \"0.5283084\",\n \"0.52805424\",\n \"0.5269254\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8258955"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":5492,"cells":{"query":{"kind":"string","value":"we will do a bubble sort on the list and then get the 2nd element to the last"},"document":{"kind":"string","value":"def second_largest(number_list):\n for i in range(len(number_list)):\n for j in range(len(number_list) - 1 - i):\n if number_list[j] > number_list[j+1]:\n number_list[j + 1], number_list[j] = number_list[j], number_list[j+1]\n\n return number_list[-2]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def bubbleSort(list):","def bubble_sort(list):\n for i in range(1, len(list) - 1):\n for j in range(len(list) - 1, i-1, -1):\n if list[j - 1] > list[j]:\n x = list[j]\n list[j] = list[j - 1]\n list[j - 1] = x\n return list","def bubbleSort(lst):\n for i in range(len(lst)):\n for j in range(len(lst)-i-1):\n if lst[j]>lst[j+1]:\n lst[j], lst[j+1], = lst[j+1], lst[j]\n print(lst)","def bubble_sort(L):\n end = len(L)-1\n\n while end !=0:\n for i in range(end):\n if L[i] > L[i+1]:\n L[i], L[i+1] = L[i+1], L[i]\n \n \n end = end -1","def bubble_sort(mylist):\n sorted = False\n while not sorted:\n sorted = True\n for i in range(1, len(mylist)):\n if mylist[i - 1] > mylist[i]:\n sorted = False\n mylist[i - 1], mylist[i] = mylist[i], mylist[i - 1]\n return mylist","def bubble_sort(a_list):\n for item in reversed(range(len(a_list))):\n for i in range(item):\n if a_list[i] > a_list[i + 1]:\n a_list[i], a_list[i + 1] = a_list[i + 1], a_list[i]\n return a_list","def bubble_sort(input_list):\n \n length = len(input_list)\n \n for i in range(length):\n for j in range(length-i-1):\n if input_list[j] > input_list[j+1]:\n input_list[j], input_list[j+1] = input_list[j+1], input_list[j]\n \n return input_list","def bubbleSort( listToSort ):\n for i in range( len(listToSort), 0, -1 ):\n for j in range( 0, i-1 ):\n if listToSort[j] > listToSort[j+1]:\n tmp = listToSort[j]\n listToSort[j] = listToSort[j+1]\n listToSort[j+1] = tmp","def bubble_sort(first):\n # iterate len(lst) times\n for i in range(len(first)):\n\n # integrate [len(lst) - i - 1] times\n for j in range(len(first) - i - 1):\n\n # sort two number if not sorted\n if first[j] > first[j + 1]:\n # swap element at j with element at j + 1\n # and element ad j + 1 with element j\n first[j], first[j + 1] = first[j + 1], first[j]","def bubble_sort(lst):\n\n def swap(i,j):\n lst[i], lst[j] = lst[j], lst[i]\n\n n = 0\n while n <= len(lst) - 1:\n for i in range(len(lst)-1-n):\n if lst[i] >= lst[i+1]:\n swap(i,i+1)\n n+=1","def bubble_sort(lst: list) -> None:\n n = len(lst)\n if n == 0 or n == 1:\n return\n for boundary in range(n, 1, -1):\n swapped = False\n for i in range(1, boundary):\n if lst[i - 1] > lst[i]:\n swap(lst, i - 1, i)\n swapped = True\n if not swapped: # if list is now sorted\n return","def buble_sort(lst):\n lst_sorted = copy.copy(lst)\n for i in range(len(lst_sorted)):\n for j in range(len(lst_sorted)):\n if j == len(lst_sorted) - 1:\n continue\n if lst_sorted[j][1] > lst_sorted[j + 1][1]:\n lst_sorted[j], lst_sorted[j+1] = lst_sorted[j+1], lst_sorted[j]\n\n return lst_sorted","def bubble_sort(items):\n for num in range(len(items)-1,0,-1):\n for j in range(num):\n if items[j]>items[j+1]:\n temp = items[j]\n items[j] = items[j+1]\n items[j+1] = temp\n return items","def BubbleSort(ulist):\n done = 0 #This variable is used to break the loop when sorting is done\n while not done:\n done = 1\n for i in range(len(ulist) - 1):\n if ulist[i] > ulist[i+1]:\n ulist[i], ulist[i+1] = ulist[i+1], ulist[i]\n done = 0","def bubble_sort(integer_list):\n for passnum in range(len(integer_list), 1, -1):\n for i in range(passnum-1):\n if integer_list[i] > integer_list[i+1]:\n integer_list[i], integer_list[i+1] = integer_list[i+1], integer_list[i]\n return integer_list","def bubble_sort(arr):\n temp = None\n for x in range(0, len(arr)-1):\n for y in range(0, len(arr)-1):\n if arr[y] > arr[y+1]:\n temp = arr[y]\n arr[y] = arr[y+1]\n arr[y+1] = temp \n return arr","def bubble_sort(arr: List[int]) -> List[int]:\n sorted = False\n while not sorted:\n sorted = True\n for i in range(1, len(arr)):\n if arr[i-1] > arr[i]:\n arr[i], arr[i-1] = arr[i-1], arr[i]\n sorted = False\n return arr","def bubbleSort(list,i):\n\n if i == 1:\n return list\n\n else:\n for k in range(i - 1):\n if list[k] > list[k+1]:\n list[k], list[k+1] = list[k+1], list[k]\n\n bubbleSort(list,i-1)","def bubble_sort(a):\n for i in reversed(range(len(a))):\n for j in range(1, i + 1):\n if a[j-1] > a[j]:\n a[j], a[j-1] = a[j-1], a[j]\n return a","def bubble_sort(a):\n for i in reversed(range(len(a))):\n for j in range(1, i + 1):\n if a[j-1] > a[j]:\n a[j], a[j-1] = a[j-1], a[j]\n return a","def buble_sort(l):\r\n for i in range(len(l)):\r\n for j in range(i+1, len(l)):\r\n if (l[j-1]>l[j]):\r\n l[j-1], l[j] = l[j], l[j-1]","def bubble_sort(data):\n the_list = list(data)\n\n length = len(the_list)\n \"\"\" Iterate from the start to the back,\n then go to back - 1 \"\"\"\n while length >= 1:\n innerloop(the_list)\n length -= 1\n\n return the_list","def improved_bubble_sort(data_list):\n for passnum in range(len(data_list) - 1, 0, -1):\n is_sorted = True\n for idx in range(passnum):\n if data_list[idx] > data_list[idx + 1]:\n temp = data_list[idx]\n data_list[idx] = data_list[idx + 1]\n data_list[idx + 1] = temp\n is_sorted = False\n if is_sorted:\n return","def bubblesort(given_list):\n completely_sorted = False\n while not completely_sorted:\n update_done = False\n for i in range(1, len(given_list)):\n previous = given_list[i-1]\n if previous > given_list[i]:\n given_list[i-1] = given_list[i]\n given_list[i] = previous\n update_done = True\n if not update_done:\n completely_sorted = True\n return given_list","def bubble_sort(items):\n for i in range(len(items)):\n for j in range(len(items) - 1 - i):\n if items[j] > items[j + 1]:\n items[j], items[j + 1] = items[j + 1], items[j]\n return items","def bubble_sort(data_list_or_tuple):\n data_list = list(data_list_or_tuple)\n for count, _ in enumerate(data_list, 1):\n for x in range(len(data_list)-count):\n if data_list[x] > data_list[x+1]:\n data_list[x], data_list[x+1] = data_list[x+1], data_list[x]\n return data_list","def bubble_sort(arr:Sequence[List]) -> Sequence[List]:\n n = len(arr)\n for i in range(n-1):\n for j in range(n-i-1):\n if arr[j] > arr[j+1]:\n arr[j], arr[j+1] = arr[j+1], arr[j]\n return arr","def bubble_sort(self, data):\n for i in range(len(data)-1, 0, -1):\n for j in range(i):\n if data[j] > data[j+1]:\n tmp = data[j]\n data[j] = data[j+1]\n data[j+1] = tmp\n print \"pass\", i, data","def bubblesort(lst_bubble):\n n = len(lst_bubble)\n cond = 0\n assign = 0\n for i in range(n):\n for j in range(1,n-i):\n cond +=1\n if lst_bubble[j-1] > lst_bubble[j]:\n lst_bubble[j],lst_bubble[j-1] = swap(lst_bubble[j],lst_bubble[j-1])\n assign +=3\n return (cond, assign)","def bubble_sort(lst):\n\n swaps_made = 0\n\n for i in range(len(lst)):\n made_swap = False\n for j in range(len(lst)-1-i):\n if lst[j] > lst[j+1]:\n lst[j], lst[j+1] = lst[j+1], lst[j]\n made_swap = True\n swaps_made += 1\n\n if not made_swap:\n break\n\n return lst #or can return # swaps made if that's what we're looing for","def bubble_sort(itr):\n arr = list(copy.copy(itr))\n is_sorted = True\n n = len(arr)\n while n > 1:\n for i in range(1, n):\n if arr[i] < arr[i - 1]:\n arr[i], arr[i - 1] = arr[i - 1], arr[i]\n is_sorted = False\n if is_sorted: break\n is_sorted = True\n n -= 1\n return arr","def mysort(lst: List[T], compare: Callable[[T, T], int]) -> List[T]:\n for i in range(1, len(lst)): #loops through each element starting at the second one\n for j in range(i, 0, -1): #loops through each element coming before i starting at i and going backwards\n if compare(lst[j], lst[j-1]) < 0: #checks to see if the previous element is smaller than the current (by saying <0 we keep the sort stable as well)\n lst[j], lst[j-1] = lst[j-1], lst[j] #if they are, we switch them\n else:\n break #if they are not, we know that the element is in its proper place\n return lst","def bubbleSort(sortList):\r\n \r\n for i in range(len(sortList)):\r\n for j in range(len(sortList)-1-i):\r\n if itemAmount[ sortList[j] ] > itemAmount[ sortList[j + 1] ]:\r\n sortList[j], sortList[j+1] = sortList[j+1], sortList[j]","def short_bubble_sort(num_list):\n exchange = True\n passnum = len(num_list) - 1\n\n while passnum > 0 and exchange:\n exchange = False\n for i in range(passnum):\n # Exchanges items\n if num_list[i] > num_list[i + 1]:\n temp = num_list[i]\n num_list[i] = num_list[i + 1]\n num_list[i + 1] = temp\n exchange = True\n passnum -= 1","def bubble_sort(mylist):\n n = len(mylist)\n swapped = True\n while swapped:\n swapped = False\n for i in range(1, n):\n if mylist[i-1] > mylist[i]:\n _swap(mylist, i-1, i)\n swapped = True\n n -= 1","def bubble_sort(items):\n for i in range(len(items)):\n for j in range(len(items)-1-i):\n if items[j] > items[j+1]:\n items[j], items[j+1] = items[j+1], items[j] # Swap!","def burbuja(lista:list):\n vector = lista\n for i in range(0, len(vector)-1):\n for j in range(0, len(vector)-1):\n if vector[j] > vector[j+1]:\n tmp = vector[j+1]\n vector[j+1] = vector[j]\n vector[j] = tmp\n return vector","def bubble_sort(l):\n # Raise value\n if not isinstance(l, list):\n raise TypeError(\"Not a list\")\n \n # Initialize variables to count\n r = c = w = 0\n lenL = len(l)\n swapped = True \n\n # only if there isn't any swap will the loop stop \n while swapped:\n swapped = False \n\n for i in range(1, lenL):\n r += 2\n c += 1 \n if l[i - 1] > l[i]:\n # Swap the elements\n l[i - 1], l[i] = l[i], l[i - 1]\n w += 2\n swapped = True # loop again \n lenL -= 1 \n \n return c, r, w","def sorting(my_list):\n for indx in range(1,len(my_list)):\n i=indx\n while i>0:\n if my_list[i]<my_list[i-1]:\n temp=my_list[i-1]\n my_list[i-1]=my_list[i]\n my_list[i]=temp\n i=i-1\n return my_list","def bubble_sort(alist):\n potato = True\n while potato:\n potato = False\n for idx in range(len(alist) - 1):\n if alist[idx] > alist[idx + 1]:\n temp = alist[idx]\n alist[idx] = alist[idx + 1]\n alist[idx + 1] = temp\n potato = True\n return alist","def sort_2(l):\n l.reverse()","def bubble_sort(arr):\n n = len(arr)\n # Traverse through all array elements\n for i in range(n):\n # Last i elements are already in place\n for j in range(0, n-i-1):\n # traverse the array from 0 to n-i-1\n # Swap if the element found is greater\n # than the next element\n if arr[j] > arr[j+1] :\n arr[j], arr[j+1] = arr[j+1], arr[j]\n return arr","def short_bubble_sort(integer_list):\n exchanged = True\n for passnum in range(len(integer_list), 1, -1):\n exchanged = False\n for i in range(passnum-1):\n if integer_list[i] > integer_list[i+1]:\n exchanged = True\n integer_list[i], integer_list[i+1] = integer_list[i+1], integer_list[i]\n if not exchanged:\n break\n return integer_list","def bubble_sort(data):\n sorted_data = list(data)\n\n for i in range(len(sorted_data) - 1):\n for j in range(len(sorted_data) - 1 - i):\n if sorted_data[j] > sorted_data[j + 1]:\n sorted_data[j], sorted_data[j + 1] =\\\n sorted_data[j + 1], sorted_data[j]\n return sorted_data","def bubble_sort_smart(array: list):\n size = len(array)\n\n for i in range(size):\n for j in range(size - i - 1):\n if array[j] > array[j + 1]:\n aux = array[j]\n array[j] = array[j + 1]\n array[j + 1] = aux\n #array[j], array[j + 1] = array[j + 1], array[j]","def sorting_alg(self, my_list):\n for i in range(len(my_list)):\n for j in range(i+1, len(my_list)):\n if my_list[i] > my_list[j]:\n my_list[i], my_list[j] = my_list[j], my_list[i]\n #print(my_list)\n #sleep(1)\n return my_list","def bubblesort(a):\n\n while True:\n swap = 0\n for i in range(1,len(a)):\n if a[i] < a[i-1]:\n a[i], a[i-1] = a[i-1], a[i]\n swap = 1\n \n if not swap:\n break","def wiggle_sort(nums):\n\n for i in range(len(nums)):\n if (i % 2 == 1) == (nums[i - 1] > nums[i]):\n nums[i - 1], nums[i] = nums[i], nums[i - 1]","def bubble_sort(array: list):\n size = len(array)\n\n for i in range(size):\n for j in range(size - 1):\n if array[j] > array[j + 1]:\n aux = array[j]\n array[j] = array[j + 1]\n array[j + 1] = aux\n #array[j], array[j + 1] = array[j + 1], array[j]","def bubble_sort(items):\n # TODO: Repeat until all items are in sorted order\n # TODO: Swap adjacent items that are out of order\n for x in range(len(items)-1):\n if items[x]>items[x+1]:\n temp = items[x]\n items[x] = items[x+1]\n items[x+1] = temp","def test_sort_reversed():\n sorted_data = [5, 4, 3, 2, 1]\n sorted_list = bubble_sort(sorted_data)\n\n for small, large in zip(sorted_list[:-1], sorted_list[1:]):\n assert small <= large","def bubble_sort(array):\n final_position = len(array) - 1\n\n while final_position > 0:\n for index in range(final_position):\n if array[index] > array[index + 1]:\n array[index], array[index + 1] = array[index + 1], array[index]\n\n final_position -= 1\n\n return array","def bubble_final_position(array):\n swap_point = len(array)\n while swap_point:\n new_swap = 0\n for i in range(1, swap_point):\n if array[i-1] > array[i]:\n array[i-1], array[i] = array[i], array[i-1]\n new_swap = i\n swap_point = new_swap","def findSecondLargest(self):\n l = []\n self.flatten(l)\n print(l)\n print(l[-2])","def bubble_sort(items):\n # Repeat until all items are in sorted order\n # Swap adjacent items that are out of order\n # loop through list\n # TODO: Running time: ??? Why and under what conditions?\n # TODO: Memory usage: ??? Why and under what conditions?\"\"\"\n while not is_sorted(items):\n for i in range(len(items) - 1):\n # Loop backwards avoiding the already sorted numbers\n for j in range(len(items) - 1 - i):\n # if left item is bigger than the right\n if items[j] > items[j + 1]:\n # Swap left and right \n items[j], items[j + 1] = items[j + 1], items[j]\n return items","def test_bubblesort_sorts_list():\n from bubblesort import bubblesort\n unsorted_list = [6, 4, 7, 9, 0, 2]\n assert bubblesort(unsorted_list) == [0, 2, 4, 6, 7, 9]","def bubbleSort(unsortedValues: list) -> None:\n \n done: bool = False # initialize to false \n sortedCount: int = 0\n\n while not done: \n done = True\n index: int = 0\n\n while index < len(unsortedValues) - 1 - sortedCount:\n if unsortedValues[index] > unsortedValues[index + 1]:\n swap(unsortedValues, index, index + 1)\n done = False\n index += 1\n sortedCount += 1","def innerloop(the_list):\n for index in range(len(the_list)-1):\n if the_list[index] > the_list[index+1]:\n smaller = the_list[index+1]\n bigger = the_list[index]\n the_list[index] = smaller\n the_list[index+1] = bigger\n\n return tuple(the_list)","def bubble_sort(items):\n out = items.copy() # in place protection on items\n for i in range(len(out)):\n for j in range(len(out)-1-i):\n if out[j] > out[j+1]:\n out[j], out[j+1] = out[j+1], out[j] # Swap!\n\n return out","def bubble_sort(A: list):\n N = len(A)\n list_is_sorted = False\n bypass = 1\n while not list_is_sorted:\n list_is_sorted = True\n for k in range(N - bypass):\n if A[k] > A[k+1]:\n A[k], A[k+1] = A[k+1], A[k]\n list_is_sorted = False\n bypass += 1","def bubble_sort(items):\n # Repeat until all items are in sorted order\n # Swap adjacent items that are out of order\n current = 0\n right = 1\n while not is_sorted(items):\n if current == len(items) - 1:\n current = 0\n right = 1\n\n elif items[current] > items[right]:\n items[current], items[right] = items[right], items[current]\n \n else:\n current += 1\n right += 1","def nth_largest2(a_list, n):\n a_list.sort()\n new_list = a_list[::-1]\n return new_list[n-1]","def bubble_sort_smarter(array: list):\n size = len(array)\n\n while size > 0:\n idx = 0\n for j in range(size):\n if array[j] > array[j + 1]:\n aux = array[j]\n array[j] = array[j + 1]\n array[j + 1] = aux\n #array[j], array[j + 1] = array[j + 1], array[j]\n idx = j + 1\n\n size = idx","def mysort(lst: List[T], compare: Callable[[T, T], int]) -> List[T]:\n temp = lst\n switched = True\n while switched:\n switched = False\n for i in range(len(temp) - 1):\n if compare(temp[i], temp[i + 1]) == 1:\n temp[i], temp[i + 1] = temp[i + 1], temp[i]\n switched = True\n\n return temp","def reverse_sort(list_to_sort: List) -> List:\n if len(list_to_sort) == 1:\n return list_to_sort\n list_to_sort = [e for e in list_to_sort] # to avoid sorting in place, comment this to change original list\n for j in range(len(list_to_sort) - 2, -1, -1):\n sorted_element = list_to_sort[j]\n # print('sorted element:', sorted_element)\n i = j + 1\n while i < len(list_to_sort) and list_to_sort[i] > sorted_element:\n list_to_sort[i - 1] = list_to_sort[i]\n i += 1\n list_to_sort[i - 1] = sorted_element\n # print('list after insertion:', list_to_sort)\n return list_to_sort","def bubble_sort_modificado(a):\n N = len(a)\n n = 0\n b = False\n while (n != N) and (not b):\n k = N - 1\n b = True\n while k != n:\n if a[k-1] > a[k]:\n b = False\n a[k-1], a[k] = a[k], a[k-1]\n k -= 1\n n += 1","def bubbleSort(sequence):\n n = len(sequence)\n # Perform n-1 bubble operations on the sequence\n for i in range(n - 1):\n # Bubble the largest item to the end.\n for j in range(n - i - 1):\n if sequence[j] > sequence[j+1]:\n sequence[j], sequence[j+1] = sequence[j+1], sequence[j]","def merge_sort(self, lst):\r\n [sorted_lst, number_of_inversions] = self.sort_and_get_number_of_inversions(lst)\r\n \r\n return sorted_lst","def bubble_sort(dataset):\n\t# start with array length and decrement each time \n\tarrayLen = len(dataset)\n\tbubbleIndex = len(dataset) - 1\n\twhile bubbleIndex != 0:\n\t\tarrayIndex = 0\n\t\twhile arrayIndex < arrayLen - 1:\n\t\t\tthisVal = dataset[arrayIndex]\n\t\t\tnextVal = dataset[arrayIndex + 1]\n\t\t\tif thisVal > nextVal:\n\t\t\t\tdataset[arrayIndex + 1] = thisVal\n\t\t\t\tdataset[arrayIndex] = nextVal\n\t\t\tarrayIndex += 1\n\t\tprint \"Current State:\", dataset\n\t\tbubbleIndex -= 1","def timsort(lst):\n sublsts = []\n\n i = 0\n while i < len(lst):\n sublsts.append([lst[i]])\n i += 1\n\n if i < len(lst) and lst[i] >= lst[i - 1]:\n while i < len(lst) and lst[i] >= lst[i - 1]:\n sublsts[-1].append(lst[i])\n i += 1\n elif i < len(lst):\n while i < len(lst) and lst[i] < lst[i - 1]:\n sublsts[-1].append(lst[i])\n i += 1\n\n sublsts[-1] = sublsts[-1][::-1]\n\n return merge_many(*sublsts)","def pizza_sort(lst):\n length = len(lst)\n def based_god_help_me(lst,index=0):\n if index == length - 1:\n return\n greatest = index_largest(lst[index:]) + index\n lst[greatest], lst[index] = lst[index], lst[greatest]\n based_god_help_me(lst,index+1)\n return based_god_help_me(lst)","def bubble_sort(array):\n\tupdated = 1\n\tcounter = 0\n\n\twhile(updated == 1):\n\t\tupdated = 0\n\t\t\n\t\tfor i in range(len(array)-1-counter):\n\t\t\tif array[i] > array[i+1]:\n\t\t\t\tarray[i],array[i+1] = array[i+1],array[i]\n\t\t\t\tupdated = 1\n\t\t\n\t\tcounter += 1\n\n\treturn array","def isort(my_list):\n comparision_count = 0\n for index in range(len(my_list)-1):\n # Picking for each Number\n comparision_count = comparision_count + 1\n if my_list[index+1] < my_list[index]:\n # moving the element\n my_list[index + 1], my_list[index] = my_list[index], my_list[index + 1]\n newposition = index\n\n # Comparing the changed element with the already sorted list\n for i in range(index,0,-1):\n comparision_count = comparision_count + 1\n if my_list[newposition-1] > my_list[i]:\n # moving the element\n my_list[i] , my_list[newposition-1] = my_list[newposition-1] , my_list[i]\n newposition = i-1 # remembering the new position\n else:\n # Since it is a sorted list, breaking loop if condition fails atleast once\n break\n return (my_list , comparision_count)","def gnomesort(self):\n # nothing to do if we're empty or singleton\n if len(self) < 2:\n return\n # start with second element, and always compare to the element before\n current = self.first.next\n while current is not None:\n # thus current must have a .prev\n # If this element is unsorted with the element before it, then\n if current.prev and current.value < current.prev.value:\n # swap this element with the element before it\n # using insert_after and pop_before is an easy way to handle first/last identities\n self.insert_after(current, self.pop_before(current))\n # and then check the new previous-element.\n else:\n # advance to next node (or None if this is the last node in the list, in which case we terminate)\n current = current.next","def test_original_unchanged():\n first_list = [28, 3, 4, 10, 8]\n bubble_sort(first_list)\n assert first_list == [28, 3, 4, 10, 8]","def bubblesort(array):\n j = len(array)\n while j > 0:\n swapped = False\n for i in range(1, j):\n if array[i-1] > array[i]:\n array[i-1], array[i] = array[i], array[i-1]\n swapped = True\n j -= 1\n if swapped == False:\n return array\n return array","def touple_bubble_sort(data_touple, sort_by = 0):\n for passnum in range(len(data_touple) - 1, 0, -1):\n is_sorted = True\n for idx in range(passnum):\n if data_touple[idx][sort_by] > data_touple[idx + 1][sort_by]:\n temp = data_touple[idx]\n data_touple[idx] = data_touple[idx + 1]\n data_touple[idx + 1] = temp\n is_sorted = False\n if is_sorted:\n return","def wiggleSort(self, nums: 'List[int]') -> 'None':\n ns = sorted(nums)\n N = len(ns)//2 + len(ns)%2\n ns1, ns2 = ns[:N][::-1], ns[N:][::-1]\n for i in range(len(ns)//2):\n nums[i*2] = ns1[i]\n nums[i*2+1] = ns2[i]\n if len(ns) % 2 == 1:\n nums[-1] = ns1[-1]","def custom_sort(vector:list)->list:\n if len(vector) <= 2:\n return vector\n\n else:\n mid = len(vector) // 2\n vector.insert(1, vector.pop(mid))\n i = 1\n for idx in range(2, len(vector)-1, 2):\n vector.insert(idx+1, vector.pop(mid+i))\n i +=1\n return vector","def bubble_sort(A):\n seguir = True\n largo = len(A)\n while seguir:\n seguir = False\n for i in xrange(largo - 1):\n if A[i] > A[i+1]:\n A[i], A[i+1] = A[i+1], A[i]\n seguir = True","def __sort(self, _list, _index, desc, pop_first_element=False):\n if _index != 0:\n _list = [(x[_index], x) for x in _list]\n \n _list.sort()\n \n if desc:\n _list.reverse()\n\n if _index != 0 or pop_first_element: \n _list = [x[1] for x in _list]\n\n return _list","def wiggleSort(self, nums):\n nums2=nums.copy()\n nums2.sort()\n n = len(nums)\n if n%2:\n midpoint = n//2\n else:\n midpoint = n//2-1\n j=n-1\n i=midpoint\n point=0\n while j > midpoint:\n nums[point] = nums2[i]\n nums[point+1] = nums2[j]\n j-=1\n i-=1\n point+=2\n if n%2:\n nums[-1]=nums2[0]\n print(nums)","def test_sort_reversed():\n reverse_sorted_data = [3, 2, 1]\n sorted_data = bubble_sort(reverse_sorted_data)\n assert sorted_data == [1, 2, 3]","def sort_1(l):\n pass","def stooge_sort(arr):\r\n stooge(arr, 0, len(arr) - 1)","def wiggleSort(self, nums: List[int]) -> None:\n '''\n ## nlogn\n if len(nums)<=1:\n return nums \n nums.sort()\n l = len(nums)\n for i in range(1,l-1,2):\n nums[i],nums[i+1] = nums[i+1],nums[i]\n return nums\n\n '''\n ## O(n)\n l = len(nums)\n for i in range(1, l):\n if i % 2 == 1 and nums[i] < nums[i - 1]:\n nums[i], nums[i - 1] = nums[i - 1], nums[i]\n if i % 2 == 0 and nums[i] > nums[i - 1]:\n nums[i], nums[i - 1] = nums[i - 1], nums[i]","def test_sort_reversed():\n assert bubble_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]","def wiggleSort3(self, nums) -> None:\n # Sort the list, and swap adjacent element starting from the second element\n nums.sort()\n i = 1\n while i < len(nums) - 1:\n nums[i], nums[i+1] = nums[i+1], nums[i]\n i += 2","def bubble_sort(input_array):\n for i in range(0, len(input_array)):\n for j in range(0,len(input_array) - i - 1):\n if input_array[j] > input_array[j+1]:\n tmp = input_array[j]\n input_array[j] = input_array[j+1]\n input_array[j+1] = tmp","def sort_012(input_list):\r\n \r\n # Positions 0's to the start of the array and 2's to the end.\r\n # All remaining are 1's.\r\n\r\n next_0_index = 0\r\n next_2_index = len(input_list) - 1\r\n\r\n i = 0\r\n \r\n # Traverse the array once.\r\n # Last index to be checked is next_2_index because it is \r\n # one position before the last placed 2.\r\n while i < next_2_index + 1:\r\n\r\n element = input_list[i]\r\n\r\n if element == 0:\r\n\r\n # Position at next_0_index and put that element in this 0's place\r\n input_list[i], input_list[next_0_index] = input_list[next_0_index], input_list[i]\r\n\r\n # next_0_index is now taken by a 0, next index is to its right\r\n next_0_index += 1\r\n\r\n # Increment to check next element. All from i and before are 0's\r\n i += 1\r\n\r\n if element == 2:\r\n \r\n # Position at next_2_index and put that element in this 2's place\r\n input_list[i], input_list[next_2_index] = input_list[next_2_index], input_list[i]\r\n \r\n # next_2_index is now taken by a 2, next index is to its left\r\n next_2_index -= 1\r\n \r\n if element == 1:\r\n\r\n # Leave as is and proceed to next. Might be replaced by a 0 later\r\n i += 1\r\n\r\n return input_list","def test_sort_sorted():\n sorted_data = [1, 2, 3, 4, 5]\n sorted_list = bubble_sort(sorted_data)\n\n for small, large in zip(sorted_list[:-1], sorted_list[1:]):\n assert small <= large","def insertionSort(list):","def test_bubblesort_on_long_list():\n from bubblesort import bubblesort\n unsorted_list = []\n for i in range(100):\n unsorted_list.append(random.randint(0, 1000))\n\n sorted_list = bubblesort(unsorted_list)\n\n assert sorted_list == sorted(unsorted_list)","def last2(x, y):\n y = np.asarray(y)\n return y[np.argsort(x)][-1]","def wiggleSort(self, nums: List[int]) -> None:\n newlist=sorted(nums)\n nums[::2]=newlist[:int(len(nums)/2)+len(nums)%2]\n nums[1::2]=newlist[int(len(nums)/2)+len(nums)%2:]","def sort(lst):\n n = len(lst)\n done = False\n round = n - 1\n while not done and round:\n done = True\n for i in range(round):\n if lst[i] > lst[i+1]:\n lst[i], lst[i+1] = lst[i+1], lst[i]\n done = False\n round -= 1","def bubble_sort(numbers):\n sorted_numbers = numbers.copy()\n swapped = True\n while swapped:\n swapped = False\n for i in range(1, len(sorted_numbers)):\n if sorted_numbers[i - 1] > sorted_numbers[i]:\n sorted_numbers[i], sorted_numbers[i - 1] = \\\n sorted_numbers[i - 1], sorted_numbers[i]\n swapped = True\n return sorted_numbers","def sort():\n return -1","def sortTuple(lstTuples, element):\n\n lstTuples.sort(key=lambda x: x[element-1])\n return lstTuples","def sort_012(input_list):\n # Initial two pointers to beginning and end\n # Start another pointer to traverse\n # if list[curr] == 0, then beg++, travel++\n # if list[curr] == 2, then swap with end, and end--, curr++\n # if list[curr] == 1, curr++\n \n # if list[end] == 2, then end-- (to optimize swaps)\n \n beg = curr = 0\n end = len(input_list) - 1\n while curr <= end:\n if input_list[curr] == 0:\n input_list[curr], input_list[beg] = \\\n input_list[beg], input_list[curr]\n beg += 1\n curr += 1\n elif input_list[curr] == 2:\n input_list[curr], input_list[end] = \\\n input_list[end], input_list[curr]\n end -= 1\n elif input_list[curr] == 1:\n curr += 1\n \n return input_list"],"string":"[\n \"def bubbleSort(list):\",\n \"def bubble_sort(list):\\n for i in range(1, len(list) - 1):\\n for j in range(len(list) - 1, i-1, -1):\\n if list[j - 1] > list[j]:\\n x = list[j]\\n list[j] = list[j - 1]\\n list[j - 1] = x\\n return list\",\n \"def bubbleSort(lst):\\n for i in range(len(lst)):\\n for j in range(len(lst)-i-1):\\n if lst[j]>lst[j+1]:\\n lst[j], lst[j+1], = lst[j+1], lst[j]\\n print(lst)\",\n \"def bubble_sort(L):\\n end = len(L)-1\\n\\n while end !=0:\\n for i in range(end):\\n if L[i] > L[i+1]:\\n L[i], L[i+1] = L[i+1], L[i]\\n \\n \\n end = end -1\",\n \"def bubble_sort(mylist):\\n sorted = False\\n while not sorted:\\n sorted = True\\n for i in range(1, len(mylist)):\\n if mylist[i - 1] > mylist[i]:\\n sorted = False\\n mylist[i - 1], mylist[i] = mylist[i], mylist[i - 1]\\n return mylist\",\n \"def bubble_sort(a_list):\\n for item in reversed(range(len(a_list))):\\n for i in range(item):\\n if a_list[i] > a_list[i + 1]:\\n a_list[i], a_list[i + 1] = a_list[i + 1], a_list[i]\\n return a_list\",\n \"def bubble_sort(input_list):\\n \\n length = len(input_list)\\n \\n for i in range(length):\\n for j in range(length-i-1):\\n if input_list[j] > input_list[j+1]:\\n input_list[j], input_list[j+1] = input_list[j+1], input_list[j]\\n \\n return input_list\",\n \"def bubbleSort( listToSort ):\\n for i in range( len(listToSort), 0, -1 ):\\n for j in range( 0, i-1 ):\\n if listToSort[j] > listToSort[j+1]:\\n tmp = listToSort[j]\\n listToSort[j] = listToSort[j+1]\\n listToSort[j+1] = tmp\",\n \"def bubble_sort(first):\\n # iterate len(lst) times\\n for i in range(len(first)):\\n\\n # integrate [len(lst) - i - 1] times\\n for j in range(len(first) - i - 1):\\n\\n # sort two number if not sorted\\n if first[j] > first[j + 1]:\\n # swap element at j with element at j + 1\\n # and element ad j + 1 with element j\\n first[j], first[j + 1] = first[j + 1], first[j]\",\n \"def bubble_sort(lst):\\n\\n def swap(i,j):\\n lst[i], lst[j] = lst[j], lst[i]\\n\\n n = 0\\n while n <= len(lst) - 1:\\n for i in range(len(lst)-1-n):\\n if lst[i] >= lst[i+1]:\\n swap(i,i+1)\\n n+=1\",\n \"def bubble_sort(lst: list) -> None:\\n n = len(lst)\\n if n == 0 or n == 1:\\n return\\n for boundary in range(n, 1, -1):\\n swapped = False\\n for i in range(1, boundary):\\n if lst[i - 1] > lst[i]:\\n swap(lst, i - 1, i)\\n swapped = True\\n if not swapped: # if list is now sorted\\n return\",\n \"def buble_sort(lst):\\n lst_sorted = copy.copy(lst)\\n for i in range(len(lst_sorted)):\\n for j in range(len(lst_sorted)):\\n if j == len(lst_sorted) - 1:\\n continue\\n if lst_sorted[j][1] > lst_sorted[j + 1][1]:\\n lst_sorted[j], lst_sorted[j+1] = lst_sorted[j+1], lst_sorted[j]\\n\\n return lst_sorted\",\n \"def bubble_sort(items):\\n for num in range(len(items)-1,0,-1):\\n for j in range(num):\\n if items[j]>items[j+1]:\\n temp = items[j]\\n items[j] = items[j+1]\\n items[j+1] = temp\\n return items\",\n \"def BubbleSort(ulist):\\n done = 0 #This variable is used to break the loop when sorting is done\\n while not done:\\n done = 1\\n for i in range(len(ulist) - 1):\\n if ulist[i] > ulist[i+1]:\\n ulist[i], ulist[i+1] = ulist[i+1], ulist[i]\\n done = 0\",\n \"def bubble_sort(integer_list):\\n for passnum in range(len(integer_list), 1, -1):\\n for i in range(passnum-1):\\n if integer_list[i] > integer_list[i+1]:\\n integer_list[i], integer_list[i+1] = integer_list[i+1], integer_list[i]\\n return integer_list\",\n \"def bubble_sort(arr):\\n temp = None\\n for x in range(0, len(arr)-1):\\n for y in range(0, len(arr)-1):\\n if arr[y] > arr[y+1]:\\n temp = arr[y]\\n arr[y] = arr[y+1]\\n arr[y+1] = temp \\n return arr\",\n \"def bubble_sort(arr: List[int]) -> List[int]:\\n sorted = False\\n while not sorted:\\n sorted = True\\n for i in range(1, len(arr)):\\n if arr[i-1] > arr[i]:\\n arr[i], arr[i-1] = arr[i-1], arr[i]\\n sorted = False\\n return arr\",\n \"def bubbleSort(list,i):\\n\\n if i == 1:\\n return list\\n\\n else:\\n for k in range(i - 1):\\n if list[k] > list[k+1]:\\n list[k], list[k+1] = list[k+1], list[k]\\n\\n bubbleSort(list,i-1)\",\n \"def bubble_sort(a):\\n for i in reversed(range(len(a))):\\n for j in range(1, i + 1):\\n if a[j-1] > a[j]:\\n a[j], a[j-1] = a[j-1], a[j]\\n return a\",\n \"def bubble_sort(a):\\n for i in reversed(range(len(a))):\\n for j in range(1, i + 1):\\n if a[j-1] > a[j]:\\n a[j], a[j-1] = a[j-1], a[j]\\n return a\",\n \"def buble_sort(l):\\r\\n for i in range(len(l)):\\r\\n for j in range(i+1, len(l)):\\r\\n if (l[j-1]>l[j]):\\r\\n l[j-1], l[j] = l[j], l[j-1]\",\n \"def bubble_sort(data):\\n the_list = list(data)\\n\\n length = len(the_list)\\n \\\"\\\"\\\" Iterate from the start to the back,\\n then go to back - 1 \\\"\\\"\\\"\\n while length >= 1:\\n innerloop(the_list)\\n length -= 1\\n\\n return the_list\",\n \"def improved_bubble_sort(data_list):\\n for passnum in range(len(data_list) - 1, 0, -1):\\n is_sorted = True\\n for idx in range(passnum):\\n if data_list[idx] > data_list[idx + 1]:\\n temp = data_list[idx]\\n data_list[idx] = data_list[idx + 1]\\n data_list[idx + 1] = temp\\n is_sorted = False\\n if is_sorted:\\n return\",\n \"def bubblesort(given_list):\\n completely_sorted = False\\n while not completely_sorted:\\n update_done = False\\n for i in range(1, len(given_list)):\\n previous = given_list[i-1]\\n if previous > given_list[i]:\\n given_list[i-1] = given_list[i]\\n given_list[i] = previous\\n update_done = True\\n if not update_done:\\n completely_sorted = True\\n return given_list\",\n \"def bubble_sort(items):\\n for i in range(len(items)):\\n for j in range(len(items) - 1 - i):\\n if items[j] > items[j + 1]:\\n items[j], items[j + 1] = items[j + 1], items[j]\\n return items\",\n \"def bubble_sort(data_list_or_tuple):\\n data_list = list(data_list_or_tuple)\\n for count, _ in enumerate(data_list, 1):\\n for x in range(len(data_list)-count):\\n if data_list[x] > data_list[x+1]:\\n data_list[x], data_list[x+1] = data_list[x+1], data_list[x]\\n return data_list\",\n \"def bubble_sort(arr:Sequence[List]) -> Sequence[List]:\\n n = len(arr)\\n for i in range(n-1):\\n for j in range(n-i-1):\\n if arr[j] > arr[j+1]:\\n arr[j], arr[j+1] = arr[j+1], arr[j]\\n return arr\",\n \"def bubble_sort(self, data):\\n for i in range(len(data)-1, 0, -1):\\n for j in range(i):\\n if data[j] > data[j+1]:\\n tmp = data[j]\\n data[j] = data[j+1]\\n data[j+1] = tmp\\n print \\\"pass\\\", i, data\",\n \"def bubblesort(lst_bubble):\\n n = len(lst_bubble)\\n cond = 0\\n assign = 0\\n for i in range(n):\\n for j in range(1,n-i):\\n cond +=1\\n if lst_bubble[j-1] > lst_bubble[j]:\\n lst_bubble[j],lst_bubble[j-1] = swap(lst_bubble[j],lst_bubble[j-1])\\n assign +=3\\n return (cond, assign)\",\n \"def bubble_sort(lst):\\n\\n swaps_made = 0\\n\\n for i in range(len(lst)):\\n made_swap = False\\n for j in range(len(lst)-1-i):\\n if lst[j] > lst[j+1]:\\n lst[j], lst[j+1] = lst[j+1], lst[j]\\n made_swap = True\\n swaps_made += 1\\n\\n if not made_swap:\\n break\\n\\n return lst #or can return # swaps made if that's what we're looing for\",\n \"def bubble_sort(itr):\\n arr = list(copy.copy(itr))\\n is_sorted = True\\n n = len(arr)\\n while n > 1:\\n for i in range(1, n):\\n if arr[i] < arr[i - 1]:\\n arr[i], arr[i - 1] = arr[i - 1], arr[i]\\n is_sorted = False\\n if is_sorted: break\\n is_sorted = True\\n n -= 1\\n return arr\",\n \"def mysort(lst: List[T], compare: Callable[[T, T], int]) -> List[T]:\\n for i in range(1, len(lst)): #loops through each element starting at the second one\\n for j in range(i, 0, -1): #loops through each element coming before i starting at i and going backwards\\n if compare(lst[j], lst[j-1]) < 0: #checks to see if the previous element is smaller than the current (by saying <0 we keep the sort stable as well)\\n lst[j], lst[j-1] = lst[j-1], lst[j] #if they are, we switch them\\n else:\\n break #if they are not, we know that the element is in its proper place\\n return lst\",\n \"def bubbleSort(sortList):\\r\\n \\r\\n for i in range(len(sortList)):\\r\\n for j in range(len(sortList)-1-i):\\r\\n if itemAmount[ sortList[j] ] > itemAmount[ sortList[j + 1] ]:\\r\\n sortList[j], sortList[j+1] = sortList[j+1], sortList[j]\",\n \"def short_bubble_sort(num_list):\\n exchange = True\\n passnum = len(num_list) - 1\\n\\n while passnum > 0 and exchange:\\n exchange = False\\n for i in range(passnum):\\n # Exchanges items\\n if num_list[i] > num_list[i + 1]:\\n temp = num_list[i]\\n num_list[i] = num_list[i + 1]\\n num_list[i + 1] = temp\\n exchange = True\\n passnum -= 1\",\n \"def bubble_sort(mylist):\\n n = len(mylist)\\n swapped = True\\n while swapped:\\n swapped = False\\n for i in range(1, n):\\n if mylist[i-1] > mylist[i]:\\n _swap(mylist, i-1, i)\\n swapped = True\\n n -= 1\",\n \"def bubble_sort(items):\\n for i in range(len(items)):\\n for j in range(len(items)-1-i):\\n if items[j] > items[j+1]:\\n items[j], items[j+1] = items[j+1], items[j] # Swap!\",\n \"def burbuja(lista:list):\\n vector = lista\\n for i in range(0, len(vector)-1):\\n for j in range(0, len(vector)-1):\\n if vector[j] > vector[j+1]:\\n tmp = vector[j+1]\\n vector[j+1] = vector[j]\\n vector[j] = tmp\\n return vector\",\n \"def bubble_sort(l):\\n # Raise value\\n if not isinstance(l, list):\\n raise TypeError(\\\"Not a list\\\")\\n \\n # Initialize variables to count\\n r = c = w = 0\\n lenL = len(l)\\n swapped = True \\n\\n # only if there isn't any swap will the loop stop \\n while swapped:\\n swapped = False \\n\\n for i in range(1, lenL):\\n r += 2\\n c += 1 \\n if l[i - 1] > l[i]:\\n # Swap the elements\\n l[i - 1], l[i] = l[i], l[i - 1]\\n w += 2\\n swapped = True # loop again \\n lenL -= 1 \\n \\n return c, r, w\",\n \"def sorting(my_list):\\n for indx in range(1,len(my_list)):\\n i=indx\\n while i>0:\\n if my_list[i]<my_list[i-1]:\\n temp=my_list[i-1]\\n my_list[i-1]=my_list[i]\\n my_list[i]=temp\\n i=i-1\\n return my_list\",\n \"def bubble_sort(alist):\\n potato = True\\n while potato:\\n potato = False\\n for idx in range(len(alist) - 1):\\n if alist[idx] > alist[idx + 1]:\\n temp = alist[idx]\\n alist[idx] = alist[idx + 1]\\n alist[idx + 1] = temp\\n potato = True\\n return alist\",\n \"def sort_2(l):\\n l.reverse()\",\n \"def bubble_sort(arr):\\n n = len(arr)\\n # Traverse through all array elements\\n for i in range(n):\\n # Last i elements are already in place\\n for j in range(0, n-i-1):\\n # traverse the array from 0 to n-i-1\\n # Swap if the element found is greater\\n # than the next element\\n if arr[j] > arr[j+1] :\\n arr[j], arr[j+1] = arr[j+1], arr[j]\\n return arr\",\n \"def short_bubble_sort(integer_list):\\n exchanged = True\\n for passnum in range(len(integer_list), 1, -1):\\n exchanged = False\\n for i in range(passnum-1):\\n if integer_list[i] > integer_list[i+1]:\\n exchanged = True\\n integer_list[i], integer_list[i+1] = integer_list[i+1], integer_list[i]\\n if not exchanged:\\n break\\n return integer_list\",\n \"def bubble_sort(data):\\n sorted_data = list(data)\\n\\n for i in range(len(sorted_data) - 1):\\n for j in range(len(sorted_data) - 1 - i):\\n if sorted_data[j] > sorted_data[j + 1]:\\n sorted_data[j], sorted_data[j + 1] =\\\\\\n sorted_data[j + 1], sorted_data[j]\\n return sorted_data\",\n \"def bubble_sort_smart(array: list):\\n size = len(array)\\n\\n for i in range(size):\\n for j in range(size - i - 1):\\n if array[j] > array[j + 1]:\\n aux = array[j]\\n array[j] = array[j + 1]\\n array[j + 1] = aux\\n #array[j], array[j + 1] = array[j + 1], array[j]\",\n \"def sorting_alg(self, my_list):\\n for i in range(len(my_list)):\\n for j in range(i+1, len(my_list)):\\n if my_list[i] > my_list[j]:\\n my_list[i], my_list[j] = my_list[j], my_list[i]\\n #print(my_list)\\n #sleep(1)\\n return my_list\",\n \"def bubblesort(a):\\n\\n while True:\\n swap = 0\\n for i in range(1,len(a)):\\n if a[i] < a[i-1]:\\n a[i], a[i-1] = a[i-1], a[i]\\n swap = 1\\n \\n if not swap:\\n break\",\n \"def wiggle_sort(nums):\\n\\n for i in range(len(nums)):\\n if (i % 2 == 1) == (nums[i - 1] > nums[i]):\\n nums[i - 1], nums[i] = nums[i], nums[i - 1]\",\n \"def bubble_sort(array: list):\\n size = len(array)\\n\\n for i in range(size):\\n for j in range(size - 1):\\n if array[j] > array[j + 1]:\\n aux = array[j]\\n array[j] = array[j + 1]\\n array[j + 1] = aux\\n #array[j], array[j + 1] = array[j + 1], array[j]\",\n \"def bubble_sort(items):\\n # TODO: Repeat until all items are in sorted order\\n # TODO: Swap adjacent items that are out of order\\n for x in range(len(items)-1):\\n if items[x]>items[x+1]:\\n temp = items[x]\\n items[x] = items[x+1]\\n items[x+1] = temp\",\n \"def test_sort_reversed():\\n sorted_data = [5, 4, 3, 2, 1]\\n sorted_list = bubble_sort(sorted_data)\\n\\n for small, large in zip(sorted_list[:-1], sorted_list[1:]):\\n assert small <= large\",\n \"def bubble_sort(array):\\n final_position = len(array) - 1\\n\\n while final_position > 0:\\n for index in range(final_position):\\n if array[index] > array[index + 1]:\\n array[index], array[index + 1] = array[index + 1], array[index]\\n\\n final_position -= 1\\n\\n return array\",\n \"def bubble_final_position(array):\\n swap_point = len(array)\\n while swap_point:\\n new_swap = 0\\n for i in range(1, swap_point):\\n if array[i-1] > array[i]:\\n array[i-1], array[i] = array[i], array[i-1]\\n new_swap = i\\n swap_point = new_swap\",\n \"def findSecondLargest(self):\\n l = []\\n self.flatten(l)\\n print(l)\\n print(l[-2])\",\n \"def bubble_sort(items):\\n # Repeat until all items are in sorted order\\n # Swap adjacent items that are out of order\\n # loop through list\\n # TODO: Running time: ??? Why and under what conditions?\\n # TODO: Memory usage: ??? Why and under what conditions?\\\"\\\"\\\"\\n while not is_sorted(items):\\n for i in range(len(items) - 1):\\n # Loop backwards avoiding the already sorted numbers\\n for j in range(len(items) - 1 - i):\\n # if left item is bigger than the right\\n if items[j] > items[j + 1]:\\n # Swap left and right \\n items[j], items[j + 1] = items[j + 1], items[j]\\n return items\",\n \"def test_bubblesort_sorts_list():\\n from bubblesort import bubblesort\\n unsorted_list = [6, 4, 7, 9, 0, 2]\\n assert bubblesort(unsorted_list) == [0, 2, 4, 6, 7, 9]\",\n \"def bubbleSort(unsortedValues: list) -> None:\\n \\n done: bool = False # initialize to false \\n sortedCount: int = 0\\n\\n while not done: \\n done = True\\n index: int = 0\\n\\n while index < len(unsortedValues) - 1 - sortedCount:\\n if unsortedValues[index] > unsortedValues[index + 1]:\\n swap(unsortedValues, index, index + 1)\\n done = False\\n index += 1\\n sortedCount += 1\",\n \"def innerloop(the_list):\\n for index in range(len(the_list)-1):\\n if the_list[index] > the_list[index+1]:\\n smaller = the_list[index+1]\\n bigger = the_list[index]\\n the_list[index] = smaller\\n the_list[index+1] = bigger\\n\\n return tuple(the_list)\",\n \"def bubble_sort(items):\\n out = items.copy() # in place protection on items\\n for i in range(len(out)):\\n for j in range(len(out)-1-i):\\n if out[j] > out[j+1]:\\n out[j], out[j+1] = out[j+1], out[j] # Swap!\\n\\n return out\",\n \"def bubble_sort(A: list):\\n N = len(A)\\n list_is_sorted = False\\n bypass = 1\\n while not list_is_sorted:\\n list_is_sorted = True\\n for k in range(N - bypass):\\n if A[k] > A[k+1]:\\n A[k], A[k+1] = A[k+1], A[k]\\n list_is_sorted = False\\n bypass += 1\",\n \"def bubble_sort(items):\\n # Repeat until all items are in sorted order\\n # Swap adjacent items that are out of order\\n current = 0\\n right = 1\\n while not is_sorted(items):\\n if current == len(items) - 1:\\n current = 0\\n right = 1\\n\\n elif items[current] > items[right]:\\n items[current], items[right] = items[right], items[current]\\n \\n else:\\n current += 1\\n right += 1\",\n \"def nth_largest2(a_list, n):\\n a_list.sort()\\n new_list = a_list[::-1]\\n return new_list[n-1]\",\n \"def bubble_sort_smarter(array: list):\\n size = len(array)\\n\\n while size > 0:\\n idx = 0\\n for j in range(size):\\n if array[j] > array[j + 1]:\\n aux = array[j]\\n array[j] = array[j + 1]\\n array[j + 1] = aux\\n #array[j], array[j + 1] = array[j + 1], array[j]\\n idx = j + 1\\n\\n size = idx\",\n \"def mysort(lst: List[T], compare: Callable[[T, T], int]) -> List[T]:\\n temp = lst\\n switched = True\\n while switched:\\n switched = False\\n for i in range(len(temp) - 1):\\n if compare(temp[i], temp[i + 1]) == 1:\\n temp[i], temp[i + 1] = temp[i + 1], temp[i]\\n switched = True\\n\\n return temp\",\n \"def reverse_sort(list_to_sort: List) -> List:\\n if len(list_to_sort) == 1:\\n return list_to_sort\\n list_to_sort = [e for e in list_to_sort] # to avoid sorting in place, comment this to change original list\\n for j in range(len(list_to_sort) - 2, -1, -1):\\n sorted_element = list_to_sort[j]\\n # print('sorted element:', sorted_element)\\n i = j + 1\\n while i < len(list_to_sort) and list_to_sort[i] > sorted_element:\\n list_to_sort[i - 1] = list_to_sort[i]\\n i += 1\\n list_to_sort[i - 1] = sorted_element\\n # print('list after insertion:', list_to_sort)\\n return list_to_sort\",\n \"def bubble_sort_modificado(a):\\n N = len(a)\\n n = 0\\n b = False\\n while (n != N) and (not b):\\n k = N - 1\\n b = True\\n while k != n:\\n if a[k-1] > a[k]:\\n b = False\\n a[k-1], a[k] = a[k], a[k-1]\\n k -= 1\\n n += 1\",\n \"def bubbleSort(sequence):\\n n = len(sequence)\\n # Perform n-1 bubble operations on the sequence\\n for i in range(n - 1):\\n # Bubble the largest item to the end.\\n for j in range(n - i - 1):\\n if sequence[j] > sequence[j+1]:\\n sequence[j], sequence[j+1] = sequence[j+1], sequence[j]\",\n \"def merge_sort(self, lst):\\r\\n [sorted_lst, number_of_inversions] = self.sort_and_get_number_of_inversions(lst)\\r\\n \\r\\n return sorted_lst\",\n \"def bubble_sort(dataset):\\n\\t# start with array length and decrement each time \\n\\tarrayLen = len(dataset)\\n\\tbubbleIndex = len(dataset) - 1\\n\\twhile bubbleIndex != 0:\\n\\t\\tarrayIndex = 0\\n\\t\\twhile arrayIndex < arrayLen - 1:\\n\\t\\t\\tthisVal = dataset[arrayIndex]\\n\\t\\t\\tnextVal = dataset[arrayIndex + 1]\\n\\t\\t\\tif thisVal > nextVal:\\n\\t\\t\\t\\tdataset[arrayIndex + 1] = thisVal\\n\\t\\t\\t\\tdataset[arrayIndex] = nextVal\\n\\t\\t\\tarrayIndex += 1\\n\\t\\tprint \\\"Current State:\\\", dataset\\n\\t\\tbubbleIndex -= 1\",\n \"def timsort(lst):\\n sublsts = []\\n\\n i = 0\\n while i < len(lst):\\n sublsts.append([lst[i]])\\n i += 1\\n\\n if i < len(lst) and lst[i] >= lst[i - 1]:\\n while i < len(lst) and lst[i] >= lst[i - 1]:\\n sublsts[-1].append(lst[i])\\n i += 1\\n elif i < len(lst):\\n while i < len(lst) and lst[i] < lst[i - 1]:\\n sublsts[-1].append(lst[i])\\n i += 1\\n\\n sublsts[-1] = sublsts[-1][::-1]\\n\\n return merge_many(*sublsts)\",\n \"def pizza_sort(lst):\\n length = len(lst)\\n def based_god_help_me(lst,index=0):\\n if index == length - 1:\\n return\\n greatest = index_largest(lst[index:]) + index\\n lst[greatest], lst[index] = lst[index], lst[greatest]\\n based_god_help_me(lst,index+1)\\n return based_god_help_me(lst)\",\n \"def bubble_sort(array):\\n\\tupdated = 1\\n\\tcounter = 0\\n\\n\\twhile(updated == 1):\\n\\t\\tupdated = 0\\n\\t\\t\\n\\t\\tfor i in range(len(array)-1-counter):\\n\\t\\t\\tif array[i] > array[i+1]:\\n\\t\\t\\t\\tarray[i],array[i+1] = array[i+1],array[i]\\n\\t\\t\\t\\tupdated = 1\\n\\t\\t\\n\\t\\tcounter += 1\\n\\n\\treturn array\",\n \"def isort(my_list):\\n comparision_count = 0\\n for index in range(len(my_list)-1):\\n # Picking for each Number\\n comparision_count = comparision_count + 1\\n if my_list[index+1] < my_list[index]:\\n # moving the element\\n my_list[index + 1], my_list[index] = my_list[index], my_list[index + 1]\\n newposition = index\\n\\n # Comparing the changed element with the already sorted list\\n for i in range(index,0,-1):\\n comparision_count = comparision_count + 1\\n if my_list[newposition-1] > my_list[i]:\\n # moving the element\\n my_list[i] , my_list[newposition-1] = my_list[newposition-1] , my_list[i]\\n newposition = i-1 # remembering the new position\\n else:\\n # Since it is a sorted list, breaking loop if condition fails atleast once\\n break\\n return (my_list , comparision_count)\",\n \"def gnomesort(self):\\n # nothing to do if we're empty or singleton\\n if len(self) < 2:\\n return\\n # start with second element, and always compare to the element before\\n current = self.first.next\\n while current is not None:\\n # thus current must have a .prev\\n # If this element is unsorted with the element before it, then\\n if current.prev and current.value < current.prev.value:\\n # swap this element with the element before it\\n # using insert_after and pop_before is an easy way to handle first/last identities\\n self.insert_after(current, self.pop_before(current))\\n # and then check the new previous-element.\\n else:\\n # advance to next node (or None if this is the last node in the list, in which case we terminate)\\n current = current.next\",\n \"def test_original_unchanged():\\n first_list = [28, 3, 4, 10, 8]\\n bubble_sort(first_list)\\n assert first_list == [28, 3, 4, 10, 8]\",\n \"def bubblesort(array):\\n j = len(array)\\n while j > 0:\\n swapped = False\\n for i in range(1, j):\\n if array[i-1] > array[i]:\\n array[i-1], array[i] = array[i], array[i-1]\\n swapped = True\\n j -= 1\\n if swapped == False:\\n return array\\n return array\",\n \"def touple_bubble_sort(data_touple, sort_by = 0):\\n for passnum in range(len(data_touple) - 1, 0, -1):\\n is_sorted = True\\n for idx in range(passnum):\\n if data_touple[idx][sort_by] > data_touple[idx + 1][sort_by]:\\n temp = data_touple[idx]\\n data_touple[idx] = data_touple[idx + 1]\\n data_touple[idx + 1] = temp\\n is_sorted = False\\n if is_sorted:\\n return\",\n \"def wiggleSort(self, nums: 'List[int]') -> 'None':\\n ns = sorted(nums)\\n N = len(ns)//2 + len(ns)%2\\n ns1, ns2 = ns[:N][::-1], ns[N:][::-1]\\n for i in range(len(ns)//2):\\n nums[i*2] = ns1[i]\\n nums[i*2+1] = ns2[i]\\n if len(ns) % 2 == 1:\\n nums[-1] = ns1[-1]\",\n \"def custom_sort(vector:list)->list:\\n if len(vector) <= 2:\\n return vector\\n\\n else:\\n mid = len(vector) // 2\\n vector.insert(1, vector.pop(mid))\\n i = 1\\n for idx in range(2, len(vector)-1, 2):\\n vector.insert(idx+1, vector.pop(mid+i))\\n i +=1\\n return vector\",\n \"def bubble_sort(A):\\n seguir = True\\n largo = len(A)\\n while seguir:\\n seguir = False\\n for i in xrange(largo - 1):\\n if A[i] > A[i+1]:\\n A[i], A[i+1] = A[i+1], A[i]\\n seguir = True\",\n \"def __sort(self, _list, _index, desc, pop_first_element=False):\\n if _index != 0:\\n _list = [(x[_index], x) for x in _list]\\n \\n _list.sort()\\n \\n if desc:\\n _list.reverse()\\n\\n if _index != 0 or pop_first_element: \\n _list = [x[1] for x in _list]\\n\\n return _list\",\n \"def wiggleSort(self, nums):\\n nums2=nums.copy()\\n nums2.sort()\\n n = len(nums)\\n if n%2:\\n midpoint = n//2\\n else:\\n midpoint = n//2-1\\n j=n-1\\n i=midpoint\\n point=0\\n while j > midpoint:\\n nums[point] = nums2[i]\\n nums[point+1] = nums2[j]\\n j-=1\\n i-=1\\n point+=2\\n if n%2:\\n nums[-1]=nums2[0]\\n print(nums)\",\n \"def test_sort_reversed():\\n reverse_sorted_data = [3, 2, 1]\\n sorted_data = bubble_sort(reverse_sorted_data)\\n assert sorted_data == [1, 2, 3]\",\n \"def sort_1(l):\\n pass\",\n \"def stooge_sort(arr):\\r\\n stooge(arr, 0, len(arr) - 1)\",\n \"def wiggleSort(self, nums: List[int]) -> None:\\n '''\\n ## nlogn\\n if len(nums)<=1:\\n return nums \\n nums.sort()\\n l = len(nums)\\n for i in range(1,l-1,2):\\n nums[i],nums[i+1] = nums[i+1],nums[i]\\n return nums\\n\\n '''\\n ## O(n)\\n l = len(nums)\\n for i in range(1, l):\\n if i % 2 == 1 and nums[i] < nums[i - 1]:\\n nums[i], nums[i - 1] = nums[i - 1], nums[i]\\n if i % 2 == 0 and nums[i] > nums[i - 1]:\\n nums[i], nums[i - 1] = nums[i - 1], nums[i]\",\n \"def test_sort_reversed():\\n assert bubble_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\",\n \"def wiggleSort3(self, nums) -> None:\\n # Sort the list, and swap adjacent element starting from the second element\\n nums.sort()\\n i = 1\\n while i < len(nums) - 1:\\n nums[i], nums[i+1] = nums[i+1], nums[i]\\n i += 2\",\n \"def bubble_sort(input_array):\\n for i in range(0, len(input_array)):\\n for j in range(0,len(input_array) - i - 1):\\n if input_array[j] > input_array[j+1]:\\n tmp = input_array[j]\\n input_array[j] = input_array[j+1]\\n input_array[j+1] = tmp\",\n \"def sort_012(input_list):\\r\\n \\r\\n # Positions 0's to the start of the array and 2's to the end.\\r\\n # All remaining are 1's.\\r\\n\\r\\n next_0_index = 0\\r\\n next_2_index = len(input_list) - 1\\r\\n\\r\\n i = 0\\r\\n \\r\\n # Traverse the array once.\\r\\n # Last index to be checked is next_2_index because it is \\r\\n # one position before the last placed 2.\\r\\n while i < next_2_index + 1:\\r\\n\\r\\n element = input_list[i]\\r\\n\\r\\n if element == 0:\\r\\n\\r\\n # Position at next_0_index and put that element in this 0's place\\r\\n input_list[i], input_list[next_0_index] = input_list[next_0_index], input_list[i]\\r\\n\\r\\n # next_0_index is now taken by a 0, next index is to its right\\r\\n next_0_index += 1\\r\\n\\r\\n # Increment to check next element. All from i and before are 0's\\r\\n i += 1\\r\\n\\r\\n if element == 2:\\r\\n \\r\\n # Position at next_2_index and put that element in this 2's place\\r\\n input_list[i], input_list[next_2_index] = input_list[next_2_index], input_list[i]\\r\\n \\r\\n # next_2_index is now taken by a 2, next index is to its left\\r\\n next_2_index -= 1\\r\\n \\r\\n if element == 1:\\r\\n\\r\\n # Leave as is and proceed to next. Might be replaced by a 0 later\\r\\n i += 1\\r\\n\\r\\n return input_list\",\n \"def test_sort_sorted():\\n sorted_data = [1, 2, 3, 4, 5]\\n sorted_list = bubble_sort(sorted_data)\\n\\n for small, large in zip(sorted_list[:-1], sorted_list[1:]):\\n assert small <= large\",\n \"def insertionSort(list):\",\n \"def test_bubblesort_on_long_list():\\n from bubblesort import bubblesort\\n unsorted_list = []\\n for i in range(100):\\n unsorted_list.append(random.randint(0, 1000))\\n\\n sorted_list = bubblesort(unsorted_list)\\n\\n assert sorted_list == sorted(unsorted_list)\",\n \"def last2(x, y):\\n y = np.asarray(y)\\n return y[np.argsort(x)][-1]\",\n \"def wiggleSort(self, nums: List[int]) -> None:\\n newlist=sorted(nums)\\n nums[::2]=newlist[:int(len(nums)/2)+len(nums)%2]\\n nums[1::2]=newlist[int(len(nums)/2)+len(nums)%2:]\",\n \"def sort(lst):\\n n = len(lst)\\n done = False\\n round = n - 1\\n while not done and round:\\n done = True\\n for i in range(round):\\n if lst[i] > lst[i+1]:\\n lst[i], lst[i+1] = lst[i+1], lst[i]\\n done = False\\n round -= 1\",\n \"def bubble_sort(numbers):\\n sorted_numbers = numbers.copy()\\n swapped = True\\n while swapped:\\n swapped = False\\n for i in range(1, len(sorted_numbers)):\\n if sorted_numbers[i - 1] > sorted_numbers[i]:\\n sorted_numbers[i], sorted_numbers[i - 1] = \\\\\\n sorted_numbers[i - 1], sorted_numbers[i]\\n swapped = True\\n return sorted_numbers\",\n \"def sort():\\n return -1\",\n \"def sortTuple(lstTuples, element):\\n\\n lstTuples.sort(key=lambda x: x[element-1])\\n return lstTuples\",\n \"def sort_012(input_list):\\n # Initial two pointers to beginning and end\\n # Start another pointer to traverse\\n # if list[curr] == 0, then beg++, travel++\\n # if list[curr] == 2, then swap with end, and end--, curr++\\n # if list[curr] == 1, curr++\\n \\n # if list[end] == 2, then end-- (to optimize swaps)\\n \\n beg = curr = 0\\n end = len(input_list) - 1\\n while curr <= end:\\n if input_list[curr] == 0:\\n input_list[curr], input_list[beg] = \\\\\\n input_list[beg], input_list[curr]\\n beg += 1\\n curr += 1\\n elif input_list[curr] == 2:\\n input_list[curr], input_list[end] = \\\\\\n input_list[end], input_list[curr]\\n end -= 1\\n elif input_list[curr] == 1:\\n curr += 1\\n \\n return input_list\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77857566","0.7745999","0.75933444","0.7433549","0.7385789","0.73774844","0.736563","0.7351545","0.73503095","0.73399705","0.7298297","0.7254225","0.7216236","0.7211703","0.7194435","0.7183924","0.71444356","0.71343726","0.7121137","0.7121137","0.71004987","0.70888084","0.7075632","0.70584345","0.7051523","0.7033102","0.70131016","0.69986415","0.69961786","0.69758344","0.69719064","0.6957651","0.69523275","0.6946385","0.69355404","0.691562","0.68937033","0.6891742","0.6864843","0.6852178","0.68309","0.6828028","0.6823788","0.68164074","0.67677045","0.67579424","0.6709796","0.6707329","0.6705577","0.6697157","0.6682835","0.6635967","0.6630977","0.66185045","0.6610023","0.65530664","0.65514266","0.6543614","0.65413857","0.6525408","0.65174145","0.65145844","0.65063107","0.6497544","0.6493397","0.6468949","0.6467729","0.6425155","0.6421218","0.6406594","0.63877666","0.6387507","0.6377164","0.6375021","0.637373","0.6349991","0.63423204","0.6341364","0.63139856","0.6312119","0.6309676","0.63070756","0.6306077","0.6305633","0.6302087","0.62954754","0.6289454","0.6287294","0.6283412","0.62779325","0.627536","0.6266298","0.62655157","0.6253299","0.6248905","0.62126064","0.6202781","0.61989224","0.6180999","0.61748856"],"string":"[\n \"0.77857566\",\n \"0.7745999\",\n \"0.75933444\",\n \"0.7433549\",\n \"0.7385789\",\n \"0.73774844\",\n \"0.736563\",\n \"0.7351545\",\n \"0.73503095\",\n \"0.73399705\",\n \"0.7298297\",\n \"0.7254225\",\n \"0.7216236\",\n \"0.7211703\",\n \"0.7194435\",\n \"0.7183924\",\n \"0.71444356\",\n \"0.71343726\",\n \"0.7121137\",\n \"0.7121137\",\n \"0.71004987\",\n \"0.70888084\",\n \"0.7075632\",\n \"0.70584345\",\n \"0.7051523\",\n \"0.7033102\",\n \"0.70131016\",\n \"0.69986415\",\n \"0.69961786\",\n \"0.69758344\",\n \"0.69719064\",\n \"0.6957651\",\n \"0.69523275\",\n \"0.6946385\",\n \"0.69355404\",\n \"0.691562\",\n \"0.68937033\",\n \"0.6891742\",\n \"0.6864843\",\n \"0.6852178\",\n \"0.68309\",\n \"0.6828028\",\n \"0.6823788\",\n \"0.68164074\",\n \"0.67677045\",\n \"0.67579424\",\n \"0.6709796\",\n \"0.6707329\",\n \"0.6705577\",\n \"0.6697157\",\n \"0.6682835\",\n \"0.6635967\",\n \"0.6630977\",\n \"0.66185045\",\n \"0.6610023\",\n \"0.65530664\",\n \"0.65514266\",\n \"0.6543614\",\n \"0.65413857\",\n \"0.6525408\",\n \"0.65174145\",\n \"0.65145844\",\n \"0.65063107\",\n \"0.6497544\",\n \"0.6493397\",\n \"0.6468949\",\n \"0.6467729\",\n \"0.6425155\",\n \"0.6421218\",\n \"0.6406594\",\n \"0.63877666\",\n \"0.6387507\",\n \"0.6377164\",\n \"0.6375021\",\n \"0.637373\",\n \"0.6349991\",\n \"0.63423204\",\n \"0.6341364\",\n \"0.63139856\",\n \"0.6312119\",\n \"0.6309676\",\n \"0.63070756\",\n \"0.6306077\",\n \"0.6305633\",\n \"0.6302087\",\n \"0.62954754\",\n \"0.6289454\",\n \"0.6287294\",\n \"0.6283412\",\n \"0.62779325\",\n \"0.627536\",\n \"0.6266298\",\n \"0.62655157\",\n \"0.6253299\",\n \"0.6248905\",\n \"0.62126064\",\n \"0.6202781\",\n \"0.61989224\",\n \"0.6180999\",\n \"0.61748856\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6551871"},"document_rank":{"kind":"string","value":"56"}}},{"rowIdx":5493,"cells":{"query":{"kind":"string","value":"slick solution in python ONLY zeros = [0 for i in range(zeros_and_ones.count(0))] ones = [1 for j in range(zeros_and_ones.count(1))] return zeros + ones"},"document":{"kind":"string","value":"def zeros_before_ones(zeros_and_ones):\n index_i = 0\n last_index = len(zeros_and_ones) - 1\n\n while index_i < last_index:\n if zeros_and_ones[index_i] == 1 and zeros_and_ones[last_index] == 0:\n zeros_and_ones[index_i], zeros_and_ones[last_index] = zeros_and_ones[last_index], zeros_and_ones[index_i]\n index_i += 1\n last_index -= 1\n # print(zeros_and_ones)\n # TODO: NEEDS IMPROVEMENTS! zeros_and_ones"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def solution2(n):\n ones = 0\n while n > 0:\n if n & 1:\n ones += 1\n n = n >> 1\n\n return 0 if ones % 2 == 0 else 1","def c(ixs):\n return sum(range(1, sum((i > 0 for i in ixs)) + 1))","def _iter_restrict(self, zeros, ones):\n inputs = list(self.inputs)\n unmapped = {}\n for i, v in enumerate(self.inputs):\n if v in zeros:\n inputs[i] = 0\n elif v in ones:\n inputs[i] = 1\n else:\n unmapped[v] = i\n vs = sorted(unmapped.keys())\n for num in range(1 << len(vs)):\n for v, val in boolfunc.num2point(num, vs).items():\n inputs[unmapped[v]] = val\n yield sum((val << i) for i, val in enumerate(inputs))","def addOnes(x,m):\n n = x.size/m\n one = np.ones((m,1))\n x = x.reshape((m,n))\n judge = np.sum(x[:,0] == one.flatten())\n if judge != m:\n x = np.hstack((one,x))\n return x","def zero_to_ones(L):\n return [-1 if val == 0 else 1 for val in L]","def matOnes(shape):\n return [[1 for y in range(shape[1])] \\\n for x in range(shape[0])]","def count_ones(n):\n s = 0\n mask = 1\n for i in xrange(16):\n if (mask << i) & n:\n s += 1\n return s","def rzeros(nums):\n total = len(nums)\n zeros = 0\n nozeros = []\n for x in nums:\n if x != 0:\n nozeros.append(x) \n else:\n zeros = zeros + 1\n \n return (nozeros, total - zeros, zeros)","def fn(i, j, mask):\n if j == n: return 1 \n if i == m: return fn(0, j+1, mask)\n ans = 0 \n for x in 1<<2*i, 1<<2*i+1, 0b11<<2*i: \n mask0 = mask ^ x\n if mask0 & 0b11<<2*i and (i == 0 or (mask0 >> 2*i) & 0b11 != (mask0 >> 2*i-2) & 0b11): \n ans += fn(i+1, j, mask0)\n return ans % 1_000_000_007","def _one_pass(nums):\n pattern = [0, 1, 0, -1]\n return [\n int(str(sum(\n v * pattern[(i // n) % len(pattern)]\n for i, v in enumerate(nums, start=1)\n ))[-1])\n for n in range(1, len(nums) + 1)\n ]","def zeros(s, zero=0):\n\treturn [zeros(s[1:] ) for i in range(s[0] ) ] if not len(s) else zero","def zeros(n):\n return [0 for i in range(n)]","def single_number(nums: List[int]) -> int:\n ones = 0\n twos = 0\n\n for num in nums:\n # Record number that appears twice.\n twos |= (ones & num)\n\n # Record number that appears once.\n ones ^= num\n\n # Remove number that is on ones and twos.\n common_bit_mask = ~(ones & twos)\n ones &= common_bit_mask\n twos &= common_bit_mask\n return ones","def ones(dice):\n return sum([x for x in dice if x == 1])","def solution2(array):\n if not array:\n return\n\n n_rows = len(array)\n n_cols = len(array[0])\n\n # Since we are using first row and column as space to mark rows and columns to be zeroed,\n # first check whether they have any zeros or not\n first_row_zero = False\n first_column_zero = False\n \n for c in range(n_cols):\n if not array[0][c]:\n first_row_zero=True\n \n for r in range(n_rows):\n if not array[r][0]:\n first_column_zero = True\n\n # Now start from 1,1 and check for 0. If 0 is found in certain row and column, mark first row\n # and column\n for r in range(1, n_rows):\n for c in range(1, n_cols):\n if not array[r][c]:\n array[0][c] = 0\n array[r][0] = 0\n\n # Now iterate through entire matrix again starting from 1,1 and set element to zero if \n # first row or column for that element is zero\n for r in range(1, n_rows):\n for c in range(1, n_cols):\n if array[0][c]==0 or array[r][0]==0:\n array[r][c] = 0\n\n # Go back to the first row and column.\n if first_row_zero:\n for c in range(n_cols):\n array[0][c] = 0\n if first_column_zero:\n for r in range(n_rows):\n array[r][0] = 0\n\n return array","def solution(A):\n \n cars = 0\n ones = 0\n\n for i in range(len(A), 0, -1):\n\n if A[i-1] == 1:\n ones += 1\n else:\n cars += ones\n\n return (-1 if cars > 1000000000 else cars)","def _make_zero(p):\n\n return [pi == 0 for pi in p]","def solve_ok(number: int) -> int:\n return no_ones(number) % 2","def solution(num):\n \n res = [0] * (num + 1)\n for i in range(1,len(res)):\n res[i] = res[i>>1] + (i%2)\n \n return res","def duplicateZeros(self, arr: List[int]) -> None:\n zero = 0\n i = 0\n while i + zero < len(arr):\n if arr[i] == 0:\n zero += 1\n i += 1\n \n if i + zero > len(arr):\n arr[-1] = 0\n i -= 1\n zero -= 1\n \n i -= 1\n j = i + zero\n while j >= 0:\n if arr[i]:\n arr[j] = arr[i]\n else:\n arr[j] = 0\n j -= 1\n arr[j] = 0\n j -= 1\n i -= 1","def ones(cls):\n return super().ones(4, 4)","def test_count_binary_decisions(self):\n abs_centered_quantized_data_0 = numpy.array([0.75, 0.05, 0.1, 0.2, 0.2, 0.15], dtype=numpy.float32)\n bin_width_test_0 = 0.05\n abs_centered_quantized_data_1 = numpy.array([210., 6., 9., 6.], dtype=numpy.float32)\n bin_width_test_1 = 3.\n truncated_unary_prefix = 7\n \n (cumulated_zeros_0, cumulated_ones_0) = \\\n lossless.stats.count_binary_decisions(abs_centered_quantized_data_0,\n bin_width_test_0,\n truncated_unary_prefix)\n (cumulated_zeros_1, cumulated_ones_1) = \\\n lossless.stats.count_binary_decisions(abs_centered_quantized_data_1,\n bin_width_test_1,\n truncated_unary_prefix)\n print('1st experiment:')\n print('Number of occurrences of 0 for each binary decision computed by the function:')\n print(cumulated_zeros_0)\n print('Number of occurrences of 0 for each binary decision computed by hand:')\n print(numpy.array([0, 1, 1, 1, 2, 0, 0]))\n print('Number of occurrences of 1 for each binary decision computed by the function:')\n print(cumulated_ones_0)\n print('Number of occurrences of 1 for each binary decision computed by hand:')\n print(numpy.array([6, 5, 4, 3, 1, 1, 1]))\n print('\\n2nd experiment:')\n print('Number of occurrences of 0 for each binary decision computed by the function:')\n print(cumulated_zeros_1)\n print('Number of occurrences of 0 for each binary decision computed by hand:')\n print(numpy.array([0, 0, 2, 1, 0, 0, 0]))\n print('Number of occurrences of 1 for each binary decision computed by the function:')\n print(cumulated_ones_1)\n print('Number of occurrences of 1 for each binary decision computed by hand:')\n print(numpy.array([4, 4, 2, 1, 1, 1, 1]))","def fn(mask, k):\n if not mask: return 0 \n ans = inf \n for i in range(n): \n if mask & (1<<i): \n ans = min(ans, (nums1[i]^nums2[k]) + fn(mask^(1<<i), k+1))\n return ans","def majority_logical(*bit_arrays):\n\n if (len(bit_arrays) == 0):\n raise TypeError(\"len(bit_arrays) must be > 0.\")\n\n MINIMUM_MAJORITY = (len(bit_arrays) // 2) + 1\n\n answer = itertools.combinations(bit_arrays, MINIMUM_MAJORITY)\n answer = map(all, answer)\n answer = any(answer)\n return answer","def bool_both_zero_compute(juduged_min, juduged_max):\n dtype = juduged_min.dtype\n tensor_zero = topi.full(juduged_min.shape, dtype, dc.zero_const(dtype))\n min_abs = topi.abs(juduged_min)\n max_abs = topi.abs(juduged_max)\n min_max_replace = topi.add(min_abs, max_abs)\n # just check wether min and max are all zero, if true return 0\n bool_min_max_product_less_zero = less_compare_float32(min_max_replace, tensor_zero)\n bool_min_max_product_more_zero = less_compare_float32(tensor_zero, min_max_replace)\n bool_both_zero = topi.add(bool_min_max_product_less_zero, bool_min_max_product_more_zero)\n\n return bool_both_zero","def onequbit_modes(statemat):\n nqubit = int(np.log2(statemat.shape[0]))\n rep = np.array(list(itertools.product((0, 1), repeat=nqubit)))\n inds = [i for i, x in enumerate(np.sum(rep, 1)) if x==1]\n \n instates = np.around(statemat[:, inds], 3)\n\n outstates = np.zeros((len(inds), len(inds)), dtype=complex)\n #print(inds)\n for ii in range(len(inds)):\n shortstate = np.around(instates[sum(instates[:,ii].nonzero()), ii], 3).todense()\n outstates[:, ii] = np.squeeze( np.array( shortstate ) )\n \n return outstates","def duplicateZeros(self, arr: List[int]) -> None:\n i = 0\n j = 0\n n = len(arr)\n while i < n:\n if arr[i] == 0:\n j += 1\n i += 1\n j += 1\n i -= 1\n j -= 1\n while i >= 0:\n if j < n:\n arr[j] = arr[i]\n if arr[i] == 0:\n j -= 1\n if j < n:\n arr[j] = 0\n i -= 1\n j -= 1","def moveZeroes(self, nums: List[int]) -> None:\n count = 0\n ans = []\n for num in nums:\n if num != 0:\n ans.append(num)\n else:\n count += 1\n for zero in range(count):\n ans.append(0)\n return ans","def map_zero_one(x, a, b):\n assert b > a\n s = 1./(b - a)\n t = a/(a-b)\n y = s*x + t\n y[y>1] = 1\n y[y<0] = 0\n return y","def ones(cls):\n return super().ones(3, 3)","def andbits(num1,num2):\n thingstoadd=[]\n for i in range(31):\n bit1=setbit(num1,i)\n bit2=setbit(num2,i)\n bit1=shiftleft(bit1,30 - i)\n bit2=shiftleft(bit2,30 - i)\n bitsum=add(bit1,bit2)\n bitsum=setbit(bitsum,31)\n bitsum=shiftright(bitsum,31 - i)\n thingstoadd.append(bitsum)\n bit1=setbit(num1,31)\n bit2=setbit(num2,31)\n bit1=shiftright(bit1,1)\n bit2=shiftright(bit2,1)\n bitsum=add(bit1,bit2)\n bitsum=setbit(bitsum,31)\n thingstoadd.append(bitsum)\n return sum(thingstoadd)","def compareones_c(w1,w2,tn):\n nw1 = np.int_(np.copy(w1))\n nw2 = np.int_(np.copy(w2))\n code = \"\"\"\n int s;\n s = 0;\n for(int i = 0; i < n; i++)\n {\n if((nw1[i] == 1)&(nw2[i] == 1))\n {\n s += 100;\n }\n }\n return_val = s;\n \"\"\"\n n = len(w2)\n res = inline(code, ['nw1','nw2','n'], headers = ['<math.h>'], compiler = 'gcc')\n return res / float(tn)","def eqcounter(nodes):\r\n nnodes = nodes.shape[0]\r\n IBC = np.zeros([nnodes, 3], dtype=np.integer)\r\n for i in range(nnodes):\r\n for k in range(3):\r\n IBC[i, k] = int(nodes[i, k+3])\r\n neq = 0\r\n for i in range(nnodes):\r\n for j in range(3):\r\n if IBC[i, j] == 0:\r\n IBC[i, j] = neq\r\n neq = neq + 1\r\n return neq, IBC","def setZeroes(self, matrix: List[List[int]]) -> None:\r\n \r\n rows, cols = len(matrix), len(matrix[0])\r\n \r\n #This solution has been done in constant space\r\n #using first row and first column for deciding which rows and columns\r\n #should be zero\r\n \r\n #using one extra variable for first row\r\n #because first cell is common in first row and column\r\n first_row = 1\r\n \r\n for i in range(rows):\r\n for j in range(cols):\r\n if matrix[i][j]==0:\r\n #for column\r\n matrix[0][j] = 0\r\n \r\n #for row\r\n if i==0:\r\n first_row = 0\r\n else:\r\n matrix[i][0] = 0\r\n \r\n #checking for rows except first row\r\n for i in range(1,rows):\r\n if matrix[i][0] == 0:\r\n for j in range(cols):\r\n matrix[i][j] = 0\r\n \r\n #checking for columns except first column\r\n for j in range(1, cols):\r\n if matrix[0][j] == 0:\r\n for i in range(rows):\r\n matrix[i][j] = 0\r\n \r\n #for first column\r\n if matrix[0][0] == 0:\r\n for i in range(rows):\r\n matrix[i][0] = 0\r\n \r\n #for first row\r\n if first_row == 0:\r\n for j in range(cols):\r\n matrix[0][j] = 0\r\n \r\n #print(matrix)","def one(x):\n return zero(x) + 1","def duplicateZeros(self, arr: List[int]) -> None:\n zeros = arr.count(0)\n for i in reversed(range(len(arr))): \n if i + zeros < len(arr): \n arr[i+zeros] = arr[i]\n if arr[i] == 0: \n zeros -= 1\n if i + zeros < len(arr): \n arr[i+zeros] = arr[i]","def singles(counts):\n return (counts==1).sum()","def ones(num):\n if num < 1:\n raise IndexError('num must be >= 1.')\n return Vector.fromSequence([1] * num)","def single_number(nums):\n tmp = 0\n for num in nums:\n tmp ^= num\n marker = 1\n while marker & tmp != marker:\n marker <<= 1\n a = 0\n for num in nums:\n if marker & num:\n a ^= num\n b = tmp ^ a\n return [a, b]","def ones(n, offset=0):\n\n if (n == float('inf')):\n return -1\n\n return ((1 << n) - 1) << offset","def moveZeroes(self, nums: List[int]) -> None:\n # Treating the corner case first:\n if len(nums) == 0 or len(nums) == 1:\n return\n # Treating the general cases...\n counter = 0\n for i in range(0, len(nums)):\n if nums[i] == 0:\n counter += 1\n left = 0\n right = 0\n while right < len(nums):\n if nums[left] == 0 and nums[right] == 0:\n right += 1\n elif nums[left] == 0 and nums[right] != 0:\n nums[left] = nums[right]\n left += 1\n right += 1\n elif nums[left] != 0 and nums[right] == 0:\n right += 1\n else:\n nums[left] = nums[right]\n left += 1\n right += 1\n i = -1\n while counter > 0:\n nums[i] = 0\n counter -=1\n i -= 1\n return","def fn(vals):\n total = odd = 0 \n for i, x in enumerate(vals): \n if vals[0] == x: \n total += 1\n if i&1: odd += 1\n elif vals[0] ^ x != (1 << n) - 1: return inf\n ans = inf \n if len(vals) <= 2*total <= len(vals)+1: ans = min(ans, odd)\n if len(vals)-1 <= 2*total <= len(vals): ans = min(ans, total - odd)\n return ans","def moveZeroes1(self, nums: List[int]) -> None:\n count = 0 \n for i in range(len(nums)-1) :\n i = i - count\n if nums[i] == 0 :\n count += 1\n nums.pop(i)\n \n nums.extend([0]*count)","def zeros_like(self):\n raise NotImplementedError","def set_zero(mn_matrix): \r\n \r\n row_flag = [0]*len(mn_matrix)\r\n column_flag = [0]*len(mn_matrix[0])\r\n for i in range(0, len(row_flag)):\r\n for j in range(0, len(column_flag)):\r\n if mn_matrix[i][j] == 0:\r\n row_flag[i] = 1\r\n column_flag[j] = 1\r\n \r\n for i in range(0, len(row_flag)):\r\n for j in range(0, len(column_flag)):\r\n if row_flag[i] == 1 or column_flag[j] == 1: \r\n mn_matrix[i][j] = 0","def solution(array):\n rows = array.shape[0]\n cols = array.shape[1]\n result = np.ones((rows,cols))\n result[1:rows-1,1:cols-1] = 0\n return result","def setZeroes(matrix):\r\n \r\n #An average O(n^2) time traversal solution with memoization\r\n #for each 0 we encounter, we update the entire row and column to 0s, but on the condition that the row/column has not been updated yet\r\n \r\n row_cache = {}\r\n column_cache = {}\r\n \r\n for r in range(0,rows := len(matrix)):\r\n for c in range(0,cols := len(matrix[0])):\r\n \r\n if matrix[r][c] == 0:\r\n \r\n if not row_cache.get(r):\r\n for i in range(0,cols):\r\n if matrix[r][i] != 0:\r\n matrix[r][i] = '0' #we use strings so we only consider the initial 0s\r\n row_cache[r] = True\r\n \r\n if not column_cache.get(c):\r\n for i in range(0,rows):\r\n if matrix[i][c] != 0:\r\n matrix[i][c] = '0'\r\n column_cache[c] = True\r\n return","def solve(given: np.array) -> np.array:\n possible = np.full((9, 9, 9), True)\n mask = given > 0\n possible[mask, :] = False\n possible[mask, given[mask] - 1] = True\n\n # number of possibilities at each site, masking those already propagated\n # to avoid repetitive work. All masked == problem solved\n count = ma.array(possible.sum(axis=2), fill_value=1)\n\n # allocate upfront to as out parameter to np.equal\n # (ma.array because count is ma.array)\n where = ma.array(np.empty((9, 9), dtype=bool), fill_value=False)\n\n stack = [(possible, count)]\n while stack:\n node, count = stack.pop()\n unsolved = propagate(node, count, where)\n if unsolved == -1:\n continue\n if unsolved == 0:\n break\n # try all possibilities from cell with fewest > 1\n i, j = np.unravel_index(count.argmin(), count.shape)\n for k in np.flatnonzero(node[i, j, :]):\n node_copy, count_copy = node.copy(), count.copy()\n node_copy[i, j, :] = False\n node_copy[i, j, k] = True\n count_copy[i, j] = 1\n stack.append((node_copy, count_copy))\n\n i, j, k = node.nonzero()\n count[i, j] = k + 1\n return np.array(count)","def _get_masks(n_input, n_hiddens, switched_dependencies=False):\n masks = []\n units = [n_input] + n_hiddens + [n_input]\n for layer in range(len(units)-1):\n n_in = units[layer]\n n_out = units[layer+1]\n\n mask = np.ones((n_in, n_out)) if not switched_dependencies else np.zeros((n_in, n_out))\n diagonalzeros = True if layer == len(units)-2 else False\n\n assert n_in % n_out == 0 or n_out % n_in == 0\n if n_out >= n_in:\n k = int(n_out / n_in)\n for i in range(n_in):\n mask[i, :i * k] = 0 if not switched_dependencies else 1\n if diagonalzeros and not switched_dependencies:\n mask[i, i * k:(i + 1) * k] = 0\n if not diagonalzeros and switched_dependencies:\n mask[i, i * k:(i + 1) * k] = 1\n else:\n k = int(n_in / n_out)\n for i in range(n_out):\n mask[(i + 1) * k:, i] = 0 if not switched_dependencies else 1\n if diagonalzeros and not switched_dependencies:\n mask[i * k:(i + 1) * k, i] = 0\n if not diagonalzeros and switched_dependencies:\n mask[i * k:(i + 1) * k, i] = 1\n\n masks.append(mask.astype(np.float32))\n\n return masks","def ones():\n return Vec2d(1, 1)","def possibilities(board):\n return board[np.where(board == 0)]","def duplicateZeros(self, arr: List[int]) -> None:\n \n n = len(arr)\n z = 0\n \n # Decide final point\n for left in range(n):\n if left > n - 1 - z:\n break\n \n if arr[left] == 0:\n if left == n - 1 - z:\n arr[-1] = 0\n n = n - 1\n break\n z += 1\n \n \n # in-place process\n idx = n - 1\n while idx > 0:\n if arr[idx - z] == 0:\n arr[idx], arr[idx - 1] = 0, 0\n z -= 1\n idx -= 1\n else:\n arr[idx] = arr[idx - z]\n idx -= 1","def fn(i):\n if i == 2*n-1 or ans[i] and fn(i+1): return True \n for x in reversed(range(1, n+1)): \n if x not in ans: \n ii = x if x > 1 else 0 \n if i+ii < 2*n-1 and ans[i] == ans[i+ii] == 0: \n ans[i] = ans[i+ii] = x\n if fn(i+1): return True \n ans[i] = ans[i+ii] = 0","def threesumzero(a):\n result = set() # set to eliminate deuplicates!\n a.sort() # sort it\n n = len(a) # number of items in a\n for x in a: # for each element in a, see if its part of some triplet\n target_sum = 0 - x # x and other two items must sum to 0, so other two must sum to -x\n i = 0 # from beginning\n j = n - 1 # from end\n while i < j:\n if a[i] + a[j] == target_sum: # we found triplet\n result.add( tuple( sorted( [x, a[i], a[j] ] ) ) ) # sort it (for uniqueness) and convert it to tuple as its immutable\n i += 1\n j -= 1\n elif a[i] + a[j] > target_sum:\n j -= 1\n else: # a[i] + a[j] < target_sum\n i += 1\n\n return result","def _pattern01(width):\n zeroes = core.Constant(0, width)\n return operation.Concat(zeroes, ~zeroes)","def fn(x, mask):\n ans = size = 0 \n for xx in range(1, 10): \n if not mask & (1 << xx): \n if (x, xx) not in mp or mask & 1 << mp[x, xx]: \n ans += fn(xx, mask^(1<<xx))\n size += 1\n size = 9 - size\n if m <= size <= n: ans += 1\n return ans","def offspring_fertility(n1=4,n2=4):\n ary = np.zeros( (n1,n2, n1,n2, 3), float )\n for i in range(n1):\n for j in range(n2):\n for k in range(n1):\n for l in range(n2):\n # set group counter to zero (one counter is sufficient)\n gc1 = 0\n for index in [i,j,k,l]: \n if index in [0,1]: gc1+=1\n if gc1==0 or gc1==4:\n ary[i,j,k,l,0] = 1. # set mark at S0\n elif gc1==1 or gc1==3:\n ary[i,j,k,l,2] = 1. # set mark at S2\n else:\n ary[i,j,k,l,1] = 1. # set mark at S1\n return ary","def fn(mask, j):\n ans = 0 \n for i in range(m): \n if not mask & (1<<i): \n ans = max(ans, fn(mask^(1<<i), j-1) + score[i][j])\n return ans","def solution(n: int) -> int:\n binary_gap = 0\n count = 0\n # skip the lowest zeros\n while n and (n & 1) == 0:\n n = n >> 1\n while n:\n while n & 1:\n n = n >> 1\n while n and (n & 1) == 0:\n count += 1\n n = n >> 1\n if n & 1 and binary_gap < count:\n binary_gap = count\n count = 0\n return binary_gap","def majority_bitwise(*bit_arrays):\n\n if (len(bit_arrays) == 0):\n raise TypeError(\"len(bit_arrays) must be > 0.\")\n\n MINIMUM_MAJORITY = (len(bit_arrays) // 2) + 1\n\n answer = 0\n for bit_array_subset in \\\n itertools.combinations(bit_arrays, MINIMUM_MAJORITY):\n answer |= functools.reduce(operator.and_, bit_array_subset)\n\n return answer","def moveZeroes(self, nums: List[int]) -> None:\n i = 0\n while i != len(nums) and nums[i]:\n i += 1\n j = i\n while j != len(nums):\n if not nums[j]:\n j += 1\n else:\n nums[i] = nums[j]\n i += 1\n j += 1\n while i != len(nums):\n nums[i] = 0\n i += 1","def moveZeroes(self, nums: List[int]) -> None:\n i = j = 0\n\n n = len(nums)\n while True:\n while i < n and nums[i]:\n i += 1\n j = max(i, j) + 1\n while j < n and not nums[j]:\n j += 1\n # i points the first zero\n # j points the first non-zero after i\n # between [i, j) are zeros\n if i == n or j == n:\n break\n self.swap(nums, i, j)","def gen_all_holds(hand):\n without_repeat = []\n mask_seque = list(gen_all_sequences([0,1], len(hand)))\n for dum_i in mask_seque:\n without_repeat.append(())\n \n for dum_i in range(len(mask_seque)):\n for dum_j in range(len(mask_seque[dum_i])):\n if (mask_seque[dum_i][dum_j]==1):\n without_repeat[dum_i]=list(without_repeat[dum_i])\n without_repeat[dum_i].append(hand[dum_j])\n without_repeat[dum_i]=tuple(without_repeat[dum_i])\n \n without_repeat = set(tuple(without_repeat))\n return without_repeat","def matZeros(shape):\n return [[0 for y in range(shape[1])] \\\n for x in range(shape[0])]","def moveZeroes(self, nums: List[int]) -> None:\n i = j = 0\n N = len(nums)\n while j < N:\n while j < N and nums[j] == 0:\n j += 1\n if j >= N:\n break\n nums[i] = nums[j]\n i += 1\n j += 1\n while i < N:\n nums[i] = 0\n i += 1","def solution(A):\n xor = 0\n for item in A:\n xor ^= item\n return xor","def new_binomial_prefactor(s,l1,l2,PAx,PBx):\n with loops.Scope() as L:\n L.total = 0.\n L.t = 0\n for _ in L.while_range(lambda: L.t < s + 1):\n #TEMP TODO rewrite this. The cond_range causes a huge overhead.\n # Try Valeev implementation\n for _ in L.cond_range(((s - l1) <= L.t) & (L.t <= l2)):\n L.total += binomials[l1,s-L.t] * binomials[l2,L.t] * PAx[l1-s + L.t] * PBx[l2 - L.t]\n L.t += 1\n return L.total","def test_jaccard_index_all_zeros_compiled():\n vector1 = np.array([0, 0, 0, 0])\n vector2 = np.array([1, 1, 1, 1])\n score11 = jaccard_index(vector1, vector1)\n score12 = jaccard_index(vector1, vector2)\n score22 = jaccard_index(vector2, vector2)\n\n assert score11 == score12 == 0.0, \"Expected different score.\"\n assert score22 == 1.0, \"Expected different score.\"","def reduce_bits(nums):\n num1, num2 = nums\n result = \"\"\n for index, bit in enumerate(num1):\n result += bit if bit == num2[index] else '-'\n return Term(result)","def zeroes(m, n):\n\n return [[0] * n for i in range(m)]","def solution(xs):\n if len(xs)==1:\n return str(xs[0])\n count_neg = 0\n count_pos = 0\n count_zero = 0\n prod_pos = 1\n prod_neg = 1\n max_neg = -float(\"inf\")\n for x in xs:\n if x ==0:\n count_zero+=1\n elif x < 0:\n pos_or_neg = True\n count_neg+=1\n prod_neg *= x\n max_neg = max(max_neg,x)\n elif x > 0:\n count_pos+=1\n pos_or_neg = True\n prod_pos *= x\n if (count_pos == 0 and count_neg == 0) or (count_zero > 0 and count_neg == 1 and count_pos == 0):\n return str(0)\n if count_neg%2!=0:\n count_neg-=1\n prod_neg //=max_neg\n \n if not (count_pos == 0 and count_neg == 0):\n return str(prod_neg*prod_pos)\n return str(0)","def check(self, i, j):\n possible=np.ones((10), np.int)\n for k in range(0, 9):\n if k==j: continue\n possible[self.a[i][k]]=0\n\n for k in range(0, 9):\n if k==i: continue\n possible[self.a[k][j]]=0\n for a1 in range(0, 3):\n for b1 in range(0, 3):\n if (i//3)*3+a1==i and (j//3)*3+b1==j:\n continue\n possible[self.a[(i//3)*3+a1][(j//3)*3+b1]]=0\n return possible","def zero_comb(num_list):\n return {tuple(sorted(n)) for n in combinations(num_list, 3) if sum(n) == 0}","def create(matrix):\n limit_y = len(matrix)\n limit_x = len(matrix[0])\n\n for y in range(1, limit_y):\n bit.create(matrix[y])\n\n for x in range(1, limit_x):\n for y in range(1, limit_y):\n k = y + (y & -y)\n if k < limit_y:\n matrix[k][x] += matrix[y][x]","def fn(i, s0, s1, c0, c1):\n if s0 > n or s1 > n: return 0 # impossible \n if i == len(balls): return int(c0 == c1)\n ans = 0 \n for x in range(balls[i]+1): \n ans += fn(i+1, s0+x, s1+balls[i]-x, c0+(x > 0), c1+(x < balls[i])) * comb(balls[i], x)\n return ans","def duplicateZeros(self, arr) -> None:\n tmp = list()\n for i,v in enumerate(arr):\n if v==0:\n tmp.append(0)\n tmp.append(0)\n else:\n tmp.append(v)\n\n arr[i] = tmp[i]","def onehot(isTrue):\n if isTrue:\n return [1, 0]\n else:\n return [0, 1]","def get_sum_zero_pairs(numbers):\n numbers = set(numbers)\n numbers = list(numbers)\n pairs_that_add_to_zero = []\n\n for i, item in enumerate(numbers):\n if numbers[i] == len(numbers):\n break\n\n if numbers[i] == 0:\n pairs_that_add_to_zero.append([0, 0]) \n\n for j in range(i+1, len(numbers)):\n total_of_two_items = numbers[i] + numbers[j]\n if (total_of_two_items == 0):\n pairs_that_add_to_zero.append([numbers[i], numbers[j]]) \n\n return pairs_that_add_to_zero","def same_bits_up(x):\n\n bit_array = get_first(x, get_consecutive_01)\n\n if (bit_array == 0):\n return x\n\n lower, upper = split_bits_bit_array(x, bit_array)\n upper = swap_bits_bit_array(upper, bit_array)\n lower = shift_trailing_zeros(lower)\n\n return upper | lower","def update_gol(arr):\n nxt = np.zeros(arr.shape)\n rows,cols = nxt.shape\n for i in range(rows):\n for j in range(cols):\n nn = sum_vonneuman_nn(arr,i,j)\n if arr[i][j]==1:\n if nn==2 or nn==3:\n nxt[i][j]=1\n else:\n if nn==3:\n nxt[i][j]=1\n return nxt","def setZeroes(self, matrix: List[List[int]]) -> None:\n if not matrix:\n return\n row = set()\n col = set()\n rowl = len(matrix[0])\n for i, r in enumerate(matrix):\n for j, c in enumerate(r):\n if c == 0:\n row.add(i)\n col.add(j)\n \n for r in row:\n matrix[r] = [0]*rowl\n for j in col:\n for i in range(len(matrix)):\n matrix[i][j] = 0","def moveZeroes(self, nums: List[int]) -> None:\n zeros=0\n for i in range(len(nums)):\n if nums[i]==0:\n zeros+=1\n else:\n nums[i-zeros]=nums[i]\n for i in range(len(nums)-zeros,len(nums)):\n nums[i]=0","def setZeroes(self, matrix: List[List[int]]) -> None:\n m = len(matrix)\n n = len(matrix[0])\n \n row_1st_0 = False\n col_1st_0 = False\n \n ## check whether 1st row and 1st col contains 0\n for i in range(n):\n if matrix[0][i] == 0:\n row_1st_0 = True\n break\n for j in range(m):\n if matrix[j][0] == 0:\n col_1st_0 = True\n break\n \n ## check row 1:m and col 1:n, store the 0 indicator to 1st row and 1st col\n for i in range(1, m):\n for j in range(1, n):\n if matrix[i][j] == 0:\n matrix[i][0] = 0\n matrix[0][j] = 0\n \n ## update cols to zero except 1st row\n for i in range(1, n):\n if matrix[0][i] == 0:\n for r in range(1, m):\n matrix[r][i] = 0\n \n ## update rows to zero except 1st col\n for j in range(1, m):\n if matrix[j][0] == 0:\n matrix[j][1:n] = [0 for i in range(n-1)]\n \n ## update 1st row and 1st col to 0\n if row_1st_0:\n matrix[0][0:n] = [0 for i in range(n)]\n if col_1st_0:\n for r in range(m):\n matrix[r][0] = 0","def subsequent_mask(lens):\n bs, max_len = len(lens), max(lens)\n mask = torch.ones([bs, max_len, max_len]).tril_(0)\n mask = mask > 0\n return mask","def TwoComp(n):\n\n l = list(n)\n for i in range(len(l)):\n l[i] = \"0\" if l[i] == \"1\" else \"1\"\n return BitAdd(\"\".join(l), \"1\", len(l))","def measure_all_1(n, state):\n state = state.copy()\n\n outs = ''\n for i in range(n):\n out = measure_single(n, state,\n i) # After measuring bit0, bit0 collapses. It affects the subsequent bit1 measurement, but does not affect the 1000 independent measurements of the upper layer\n outs = str(out) + outs # from low bit to high bit\n return outs","def binary_add(x, y):\n # Makes sure that the arrays have the same length.\n # Could be changed to padding on extra zeroes, if so desired.\n assert(len(x) == len(y))\n\n z = [0] * (len(x)+1)\n for a, (i, j) in enumerate(zip(x[::-1], y[::-1])):\n # Makes sure that the array is a binary array.\n # Strictly speaking, not necessary. But nice.\n if i not in [0, 1]: return False\n if j not in [0, 1]: return False\n\n # if i and j are both 1 \n if i and j:\n z[a] += 0\n z[a+1] += 1\n # if only one of them is 1\n elif i or j:\n z[a] += 1\n # if they're both 0\n else: pass\n\n if z[a] == 2:\n z[a+1] += 1\n z[a] -= 2\n \n return z[::-1]","def moveZeroes(self, nums: List[int]) -> None:\n ##brute force\n # counts= nums.count(0)\n # while 0 in nums: nums.remove(0)\n # nums+=[0]*counts\n \n ## two pointer (swapping)\n if not nums: return None\n anchor, explore= 0, 0\n while explore <len(nums):\n if nums[explore]!=0 and explore!=anchor:\n temp= nums[anchor]\n nums[anchor]=nums[explore]\n nums[explore]=temp\n if nums[anchor]!= 0:\n anchor+=1\n explore+=1","def _get_possible_outcomes(m, bits):\n\n # This is filled with loads of dirty binary tricks...You have been warned\n\n size = max(m.shape) # Max of shape to account for bra or ket\n nqubits = int(math.log(size, 2) + .1) # Number of qubits possible\n\n # Make the output states and put in output_matrices, nothing in them now.\n # Each state will represent a possible outcome of the measurement\n # Thus, output_matrices[0] is the matrix which we get when all measured\n # bits return 0. and output_matrices[1] is the matrix for only the 0th\n # bit being true\n output_matrices = []\n for i in range(1 << len(bits)):\n output_matrices.append(zeros(2**nqubits, 1))\n\n # Bitmasks will help sort how to determine possible outcomes.\n # When the bit mask is and-ed with a matrix-index,\n # it will determine which state that index belongs to\n bit_masks = []\n for bit in bits:\n bit_masks.append(1 << bit)\n\n # Make possible outcome states\n for i in range(2**nqubits):\n trueness = 0 # This tells us to which output_matrix this value belongs\n # Find trueness\n for j in range(len(bit_masks)):\n if i & bit_masks[j]:\n trueness += j + 1\n # Put the value in the correct output matrix\n output_matrices[trueness][i] = m[i]\n return output_matrices","def moveZeroes(self, nums: List[int]) -> None:\n N = len(nums)\n l = 0\n r = 0\n while r < N:\n if nums[l] == 0 and nums[r] != 0:\n nums[l], nums[r] = nums[r], nums[l]\n l += 1\n elif nums[r] == 0:\n r += 1\n else:\n l += 1\n r += 1","def move_zeros(items: list) -> Iterable[int]:\n return [x for x in items if x != 0] + [x for x in items if x == 0]","def invert_zero_one(sequence):\n return [1 - code for code in sequence]","def _make_masks(ilens, olens):\n # (B, T_in)\n in_masks = make_non_pad_mask(ilens)\n # (B, T_out)\n out_masks = make_non_pad_mask(olens)\n # (B, T_out, T_in)\n\n return paddle.logical_and(\n out_masks.unsqueeze(-1), in_masks.unsqueeze(-2))","def fn(i, j, mv):\n if not (0 <= i < m and 0 <= j < n): return 1 \n if mv == 0: return 0\n return (fn(i-1, j, mv-1) + fn(i, j-1, mv-1) + fn(i, j+1, mv-1) + fn(i+1, j, mv-1)) % 1_000_000_007","def moveZeroes(self, nums: List[int]) -> None:\n n = len(nums)\n i, j = 0, 0\n # i记录最靠前的0的位置\n # j记录从i开始第一个非0的位置\n while j < n:\n while i < n-1 and nums[i] != 0:\n i += 1\n j = i + 1\n while j < n and nums[j] == 0:\n j += 1\n if j > n-1:\n break\n nums[i], nums[j] = nums[j], nums[i]\n\n i += 1","def moveZeroes(self, nums: List[int]) -> None:\n try:\n j = nums.index(0)\n except ValueError:\n return\n nums_len = len(nums)\n i = j + 1\n while i < nums_len and nums[i] == 0:\n i += 1\n\n while i < nums_len:\n nums[j] = nums[i]\n nums[i] = 0\n j += 1\n while i < nums_len and nums[i] == 0:\n i += 1","def triplets():\n for a in xrange(1, 1000):\n for b in xrange(a, 1000):\n c = 1000 - (a + b)\n if a**2 + b**2 == c**2:\n return a, b, c","def setZeroes(self, matrix: List[List[int]]) -> None:\n \n m = len(matrix)\n n = len(matrix[0])\n \n i_zeros = []\n j_zeros = []\n \n for i in range(m): ## find the zeros\n for j in range(n):\n \n if matrix[i][j] == 0:\n i_zeros.append(i)\n j_zeros.append(j)\n \n for i in i_zeros:\n matrix[i] = [0]*n\n \n for j in j_zeros:\n for i in range(m):\n matrix[i][j] = 0","def solution(data):\n\t\tif data:\n\t\t\treturn 1\n\t\telse:\n\t\t\treturn 0","def osd(counts):\n return (counts!=0).sum(), (counts==1).sum(), (counts==2).sum()"],"string":"[\n \"def solution2(n):\\n ones = 0\\n while n > 0:\\n if n & 1:\\n ones += 1\\n n = n >> 1\\n\\n return 0 if ones % 2 == 0 else 1\",\n \"def c(ixs):\\n return sum(range(1, sum((i > 0 for i in ixs)) + 1))\",\n \"def _iter_restrict(self, zeros, ones):\\n inputs = list(self.inputs)\\n unmapped = {}\\n for i, v in enumerate(self.inputs):\\n if v in zeros:\\n inputs[i] = 0\\n elif v in ones:\\n inputs[i] = 1\\n else:\\n unmapped[v] = i\\n vs = sorted(unmapped.keys())\\n for num in range(1 << len(vs)):\\n for v, val in boolfunc.num2point(num, vs).items():\\n inputs[unmapped[v]] = val\\n yield sum((val << i) for i, val in enumerate(inputs))\",\n \"def addOnes(x,m):\\n n = x.size/m\\n one = np.ones((m,1))\\n x = x.reshape((m,n))\\n judge = np.sum(x[:,0] == one.flatten())\\n if judge != m:\\n x = np.hstack((one,x))\\n return x\",\n \"def zero_to_ones(L):\\n return [-1 if val == 0 else 1 for val in L]\",\n \"def matOnes(shape):\\n return [[1 for y in range(shape[1])] \\\\\\n for x in range(shape[0])]\",\n \"def count_ones(n):\\n s = 0\\n mask = 1\\n for i in xrange(16):\\n if (mask << i) & n:\\n s += 1\\n return s\",\n \"def rzeros(nums):\\n total = len(nums)\\n zeros = 0\\n nozeros = []\\n for x in nums:\\n if x != 0:\\n nozeros.append(x) \\n else:\\n zeros = zeros + 1\\n \\n return (nozeros, total - zeros, zeros)\",\n \"def fn(i, j, mask):\\n if j == n: return 1 \\n if i == m: return fn(0, j+1, mask)\\n ans = 0 \\n for x in 1<<2*i, 1<<2*i+1, 0b11<<2*i: \\n mask0 = mask ^ x\\n if mask0 & 0b11<<2*i and (i == 0 or (mask0 >> 2*i) & 0b11 != (mask0 >> 2*i-2) & 0b11): \\n ans += fn(i+1, j, mask0)\\n return ans % 1_000_000_007\",\n \"def _one_pass(nums):\\n pattern = [0, 1, 0, -1]\\n return [\\n int(str(sum(\\n v * pattern[(i // n) % len(pattern)]\\n for i, v in enumerate(nums, start=1)\\n ))[-1])\\n for n in range(1, len(nums) + 1)\\n ]\",\n \"def zeros(s, zero=0):\\n\\treturn [zeros(s[1:] ) for i in range(s[0] ) ] if not len(s) else zero\",\n \"def zeros(n):\\n return [0 for i in range(n)]\",\n \"def single_number(nums: List[int]) -> int:\\n ones = 0\\n twos = 0\\n\\n for num in nums:\\n # Record number that appears twice.\\n twos |= (ones & num)\\n\\n # Record number that appears once.\\n ones ^= num\\n\\n # Remove number that is on ones and twos.\\n common_bit_mask = ~(ones & twos)\\n ones &= common_bit_mask\\n twos &= common_bit_mask\\n return ones\",\n \"def ones(dice):\\n return sum([x for x in dice if x == 1])\",\n \"def solution2(array):\\n if not array:\\n return\\n\\n n_rows = len(array)\\n n_cols = len(array[0])\\n\\n # Since we are using first row and column as space to mark rows and columns to be zeroed,\\n # first check whether they have any zeros or not\\n first_row_zero = False\\n first_column_zero = False\\n \\n for c in range(n_cols):\\n if not array[0][c]:\\n first_row_zero=True\\n \\n for r in range(n_rows):\\n if not array[r][0]:\\n first_column_zero = True\\n\\n # Now start from 1,1 and check for 0. If 0 is found in certain row and column, mark first row\\n # and column\\n for r in range(1, n_rows):\\n for c in range(1, n_cols):\\n if not array[r][c]:\\n array[0][c] = 0\\n array[r][0] = 0\\n\\n # Now iterate through entire matrix again starting from 1,1 and set element to zero if \\n # first row or column for that element is zero\\n for r in range(1, n_rows):\\n for c in range(1, n_cols):\\n if array[0][c]==0 or array[r][0]==0:\\n array[r][c] = 0\\n\\n # Go back to the first row and column.\\n if first_row_zero:\\n for c in range(n_cols):\\n array[0][c] = 0\\n if first_column_zero:\\n for r in range(n_rows):\\n array[r][0] = 0\\n\\n return array\",\n \"def solution(A):\\n \\n cars = 0\\n ones = 0\\n\\n for i in range(len(A), 0, -1):\\n\\n if A[i-1] == 1:\\n ones += 1\\n else:\\n cars += ones\\n\\n return (-1 if cars > 1000000000 else cars)\",\n \"def _make_zero(p):\\n\\n return [pi == 0 for pi in p]\",\n \"def solve_ok(number: int) -> int:\\n return no_ones(number) % 2\",\n \"def solution(num):\\n \\n res = [0] * (num + 1)\\n for i in range(1,len(res)):\\n res[i] = res[i>>1] + (i%2)\\n \\n return res\",\n \"def duplicateZeros(self, arr: List[int]) -> None:\\n zero = 0\\n i = 0\\n while i + zero < len(arr):\\n if arr[i] == 0:\\n zero += 1\\n i += 1\\n \\n if i + zero > len(arr):\\n arr[-1] = 0\\n i -= 1\\n zero -= 1\\n \\n i -= 1\\n j = i + zero\\n while j >= 0:\\n if arr[i]:\\n arr[j] = arr[i]\\n else:\\n arr[j] = 0\\n j -= 1\\n arr[j] = 0\\n j -= 1\\n i -= 1\",\n \"def ones(cls):\\n return super().ones(4, 4)\",\n \"def test_count_binary_decisions(self):\\n abs_centered_quantized_data_0 = numpy.array([0.75, 0.05, 0.1, 0.2, 0.2, 0.15], dtype=numpy.float32)\\n bin_width_test_0 = 0.05\\n abs_centered_quantized_data_1 = numpy.array([210., 6., 9., 6.], dtype=numpy.float32)\\n bin_width_test_1 = 3.\\n truncated_unary_prefix = 7\\n \\n (cumulated_zeros_0, cumulated_ones_0) = \\\\\\n lossless.stats.count_binary_decisions(abs_centered_quantized_data_0,\\n bin_width_test_0,\\n truncated_unary_prefix)\\n (cumulated_zeros_1, cumulated_ones_1) = \\\\\\n lossless.stats.count_binary_decisions(abs_centered_quantized_data_1,\\n bin_width_test_1,\\n truncated_unary_prefix)\\n print('1st experiment:')\\n print('Number of occurrences of 0 for each binary decision computed by the function:')\\n print(cumulated_zeros_0)\\n print('Number of occurrences of 0 for each binary decision computed by hand:')\\n print(numpy.array([0, 1, 1, 1, 2, 0, 0]))\\n print('Number of occurrences of 1 for each binary decision computed by the function:')\\n print(cumulated_ones_0)\\n print('Number of occurrences of 1 for each binary decision computed by hand:')\\n print(numpy.array([6, 5, 4, 3, 1, 1, 1]))\\n print('\\\\n2nd experiment:')\\n print('Number of occurrences of 0 for each binary decision computed by the function:')\\n print(cumulated_zeros_1)\\n print('Number of occurrences of 0 for each binary decision computed by hand:')\\n print(numpy.array([0, 0, 2, 1, 0, 0, 0]))\\n print('Number of occurrences of 1 for each binary decision computed by the function:')\\n print(cumulated_ones_1)\\n print('Number of occurrences of 1 for each binary decision computed by hand:')\\n print(numpy.array([4, 4, 2, 1, 1, 1, 1]))\",\n \"def fn(mask, k):\\n if not mask: return 0 \\n ans = inf \\n for i in range(n): \\n if mask & (1<<i): \\n ans = min(ans, (nums1[i]^nums2[k]) + fn(mask^(1<<i), k+1))\\n return ans\",\n \"def majority_logical(*bit_arrays):\\n\\n if (len(bit_arrays) == 0):\\n raise TypeError(\\\"len(bit_arrays) must be > 0.\\\")\\n\\n MINIMUM_MAJORITY = (len(bit_arrays) // 2) + 1\\n\\n answer = itertools.combinations(bit_arrays, MINIMUM_MAJORITY)\\n answer = map(all, answer)\\n answer = any(answer)\\n return answer\",\n \"def bool_both_zero_compute(juduged_min, juduged_max):\\n dtype = juduged_min.dtype\\n tensor_zero = topi.full(juduged_min.shape, dtype, dc.zero_const(dtype))\\n min_abs = topi.abs(juduged_min)\\n max_abs = topi.abs(juduged_max)\\n min_max_replace = topi.add(min_abs, max_abs)\\n # just check wether min and max are all zero, if true return 0\\n bool_min_max_product_less_zero = less_compare_float32(min_max_replace, tensor_zero)\\n bool_min_max_product_more_zero = less_compare_float32(tensor_zero, min_max_replace)\\n bool_both_zero = topi.add(bool_min_max_product_less_zero, bool_min_max_product_more_zero)\\n\\n return bool_both_zero\",\n \"def onequbit_modes(statemat):\\n nqubit = int(np.log2(statemat.shape[0]))\\n rep = np.array(list(itertools.product((0, 1), repeat=nqubit)))\\n inds = [i for i, x in enumerate(np.sum(rep, 1)) if x==1]\\n \\n instates = np.around(statemat[:, inds], 3)\\n\\n outstates = np.zeros((len(inds), len(inds)), dtype=complex)\\n #print(inds)\\n for ii in range(len(inds)):\\n shortstate = np.around(instates[sum(instates[:,ii].nonzero()), ii], 3).todense()\\n outstates[:, ii] = np.squeeze( np.array( shortstate ) )\\n \\n return outstates\",\n \"def duplicateZeros(self, arr: List[int]) -> None:\\n i = 0\\n j = 0\\n n = len(arr)\\n while i < n:\\n if arr[i] == 0:\\n j += 1\\n i += 1\\n j += 1\\n i -= 1\\n j -= 1\\n while i >= 0:\\n if j < n:\\n arr[j] = arr[i]\\n if arr[i] == 0:\\n j -= 1\\n if j < n:\\n arr[j] = 0\\n i -= 1\\n j -= 1\",\n \"def moveZeroes(self, nums: List[int]) -> None:\\n count = 0\\n ans = []\\n for num in nums:\\n if num != 0:\\n ans.append(num)\\n else:\\n count += 1\\n for zero in range(count):\\n ans.append(0)\\n return ans\",\n \"def map_zero_one(x, a, b):\\n assert b > a\\n s = 1./(b - a)\\n t = a/(a-b)\\n y = s*x + t\\n y[y>1] = 1\\n y[y<0] = 0\\n return y\",\n \"def ones(cls):\\n return super().ones(3, 3)\",\n \"def andbits(num1,num2):\\n thingstoadd=[]\\n for i in range(31):\\n bit1=setbit(num1,i)\\n bit2=setbit(num2,i)\\n bit1=shiftleft(bit1,30 - i)\\n bit2=shiftleft(bit2,30 - i)\\n bitsum=add(bit1,bit2)\\n bitsum=setbit(bitsum,31)\\n bitsum=shiftright(bitsum,31 - i)\\n thingstoadd.append(bitsum)\\n bit1=setbit(num1,31)\\n bit2=setbit(num2,31)\\n bit1=shiftright(bit1,1)\\n bit2=shiftright(bit2,1)\\n bitsum=add(bit1,bit2)\\n bitsum=setbit(bitsum,31)\\n thingstoadd.append(bitsum)\\n return sum(thingstoadd)\",\n \"def compareones_c(w1,w2,tn):\\n nw1 = np.int_(np.copy(w1))\\n nw2 = np.int_(np.copy(w2))\\n code = \\\"\\\"\\\"\\n int s;\\n s = 0;\\n for(int i = 0; i < n; i++)\\n {\\n if((nw1[i] == 1)&(nw2[i] == 1))\\n {\\n s += 100;\\n }\\n }\\n return_val = s;\\n \\\"\\\"\\\"\\n n = len(w2)\\n res = inline(code, ['nw1','nw2','n'], headers = ['<math.h>'], compiler = 'gcc')\\n return res / float(tn)\",\n \"def eqcounter(nodes):\\r\\n nnodes = nodes.shape[0]\\r\\n IBC = np.zeros([nnodes, 3], dtype=np.integer)\\r\\n for i in range(nnodes):\\r\\n for k in range(3):\\r\\n IBC[i, k] = int(nodes[i, k+3])\\r\\n neq = 0\\r\\n for i in range(nnodes):\\r\\n for j in range(3):\\r\\n if IBC[i, j] == 0:\\r\\n IBC[i, j] = neq\\r\\n neq = neq + 1\\r\\n return neq, IBC\",\n \"def setZeroes(self, matrix: List[List[int]]) -> None:\\r\\n \\r\\n rows, cols = len(matrix), len(matrix[0])\\r\\n \\r\\n #This solution has been done in constant space\\r\\n #using first row and first column for deciding which rows and columns\\r\\n #should be zero\\r\\n \\r\\n #using one extra variable for first row\\r\\n #because first cell is common in first row and column\\r\\n first_row = 1\\r\\n \\r\\n for i in range(rows):\\r\\n for j in range(cols):\\r\\n if matrix[i][j]==0:\\r\\n #for column\\r\\n matrix[0][j] = 0\\r\\n \\r\\n #for row\\r\\n if i==0:\\r\\n first_row = 0\\r\\n else:\\r\\n matrix[i][0] = 0\\r\\n \\r\\n #checking for rows except first row\\r\\n for i in range(1,rows):\\r\\n if matrix[i][0] == 0:\\r\\n for j in range(cols):\\r\\n matrix[i][j] = 0\\r\\n \\r\\n #checking for columns except first column\\r\\n for j in range(1, cols):\\r\\n if matrix[0][j] == 0:\\r\\n for i in range(rows):\\r\\n matrix[i][j] = 0\\r\\n \\r\\n #for first column\\r\\n if matrix[0][0] == 0:\\r\\n for i in range(rows):\\r\\n matrix[i][0] = 0\\r\\n \\r\\n #for first row\\r\\n if first_row == 0:\\r\\n for j in range(cols):\\r\\n matrix[0][j] = 0\\r\\n \\r\\n #print(matrix)\",\n \"def one(x):\\n return zero(x) + 1\",\n \"def duplicateZeros(self, arr: List[int]) -> None:\\n zeros = arr.count(0)\\n for i in reversed(range(len(arr))): \\n if i + zeros < len(arr): \\n arr[i+zeros] = arr[i]\\n if arr[i] == 0: \\n zeros -= 1\\n if i + zeros < len(arr): \\n arr[i+zeros] = arr[i]\",\n \"def singles(counts):\\n return (counts==1).sum()\",\n \"def ones(num):\\n if num < 1:\\n raise IndexError('num must be >= 1.')\\n return Vector.fromSequence([1] * num)\",\n \"def single_number(nums):\\n tmp = 0\\n for num in nums:\\n tmp ^= num\\n marker = 1\\n while marker & tmp != marker:\\n marker <<= 1\\n a = 0\\n for num in nums:\\n if marker & num:\\n a ^= num\\n b = tmp ^ a\\n return [a, b]\",\n \"def ones(n, offset=0):\\n\\n if (n == float('inf')):\\n return -1\\n\\n return ((1 << n) - 1) << offset\",\n \"def moveZeroes(self, nums: List[int]) -> None:\\n # Treating the corner case first:\\n if len(nums) == 0 or len(nums) == 1:\\n return\\n # Treating the general cases...\\n counter = 0\\n for i in range(0, len(nums)):\\n if nums[i] == 0:\\n counter += 1\\n left = 0\\n right = 0\\n while right < len(nums):\\n if nums[left] == 0 and nums[right] == 0:\\n right += 1\\n elif nums[left] == 0 and nums[right] != 0:\\n nums[left] = nums[right]\\n left += 1\\n right += 1\\n elif nums[left] != 0 and nums[right] == 0:\\n right += 1\\n else:\\n nums[left] = nums[right]\\n left += 1\\n right += 1\\n i = -1\\n while counter > 0:\\n nums[i] = 0\\n counter -=1\\n i -= 1\\n return\",\n \"def fn(vals):\\n total = odd = 0 \\n for i, x in enumerate(vals): \\n if vals[0] == x: \\n total += 1\\n if i&1: odd += 1\\n elif vals[0] ^ x != (1 << n) - 1: return inf\\n ans = inf \\n if len(vals) <= 2*total <= len(vals)+1: ans = min(ans, odd)\\n if len(vals)-1 <= 2*total <= len(vals): ans = min(ans, total - odd)\\n return ans\",\n \"def moveZeroes1(self, nums: List[int]) -> None:\\n count = 0 \\n for i in range(len(nums)-1) :\\n i = i - count\\n if nums[i] == 0 :\\n count += 1\\n nums.pop(i)\\n \\n nums.extend([0]*count)\",\n \"def zeros_like(self):\\n raise NotImplementedError\",\n \"def set_zero(mn_matrix): \\r\\n \\r\\n row_flag = [0]*len(mn_matrix)\\r\\n column_flag = [0]*len(mn_matrix[0])\\r\\n for i in range(0, len(row_flag)):\\r\\n for j in range(0, len(column_flag)):\\r\\n if mn_matrix[i][j] == 0:\\r\\n row_flag[i] = 1\\r\\n column_flag[j] = 1\\r\\n \\r\\n for i in range(0, len(row_flag)):\\r\\n for j in range(0, len(column_flag)):\\r\\n if row_flag[i] == 1 or column_flag[j] == 1: \\r\\n mn_matrix[i][j] = 0\",\n \"def solution(array):\\n rows = array.shape[0]\\n cols = array.shape[1]\\n result = np.ones((rows,cols))\\n result[1:rows-1,1:cols-1] = 0\\n return result\",\n \"def setZeroes(matrix):\\r\\n \\r\\n #An average O(n^2) time traversal solution with memoization\\r\\n #for each 0 we encounter, we update the entire row and column to 0s, but on the condition that the row/column has not been updated yet\\r\\n \\r\\n row_cache = {}\\r\\n column_cache = {}\\r\\n \\r\\n for r in range(0,rows := len(matrix)):\\r\\n for c in range(0,cols := len(matrix[0])):\\r\\n \\r\\n if matrix[r][c] == 0:\\r\\n \\r\\n if not row_cache.get(r):\\r\\n for i in range(0,cols):\\r\\n if matrix[r][i] != 0:\\r\\n matrix[r][i] = '0' #we use strings so we only consider the initial 0s\\r\\n row_cache[r] = True\\r\\n \\r\\n if not column_cache.get(c):\\r\\n for i in range(0,rows):\\r\\n if matrix[i][c] != 0:\\r\\n matrix[i][c] = '0'\\r\\n column_cache[c] = True\\r\\n return\",\n \"def solve(given: np.array) -> np.array:\\n possible = np.full((9, 9, 9), True)\\n mask = given > 0\\n possible[mask, :] = False\\n possible[mask, given[mask] - 1] = True\\n\\n # number of possibilities at each site, masking those already propagated\\n # to avoid repetitive work. All masked == problem solved\\n count = ma.array(possible.sum(axis=2), fill_value=1)\\n\\n # allocate upfront to as out parameter to np.equal\\n # (ma.array because count is ma.array)\\n where = ma.array(np.empty((9, 9), dtype=bool), fill_value=False)\\n\\n stack = [(possible, count)]\\n while stack:\\n node, count = stack.pop()\\n unsolved = propagate(node, count, where)\\n if unsolved == -1:\\n continue\\n if unsolved == 0:\\n break\\n # try all possibilities from cell with fewest > 1\\n i, j = np.unravel_index(count.argmin(), count.shape)\\n for k in np.flatnonzero(node[i, j, :]):\\n node_copy, count_copy = node.copy(), count.copy()\\n node_copy[i, j, :] = False\\n node_copy[i, j, k] = True\\n count_copy[i, j] = 1\\n stack.append((node_copy, count_copy))\\n\\n i, j, k = node.nonzero()\\n count[i, j] = k + 1\\n return np.array(count)\",\n \"def _get_masks(n_input, n_hiddens, switched_dependencies=False):\\n masks = []\\n units = [n_input] + n_hiddens + [n_input]\\n for layer in range(len(units)-1):\\n n_in = units[layer]\\n n_out = units[layer+1]\\n\\n mask = np.ones((n_in, n_out)) if not switched_dependencies else np.zeros((n_in, n_out))\\n diagonalzeros = True if layer == len(units)-2 else False\\n\\n assert n_in % n_out == 0 or n_out % n_in == 0\\n if n_out >= n_in:\\n k = int(n_out / n_in)\\n for i in range(n_in):\\n mask[i, :i * k] = 0 if not switched_dependencies else 1\\n if diagonalzeros and not switched_dependencies:\\n mask[i, i * k:(i + 1) * k] = 0\\n if not diagonalzeros and switched_dependencies:\\n mask[i, i * k:(i + 1) * k] = 1\\n else:\\n k = int(n_in / n_out)\\n for i in range(n_out):\\n mask[(i + 1) * k:, i] = 0 if not switched_dependencies else 1\\n if diagonalzeros and not switched_dependencies:\\n mask[i * k:(i + 1) * k, i] = 0\\n if not diagonalzeros and switched_dependencies:\\n mask[i * k:(i + 1) * k, i] = 1\\n\\n masks.append(mask.astype(np.float32))\\n\\n return masks\",\n \"def ones():\\n return Vec2d(1, 1)\",\n \"def possibilities(board):\\n return board[np.where(board == 0)]\",\n \"def duplicateZeros(self, arr: List[int]) -> None:\\n \\n n = len(arr)\\n z = 0\\n \\n # Decide final point\\n for left in range(n):\\n if left > n - 1 - z:\\n break\\n \\n if arr[left] == 0:\\n if left == n - 1 - z:\\n arr[-1] = 0\\n n = n - 1\\n break\\n z += 1\\n \\n \\n # in-place process\\n idx = n - 1\\n while idx > 0:\\n if arr[idx - z] == 0:\\n arr[idx], arr[idx - 1] = 0, 0\\n z -= 1\\n idx -= 1\\n else:\\n arr[idx] = arr[idx - z]\\n idx -= 1\",\n \"def fn(i):\\n if i == 2*n-1 or ans[i] and fn(i+1): return True \\n for x in reversed(range(1, n+1)): \\n if x not in ans: \\n ii = x if x > 1 else 0 \\n if i+ii < 2*n-1 and ans[i] == ans[i+ii] == 0: \\n ans[i] = ans[i+ii] = x\\n if fn(i+1): return True \\n ans[i] = ans[i+ii] = 0\",\n \"def threesumzero(a):\\n result = set() # set to eliminate deuplicates!\\n a.sort() # sort it\\n n = len(a) # number of items in a\\n for x in a: # for each element in a, see if its part of some triplet\\n target_sum = 0 - x # x and other two items must sum to 0, so other two must sum to -x\\n i = 0 # from beginning\\n j = n - 1 # from end\\n while i < j:\\n if a[i] + a[j] == target_sum: # we found triplet\\n result.add( tuple( sorted( [x, a[i], a[j] ] ) ) ) # sort it (for uniqueness) and convert it to tuple as its immutable\\n i += 1\\n j -= 1\\n elif a[i] + a[j] > target_sum:\\n j -= 1\\n else: # a[i] + a[j] < target_sum\\n i += 1\\n\\n return result\",\n \"def _pattern01(width):\\n zeroes = core.Constant(0, width)\\n return operation.Concat(zeroes, ~zeroes)\",\n \"def fn(x, mask):\\n ans = size = 0 \\n for xx in range(1, 10): \\n if not mask & (1 << xx): \\n if (x, xx) not in mp or mask & 1 << mp[x, xx]: \\n ans += fn(xx, mask^(1<<xx))\\n size += 1\\n size = 9 - size\\n if m <= size <= n: ans += 1\\n return ans\",\n \"def offspring_fertility(n1=4,n2=4):\\n ary = np.zeros( (n1,n2, n1,n2, 3), float )\\n for i in range(n1):\\n for j in range(n2):\\n for k in range(n1):\\n for l in range(n2):\\n # set group counter to zero (one counter is sufficient)\\n gc1 = 0\\n for index in [i,j,k,l]: \\n if index in [0,1]: gc1+=1\\n if gc1==0 or gc1==4:\\n ary[i,j,k,l,0] = 1. # set mark at S0\\n elif gc1==1 or gc1==3:\\n ary[i,j,k,l,2] = 1. # set mark at S2\\n else:\\n ary[i,j,k,l,1] = 1. # set mark at S1\\n return ary\",\n \"def fn(mask, j):\\n ans = 0 \\n for i in range(m): \\n if not mask & (1<<i): \\n ans = max(ans, fn(mask^(1<<i), j-1) + score[i][j])\\n return ans\",\n \"def solution(n: int) -> int:\\n binary_gap = 0\\n count = 0\\n # skip the lowest zeros\\n while n and (n & 1) == 0:\\n n = n >> 1\\n while n:\\n while n & 1:\\n n = n >> 1\\n while n and (n & 1) == 0:\\n count += 1\\n n = n >> 1\\n if n & 1 and binary_gap < count:\\n binary_gap = count\\n count = 0\\n return binary_gap\",\n \"def majority_bitwise(*bit_arrays):\\n\\n if (len(bit_arrays) == 0):\\n raise TypeError(\\\"len(bit_arrays) must be > 0.\\\")\\n\\n MINIMUM_MAJORITY = (len(bit_arrays) // 2) + 1\\n\\n answer = 0\\n for bit_array_subset in \\\\\\n itertools.combinations(bit_arrays, MINIMUM_MAJORITY):\\n answer |= functools.reduce(operator.and_, bit_array_subset)\\n\\n return answer\",\n \"def moveZeroes(self, nums: List[int]) -> None:\\n i = 0\\n while i != len(nums) and nums[i]:\\n i += 1\\n j = i\\n while j != len(nums):\\n if not nums[j]:\\n j += 1\\n else:\\n nums[i] = nums[j]\\n i += 1\\n j += 1\\n while i != len(nums):\\n nums[i] = 0\\n i += 1\",\n \"def moveZeroes(self, nums: List[int]) -> None:\\n i = j = 0\\n\\n n = len(nums)\\n while True:\\n while i < n and nums[i]:\\n i += 1\\n j = max(i, j) + 1\\n while j < n and not nums[j]:\\n j += 1\\n # i points the first zero\\n # j points the first non-zero after i\\n # between [i, j) are zeros\\n if i == n or j == n:\\n break\\n self.swap(nums, i, j)\",\n \"def gen_all_holds(hand):\\n without_repeat = []\\n mask_seque = list(gen_all_sequences([0,1], len(hand)))\\n for dum_i in mask_seque:\\n without_repeat.append(())\\n \\n for dum_i in range(len(mask_seque)):\\n for dum_j in range(len(mask_seque[dum_i])):\\n if (mask_seque[dum_i][dum_j]==1):\\n without_repeat[dum_i]=list(without_repeat[dum_i])\\n without_repeat[dum_i].append(hand[dum_j])\\n without_repeat[dum_i]=tuple(without_repeat[dum_i])\\n \\n without_repeat = set(tuple(without_repeat))\\n return without_repeat\",\n \"def matZeros(shape):\\n return [[0 for y in range(shape[1])] \\\\\\n for x in range(shape[0])]\",\n \"def moveZeroes(self, nums: List[int]) -> None:\\n i = j = 0\\n N = len(nums)\\n while j < N:\\n while j < N and nums[j] == 0:\\n j += 1\\n if j >= N:\\n break\\n nums[i] = nums[j]\\n i += 1\\n j += 1\\n while i < N:\\n nums[i] = 0\\n i += 1\",\n \"def solution(A):\\n xor = 0\\n for item in A:\\n xor ^= item\\n return xor\",\n \"def new_binomial_prefactor(s,l1,l2,PAx,PBx):\\n with loops.Scope() as L:\\n L.total = 0.\\n L.t = 0\\n for _ in L.while_range(lambda: L.t < s + 1):\\n #TEMP TODO rewrite this. The cond_range causes a huge overhead.\\n # Try Valeev implementation\\n for _ in L.cond_range(((s - l1) <= L.t) & (L.t <= l2)):\\n L.total += binomials[l1,s-L.t] * binomials[l2,L.t] * PAx[l1-s + L.t] * PBx[l2 - L.t]\\n L.t += 1\\n return L.total\",\n \"def test_jaccard_index_all_zeros_compiled():\\n vector1 = np.array([0, 0, 0, 0])\\n vector2 = np.array([1, 1, 1, 1])\\n score11 = jaccard_index(vector1, vector1)\\n score12 = jaccard_index(vector1, vector2)\\n score22 = jaccard_index(vector2, vector2)\\n\\n assert score11 == score12 == 0.0, \\\"Expected different score.\\\"\\n assert score22 == 1.0, \\\"Expected different score.\\\"\",\n \"def reduce_bits(nums):\\n num1, num2 = nums\\n result = \\\"\\\"\\n for index, bit in enumerate(num1):\\n result += bit if bit == num2[index] else '-'\\n return Term(result)\",\n \"def zeroes(m, n):\\n\\n return [[0] * n for i in range(m)]\",\n \"def solution(xs):\\n if len(xs)==1:\\n return str(xs[0])\\n count_neg = 0\\n count_pos = 0\\n count_zero = 0\\n prod_pos = 1\\n prod_neg = 1\\n max_neg = -float(\\\"inf\\\")\\n for x in xs:\\n if x ==0:\\n count_zero+=1\\n elif x < 0:\\n pos_or_neg = True\\n count_neg+=1\\n prod_neg *= x\\n max_neg = max(max_neg,x)\\n elif x > 0:\\n count_pos+=1\\n pos_or_neg = True\\n prod_pos *= x\\n if (count_pos == 0 and count_neg == 0) or (count_zero > 0 and count_neg == 1 and count_pos == 0):\\n return str(0)\\n if count_neg%2!=0:\\n count_neg-=1\\n prod_neg //=max_neg\\n \\n if not (count_pos == 0 and count_neg == 0):\\n return str(prod_neg*prod_pos)\\n return str(0)\",\n \"def check(self, i, j):\\n possible=np.ones((10), np.int)\\n for k in range(0, 9):\\n if k==j: continue\\n possible[self.a[i][k]]=0\\n\\n for k in range(0, 9):\\n if k==i: continue\\n possible[self.a[k][j]]=0\\n for a1 in range(0, 3):\\n for b1 in range(0, 3):\\n if (i//3)*3+a1==i and (j//3)*3+b1==j:\\n continue\\n possible[self.a[(i//3)*3+a1][(j//3)*3+b1]]=0\\n return possible\",\n \"def zero_comb(num_list):\\n return {tuple(sorted(n)) for n in combinations(num_list, 3) if sum(n) == 0}\",\n \"def create(matrix):\\n limit_y = len(matrix)\\n limit_x = len(matrix[0])\\n\\n for y in range(1, limit_y):\\n bit.create(matrix[y])\\n\\n for x in range(1, limit_x):\\n for y in range(1, limit_y):\\n k = y + (y & -y)\\n if k < limit_y:\\n matrix[k][x] += matrix[y][x]\",\n \"def fn(i, s0, s1, c0, c1):\\n if s0 > n or s1 > n: return 0 # impossible \\n if i == len(balls): return int(c0 == c1)\\n ans = 0 \\n for x in range(balls[i]+1): \\n ans += fn(i+1, s0+x, s1+balls[i]-x, c0+(x > 0), c1+(x < balls[i])) * comb(balls[i], x)\\n return ans\",\n \"def duplicateZeros(self, arr) -> None:\\n tmp = list()\\n for i,v in enumerate(arr):\\n if v==0:\\n tmp.append(0)\\n tmp.append(0)\\n else:\\n tmp.append(v)\\n\\n arr[i] = tmp[i]\",\n \"def onehot(isTrue):\\n if isTrue:\\n return [1, 0]\\n else:\\n return [0, 1]\",\n \"def get_sum_zero_pairs(numbers):\\n numbers = set(numbers)\\n numbers = list(numbers)\\n pairs_that_add_to_zero = []\\n\\n for i, item in enumerate(numbers):\\n if numbers[i] == len(numbers):\\n break\\n\\n if numbers[i] == 0:\\n pairs_that_add_to_zero.append([0, 0]) \\n\\n for j in range(i+1, len(numbers)):\\n total_of_two_items = numbers[i] + numbers[j]\\n if (total_of_two_items == 0):\\n pairs_that_add_to_zero.append([numbers[i], numbers[j]]) \\n\\n return pairs_that_add_to_zero\",\n \"def same_bits_up(x):\\n\\n bit_array = get_first(x, get_consecutive_01)\\n\\n if (bit_array == 0):\\n return x\\n\\n lower, upper = split_bits_bit_array(x, bit_array)\\n upper = swap_bits_bit_array(upper, bit_array)\\n lower = shift_trailing_zeros(lower)\\n\\n return upper | lower\",\n \"def update_gol(arr):\\n nxt = np.zeros(arr.shape)\\n rows,cols = nxt.shape\\n for i in range(rows):\\n for j in range(cols):\\n nn = sum_vonneuman_nn(arr,i,j)\\n if arr[i][j]==1:\\n if nn==2 or nn==3:\\n nxt[i][j]=1\\n else:\\n if nn==3:\\n nxt[i][j]=1\\n return nxt\",\n \"def setZeroes(self, matrix: List[List[int]]) -> None:\\n if not matrix:\\n return\\n row = set()\\n col = set()\\n rowl = len(matrix[0])\\n for i, r in enumerate(matrix):\\n for j, c in enumerate(r):\\n if c == 0:\\n row.add(i)\\n col.add(j)\\n \\n for r in row:\\n matrix[r] = [0]*rowl\\n for j in col:\\n for i in range(len(matrix)):\\n matrix[i][j] = 0\",\n \"def moveZeroes(self, nums: List[int]) -> None:\\n zeros=0\\n for i in range(len(nums)):\\n if nums[i]==0:\\n zeros+=1\\n else:\\n nums[i-zeros]=nums[i]\\n for i in range(len(nums)-zeros,len(nums)):\\n nums[i]=0\",\n \"def setZeroes(self, matrix: List[List[int]]) -> None:\\n m = len(matrix)\\n n = len(matrix[0])\\n \\n row_1st_0 = False\\n col_1st_0 = False\\n \\n ## check whether 1st row and 1st col contains 0\\n for i in range(n):\\n if matrix[0][i] == 0:\\n row_1st_0 = True\\n break\\n for j in range(m):\\n if matrix[j][0] == 0:\\n col_1st_0 = True\\n break\\n \\n ## check row 1:m and col 1:n, store the 0 indicator to 1st row and 1st col\\n for i in range(1, m):\\n for j in range(1, n):\\n if matrix[i][j] == 0:\\n matrix[i][0] = 0\\n matrix[0][j] = 0\\n \\n ## update cols to zero except 1st row\\n for i in range(1, n):\\n if matrix[0][i] == 0:\\n for r in range(1, m):\\n matrix[r][i] = 0\\n \\n ## update rows to zero except 1st col\\n for j in range(1, m):\\n if matrix[j][0] == 0:\\n matrix[j][1:n] = [0 for i in range(n-1)]\\n \\n ## update 1st row and 1st col to 0\\n if row_1st_0:\\n matrix[0][0:n] = [0 for i in range(n)]\\n if col_1st_0:\\n for r in range(m):\\n matrix[r][0] = 0\",\n \"def subsequent_mask(lens):\\n bs, max_len = len(lens), max(lens)\\n mask = torch.ones([bs, max_len, max_len]).tril_(0)\\n mask = mask > 0\\n return mask\",\n \"def TwoComp(n):\\n\\n l = list(n)\\n for i in range(len(l)):\\n l[i] = \\\"0\\\" if l[i] == \\\"1\\\" else \\\"1\\\"\\n return BitAdd(\\\"\\\".join(l), \\\"1\\\", len(l))\",\n \"def measure_all_1(n, state):\\n state = state.copy()\\n\\n outs = ''\\n for i in range(n):\\n out = measure_single(n, state,\\n i) # After measuring bit0, bit0 collapses. It affects the subsequent bit1 measurement, but does not affect the 1000 independent measurements of the upper layer\\n outs = str(out) + outs # from low bit to high bit\\n return outs\",\n \"def binary_add(x, y):\\n # Makes sure that the arrays have the same length.\\n # Could be changed to padding on extra zeroes, if so desired.\\n assert(len(x) == len(y))\\n\\n z = [0] * (len(x)+1)\\n for a, (i, j) in enumerate(zip(x[::-1], y[::-1])):\\n # Makes sure that the array is a binary array.\\n # Strictly speaking, not necessary. But nice.\\n if i not in [0, 1]: return False\\n if j not in [0, 1]: return False\\n\\n # if i and j are both 1 \\n if i and j:\\n z[a] += 0\\n z[a+1] += 1\\n # if only one of them is 1\\n elif i or j:\\n z[a] += 1\\n # if they're both 0\\n else: pass\\n\\n if z[a] == 2:\\n z[a+1] += 1\\n z[a] -= 2\\n \\n return z[::-1]\",\n \"def moveZeroes(self, nums: List[int]) -> None:\\n ##brute force\\n # counts= nums.count(0)\\n # while 0 in nums: nums.remove(0)\\n # nums+=[0]*counts\\n \\n ## two pointer (swapping)\\n if not nums: return None\\n anchor, explore= 0, 0\\n while explore <len(nums):\\n if nums[explore]!=0 and explore!=anchor:\\n temp= nums[anchor]\\n nums[anchor]=nums[explore]\\n nums[explore]=temp\\n if nums[anchor]!= 0:\\n anchor+=1\\n explore+=1\",\n \"def _get_possible_outcomes(m, bits):\\n\\n # This is filled with loads of dirty binary tricks...You have been warned\\n\\n size = max(m.shape) # Max of shape to account for bra or ket\\n nqubits = int(math.log(size, 2) + .1) # Number of qubits possible\\n\\n # Make the output states and put in output_matrices, nothing in them now.\\n # Each state will represent a possible outcome of the measurement\\n # Thus, output_matrices[0] is the matrix which we get when all measured\\n # bits return 0. and output_matrices[1] is the matrix for only the 0th\\n # bit being true\\n output_matrices = []\\n for i in range(1 << len(bits)):\\n output_matrices.append(zeros(2**nqubits, 1))\\n\\n # Bitmasks will help sort how to determine possible outcomes.\\n # When the bit mask is and-ed with a matrix-index,\\n # it will determine which state that index belongs to\\n bit_masks = []\\n for bit in bits:\\n bit_masks.append(1 << bit)\\n\\n # Make possible outcome states\\n for i in range(2**nqubits):\\n trueness = 0 # This tells us to which output_matrix this value belongs\\n # Find trueness\\n for j in range(len(bit_masks)):\\n if i & bit_masks[j]:\\n trueness += j + 1\\n # Put the value in the correct output matrix\\n output_matrices[trueness][i] = m[i]\\n return output_matrices\",\n \"def moveZeroes(self, nums: List[int]) -> None:\\n N = len(nums)\\n l = 0\\n r = 0\\n while r < N:\\n if nums[l] == 0 and nums[r] != 0:\\n nums[l], nums[r] = nums[r], nums[l]\\n l += 1\\n elif nums[r] == 0:\\n r += 1\\n else:\\n l += 1\\n r += 1\",\n \"def move_zeros(items: list) -> Iterable[int]:\\n return [x for x in items if x != 0] + [x for x in items if x == 0]\",\n \"def invert_zero_one(sequence):\\n return [1 - code for code in sequence]\",\n \"def _make_masks(ilens, olens):\\n # (B, T_in)\\n in_masks = make_non_pad_mask(ilens)\\n # (B, T_out)\\n out_masks = make_non_pad_mask(olens)\\n # (B, T_out, T_in)\\n\\n return paddle.logical_and(\\n out_masks.unsqueeze(-1), in_masks.unsqueeze(-2))\",\n \"def fn(i, j, mv):\\n if not (0 <= i < m and 0 <= j < n): return 1 \\n if mv == 0: return 0\\n return (fn(i-1, j, mv-1) + fn(i, j-1, mv-1) + fn(i, j+1, mv-1) + fn(i+1, j, mv-1)) % 1_000_000_007\",\n \"def moveZeroes(self, nums: List[int]) -> None:\\n n = len(nums)\\n i, j = 0, 0\\n # i记录最靠前的0的位置\\n # j记录从i开始第一个非0的位置\\n while j < n:\\n while i < n-1 and nums[i] != 0:\\n i += 1\\n j = i + 1\\n while j < n and nums[j] == 0:\\n j += 1\\n if j > n-1:\\n break\\n nums[i], nums[j] = nums[j], nums[i]\\n\\n i += 1\",\n \"def moveZeroes(self, nums: List[int]) -> None:\\n try:\\n j = nums.index(0)\\n except ValueError:\\n return\\n nums_len = len(nums)\\n i = j + 1\\n while i < nums_len and nums[i] == 0:\\n i += 1\\n\\n while i < nums_len:\\n nums[j] = nums[i]\\n nums[i] = 0\\n j += 1\\n while i < nums_len and nums[i] == 0:\\n i += 1\",\n \"def triplets():\\n for a in xrange(1, 1000):\\n for b in xrange(a, 1000):\\n c = 1000 - (a + b)\\n if a**2 + b**2 == c**2:\\n return a, b, c\",\n \"def setZeroes(self, matrix: List[List[int]]) -> None:\\n \\n m = len(matrix)\\n n = len(matrix[0])\\n \\n i_zeros = []\\n j_zeros = []\\n \\n for i in range(m): ## find the zeros\\n for j in range(n):\\n \\n if matrix[i][j] == 0:\\n i_zeros.append(i)\\n j_zeros.append(j)\\n \\n for i in i_zeros:\\n matrix[i] = [0]*n\\n \\n for j in j_zeros:\\n for i in range(m):\\n matrix[i][j] = 0\",\n \"def solution(data):\\n\\t\\tif data:\\n\\t\\t\\treturn 1\\n\\t\\telse:\\n\\t\\t\\treturn 0\",\n \"def osd(counts):\\n return (counts!=0).sum(), (counts==1).sum(), (counts==2).sum()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6483679","0.624784","0.61705774","0.610907","0.6090902","0.6031265","0.59823155","0.59540856","0.59308344","0.59170455","0.5842495","0.5830201","0.5826083","0.5814207","0.578468","0.57763344","0.5771295","0.57675946","0.5759372","0.5745411","0.5724746","0.5723461","0.5713244","0.5685539","0.5685301","0.5676476","0.5657328","0.56461656","0.5642397","0.5629498","0.56216425","0.5609396","0.55813867","0.557257","0.556937","0.55691636","0.5566569","0.55565035","0.5550816","0.5531341","0.55044776","0.5493055","0.5492269","0.54828584","0.5479583","0.54754764","0.5475407","0.5469933","0.54697853","0.54606646","0.54596263","0.5455562","0.54481804","0.54436356","0.5443365","0.54360634","0.54301465","0.542594","0.542502","0.5422397","0.5417279","0.541509","0.54096484","0.5397182","0.53933704","0.5388943","0.53859484","0.5375774","0.53723276","0.5371568","0.53702945","0.53677887","0.53643405","0.53555745","0.5353314","0.53506994","0.53493553","0.53482103","0.53469527","0.53461796","0.5326446","0.5321244","0.53176385","0.53139806","0.5308967","0.5308668","0.5308062","0.530451","0.5302518","0.52998793","0.52930075","0.52881587","0.5285078","0.52850354","0.52846307","0.52832174","0.5279823","0.52709585","0.5270728","0.5264962"],"string":"[\n \"0.6483679\",\n \"0.624784\",\n \"0.61705774\",\n \"0.610907\",\n \"0.6090902\",\n \"0.6031265\",\n \"0.59823155\",\n \"0.59540856\",\n \"0.59308344\",\n \"0.59170455\",\n \"0.5842495\",\n \"0.5830201\",\n \"0.5826083\",\n \"0.5814207\",\n \"0.578468\",\n \"0.57763344\",\n \"0.5771295\",\n \"0.57675946\",\n \"0.5759372\",\n \"0.5745411\",\n \"0.5724746\",\n \"0.5723461\",\n \"0.5713244\",\n \"0.5685539\",\n \"0.5685301\",\n \"0.5676476\",\n \"0.5657328\",\n \"0.56461656\",\n \"0.5642397\",\n \"0.5629498\",\n \"0.56216425\",\n \"0.5609396\",\n \"0.55813867\",\n \"0.557257\",\n \"0.556937\",\n \"0.55691636\",\n \"0.5566569\",\n \"0.55565035\",\n \"0.5550816\",\n \"0.5531341\",\n \"0.55044776\",\n \"0.5493055\",\n \"0.5492269\",\n \"0.54828584\",\n \"0.5479583\",\n \"0.54754764\",\n \"0.5475407\",\n \"0.5469933\",\n \"0.54697853\",\n \"0.54606646\",\n \"0.54596263\",\n \"0.5455562\",\n \"0.54481804\",\n \"0.54436356\",\n \"0.5443365\",\n \"0.54360634\",\n \"0.54301465\",\n \"0.542594\",\n \"0.542502\",\n \"0.5422397\",\n \"0.5417279\",\n \"0.541509\",\n \"0.54096484\",\n \"0.5397182\",\n \"0.53933704\",\n \"0.5388943\",\n \"0.53859484\",\n \"0.5375774\",\n \"0.53723276\",\n \"0.5371568\",\n \"0.53702945\",\n \"0.53677887\",\n \"0.53643405\",\n \"0.53555745\",\n \"0.5353314\",\n \"0.53506994\",\n \"0.53493553\",\n \"0.53482103\",\n \"0.53469527\",\n \"0.53461796\",\n \"0.5326446\",\n \"0.5321244\",\n \"0.53176385\",\n \"0.53139806\",\n \"0.5308967\",\n \"0.5308668\",\n \"0.5308062\",\n \"0.530451\",\n \"0.5302518\",\n \"0.52998793\",\n \"0.52930075\",\n \"0.52881587\",\n \"0.5285078\",\n \"0.52850354\",\n \"0.52846307\",\n \"0.52832174\",\n \"0.5279823\",\n \"0.52709585\",\n \"0.5270728\",\n \"0.5264962\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6798596"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":5494,"cells":{"query":{"kind":"string","value":"Implements a descending exponential cooling scheme. Temperature becomes zero after all iterations have been passed."},"document":{"kind":"string","value":"def update_temperature(self):\n self.iteration += 1 \n self.T = self.T0 * 0.9935**self.iteration"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def constant_temp(self, numIterations):\n return 1 + self.alpha","def _etaE_cool(self,x):\n return self._eta_sfr_scaling(x,'E_cool')","def _etaE(self,x):\n return self._etaE_cool(x) + self._etaE_hot(x)","def sim_alternating_exp():\n catches = 0\n for _ in range(100000):\n j = np.random.uniform()*1000\n # j = np.random.exponential(500)\n t_i = 0\n i = 0\n while t_i < j+100:\n if i % 2 == 1:\n t_i += np.random.exponential(10)\n else:\n t_i += np.random.exponential(20)\n if j < t_i and t_i < j+1:\n catches += 1\n i += 1\n print(catches/100000)","def simpleCool(T0, i):\n\talpha = 0.99995\n\treturn (alpha ** i) * T0","def activation(self,z):\n #using the clipping function as there is no need for it because the values larger or smaller would be very close to zero\n return 1./(1. + np.exp(-np.clip(z,-250,250)))","def exponential(min_iterations, i, start = start_temp, final = final_temp):\n\n\ttemperature = (start * (final / start) ** (i / min_iterations))\n\n\treturn temperature","def linear_decrease_temp(self, numIterations):\n\n denom = numIterations*self.alpha\n return self.maxCount/denom if denom > 0 else 0","def cool(self):\n self.t = self.t - 1","def temp(self, numIterations):\n return self.linear_decrease_temp(numIterations)","def __call__(self, epoch):\n exp = np.floor((1 + epoch) / self.dropEvery)\n alpha = initAlpha * (self.factor ** exp)\n \n # return alpha \n return float(alpha)","def exponentialLearningRate(base):\n def function(t):\n return base ** (t-1)\n return function","def activation(self, z):\r\n denominator = 1 + np.exp(-z)\r\n result = 1/denominator\r\n return result","def exponentialMovingAverage(self,new,old, alpha):\n return alpha * new + (1 - alpha)* old","def exp_warmup(base_value, max_warmup_iter, cur_step):\n if max_warmup_iter <= cur_step:\n return base_value\n return base_value * math.exp(-5 * (1 - cur_step/max_warmup_iter)**2)","def _etaE_hot(self,x):\n return self._eta_sfr_scaling(x,'E_hot')","def _decay_rate_pow(i: int, exponent: float = 0.8) -> float:\n t = jnp.array(i, jnp.float32) + 1.0\n return 1.0 - t**(-exponent)","def evaluate(self, _t):\n\n temp = self.init_temp*(self.decay**_t)\n\n if temp < self.min_temp:\n temp = self.min_temp\n\n return temp","def cubic_evolve(self,nt=1):\n #loop through time steps\n for l in range(nt):\n # temporary array\n y_temp = np.zeros(self.y.shape[0])\n # loop through array\n for i in range(self.y.shape[0]):\n # idx left to departure point\n x_dep = self.x[i]-self.u[i]*self.dt\n j = int(np.floor(x_dep/self.dx))\n # alpha\n a = (self.x[i]-self.u[i]*self.dt - j*self.dx)/self.dx\n # calculate next time step\n f = lambda x: x % self.y.shape[0] if x >= self.y.shape[0] else x\n y_temp[i] = - a * (1-a)*(2-a)/6 * self.y[f(j-1)]\n y_temp[i] += (1-a**2)*(2-a)/2 * self.y[f(j)]\n y_temp[i] += a*(1+a)*(2-a)/2 * self.y[f(j+1)]\n y_temp[i] -= a*(1-a**2)/6 * self.y[f(j+2)]\n self.y = np.copy(y_temp)\n return self.y","def linear_decay(x0, alpha, T, t):\n if t <= T:\n return x0 - (1 - alpha) * x0 * t / T\n else:\n return alpha * x0","def evaluate(self, _t):\n\n temp = self.init_temp - (self.decay*_t)\n\n if temp < self.min_temp:\n temp = self.min_temp\n\n return temp","def test_exp_decay(self, alpha: float):\n x = np.linspace(0, 1, 100)\n y = np.exp(alpha * x)\n\n alpha_guess = guess.exp_decay(x, y)\n\n self.assertAlmostEqualAbsolute(alpha_guess, alpha)","def activation_function(self, z):\n return 1. / (1. + np.exp(-np.clip(z, -250, 250)))","def sigmoid_decay(ep, static =5, k=5):\n static = static\n if ep < static:\n return float(1.)\n else:\n ep = ep - static\n factor = k/(k + np.exp(ep / k))\n return float(factor)","def next(self, dt):\n self.x = self.x + \\\n (self.rate-0.5*self.vola*self.vola)*dt + \\\n sqrt(dt)*self.vola*np.random.normal()\n return exp(self.x)","def safe_cumprod(x, eps):\n return torch.exp(exclusive_cumsum(torch.log(torch.clamp(x, min=eps, max=1.0))))","def get_duct_linear_heat_loss_coefficient() -> float:\n return 0.49","def thermal_expansivity_of_air(self) -> float:\n\n return 1 / self.ambient_temperature","def elo(old, exp, score, k=10):\n return old + k * (score - exp)","def probability(delta_cost: float, temperature: float, k: float = 1) -> float:\n if delta_cost < 0:\n return 1\n else:\n return np.exp(-delta_cost / (k * temperature))","def forward(self):\n self.iteration_number += 1\n x = self.x\n self.x = self.alpha * self.x + self.betta\n t = x - self.x\n\n return (t * t).sum()","def powAlpha( n ):\n return (1-betaval)*Fib(n) + Fib(n-1)\n #return Fib(n+1) - Fib(n) * betaval","def dielectric_constant_water(temperature=298.15):\n tabulated_data = np.array([[263.15, 92.10],\n [268.15, 89.96],\n [273.15, 87.90],\n [278.15, 85.90],\n [283.15, 83.96],\n [288.15, 82.06],\n [293.15, 80.20],\n [298.15, 78.38],\n [303.15, 76.60],\n [308.15, 74.86],\n [313.15, 73.17],\n [318.15, 71.50],\n [323.15, 69.88],\n [328.15, 68.29],\n [333.15, 66.74],\n [338.15, 65.22],\n [343.15, 63.73],\n [348.15, 62.28],\n [353.15, 60.87],\n [358.15, 59.48],\n [363.15, 58.13],\n [368.15, 56.81],\n [373.15, 55.51]])\n polynomal_degree = 5\n fitdata = np.polyfit(tabulated_data[:, 0], tabulated_data[:, 1],\n polynomal_degree)\n fitfunction = np.poly1d(fitdata)\n return fitfunction(temperature)","def exponential(self, data=[], init_lambdas=[1,0.75], max_iteration=500):\r\n xaxis = np.arange(1, len(data)+1)\r\n data = np.array(data)\r\n idx = 1\r\n lambdas = np.array(init_lambdas)\r\n while idx < max_iteration:\r\n y = [lmbda*np.exp(data*(-lmbda)) for lmbda in lambdas]\r\n weights = y/np.sum(y, axis=0)\r\n coefficients = np.mean(weights, axis=1)\r\n lambdas = np.sum(weights, axis=1)/np.sum(weights*data, axis=1)\r\n idx+=1 \r\n print lambdas, coefficients\r\n return lambdas, coefficients","def _func_pen(self, coeffs_ext):\n l_elastic_net = self.l_elastic_net\n eta = self.eta\n n_features = self.n_features\n coeffs = coeffs_ext[:n_features] - coeffs_ext[n_features:]\n return l_elastic_net * ((1. - eta) * coeffs_ext.sum()\n + 0.5 * eta * np.linalg.norm(coeffs) ** 2)","def oactivate(self,x):\n value = 1 / (1 + math.exp(-x))\n if value > 0.5:\n return 1\n else:\n return -1","def sigmoidal(min_iterations, i, start = start_temp, final = final_temp ):\n\n\t# to prevent a math overflow a scale (x^(1/ (i - min_iterations))) is used\n\ttemperature = final + ((start - final)**( 1/ (i - min_iterations))) / \\\n\t\t\t\t\t(1 **(i - min_iterations)) + math.exp(0.3 * ((i - min_iterations / 2) /(i - min_iterations)))\n\n\treturn temperature","def exponential_window_lssm(self):\n self.A = np.array([self.decay])\n self.s = np.ones(1)\n self.C = np.ones(1)","def set_coefs_decay(self):\n wt_phenotype = self.epistasis.values[0]\n for order in range(1, self.epistasis.order + 1):\n # Get epistasis map for this order.\n em = self.epistasis.get_orders(order)\n index = em.index\n\n # Randomly choose values for the given order\n vals = 10**(-order) * np.random.uniform(-wt_phenotype,\n wt_phenotype,\n size=len(index))\n\n # Map to epistasis object.\n self.epistasis.data.values[index[0]: index[-1] + 1] = vals\n self.build()\n return self","def activate(self,x):\n return 1 / (1 + np.exp(-x))","def schechter(l,alpha):\n return exp(-l)*(l**alpha)","def exp_func(x, initial, lifetime):\n return initial * np.exp(-x/lifetime)","def activate_der(self):\r\n\t\treturn self.value * (1 - self.value)","def calculate_energy(self):\n temp_e = 0\n\n for i in range(0,self.neuron_count):\n for j in range(0, self.neuron_count):\n if i != j:\n temp_e += self.get_weight(i, j) * self.current_state[i] * \\\n self.current_state[j]\n return -1 * temp_e / 2","def helmholtzenergy(temp,pres):\n g = liq_g(0,0,temp,pres)\n g_p = liq_g(0,1,temp,pres)\n f = g - pres*g_p\n return f","def test_exp_decay_with_invalid_y(self):\n x = np.array([9.0e-06, 1.9e-05, 2.9e-05, 3.9e-05])\n y = np.array([0.16455749, 0.07045296, 0.02702439, -0.00135192])\n\n # The last point is excluded. This point might be some artifact due to filtering.\n alpha_guess = guess.exp_decay(x, y)\n\n np.testing.assert_almost_equal(alpha_guess, -90326, decimal=0)","def _etaZ(self,x):\n return self._eta_sfr_scaling(x,'Z_cool')+self._eta_sfr_scaling(x,'Z_hot')","def test_exp_osci_decay(self, alpha, freq):\n x = np.linspace(0, 1, 100)\n y = np.exp(alpha * x) * np.cos(2 * np.pi * freq * x)\n\n alpha_guess = guess.oscillation_exp_decay(x, y)\n\n self.assertAlmostEqualAbsolute(alpha_guess, alpha)","def update_exponential(self, Z, eta, BDpair=None):\r\n if eta == 0:\r\n return\r\n if BDpair:\r\n B, D = BDpair\r\n else:\r\n D, B = self.opts['CMA_eigenmethod'](self.C)\r\n D **= 0.5\r\n Csi = dot(B, (B / D).T)\r\n Cs = dot(B, (B * D).T)\r\n self.C = dot(Cs, dot(Mh.expms(eta * dot(Csi, dot(Z, Csi)), self.opts['CMA_eigenmethod']), Cs))","def _etap(self,x):\n return self._eta_sfr_scaling(x,'p_cool') + self._eta_sfr_scaling(x,'p_hot')","def activation_func(x):\r\n a = -1\r\n return 1/(1+np.exp(-a*x))","def adjust_cost(self) -> None:\n\n n_iterations = self.array.shape[-1]\n n_year = len(self.array.year.values)\n\n # If uncertainty is not considered, the cost factor equals 1.\n # Otherwise, a variability of +/-30% is added.\n\n if n_iterations == 1:\n cost_factor = 1\n else:\n if \"reference\" in self.array.value.values.tolist():\n cost_factor = np.ones((n_iterations, 1))\n else:\n cost_factor = np.random.triangular(0.7, 1, 1.3, (n_iterations, 1))\n\n # Correction of hydrogen tank cost, per kg\n # Correction of fuel cell stack cost, per kW\n if \"FCEV\" in self.array.powertrain:\n self.array.loc[\n dict(powertrain=\"FCEV\", parameter=\"fuel tank cost per kg\")\n ] = np.reshape(\n (1.078e58 * np.exp(-6.32e-2 * self.array.year.values) + 3.43e2)\n * cost_factor,\n (1, n_year, n_iterations),\n )\n\n self.array.loc[\n dict(powertrain=\"FCEV\", parameter=\"fuel tank cost per kg\")\n ] = np.reshape(\n (3.15e66 * np.exp(-7.35e-2 * self.array.year.values) + 2.39e1)\n * cost_factor,\n (1, n_year, n_iterations),\n )\n\n # Correction of energy battery system cost, per kWh\n list_batt = [\n i\n for i in [\"BEV\", \"PHEV-e\", \"PHEV-c-p\", \"PHEV-c-d\"]\n if i in self.array.powertrain\n ]\n if len(list_batt) > 0:\n self.array.loc[\n dict(powertrain=list_batt, parameter=\"energy battery cost per kWh\")\n ] = np.reshape(\n (2.75e86 * np.exp(-9.61e-2 * self.array.year.values) + 5.059e1)\n * cost_factor,\n (1, 1, n_year, n_iterations),\n )\n\n # Correction of power battery system cost, per kW\n list_pwt = [\n i\n for i in [\n \"ICEV-p\",\n \"ICEV-d\",\n \"ICEV-g\",\n \"PHEV-c-p\",\n \"PHEV-c-d\",\n \"FCEV\",\n \"HEV-p\",\n \"HEV-d\",\n ]\n if i in self.array.powertrain\n ]\n\n if len(list_pwt) > 0:\n self.array.loc[\n dict(powertrain=list_pwt, parameter=\"power battery cost per kW\")\n ] = np.reshape(\n (8.337e40 * np.exp(-4.49e-2 * self.array.year.values) + 11.17)\n * cost_factor,\n (1, 1, n_year, n_iterations),\n )\n\n # Correction of combustion powertrain cost for ICEV-g\n if \"ICEV-g\" in self.array.powertrain:\n self.array.loc[\n dict(powertrain=\"ICEV-g\", parameter=\"combustion powertrain cost per kW\")\n ] = np.clip(\n np.reshape(\n (5.92e160 * np.exp(-0.1819 * self.array.year.values) + 26.76)\n * cost_factor,\n (1, n_year, n_iterations),\n ),\n None,\n 100,\n )","def reweight_distribution(original_distribution, temperature=0.5):\n\n with warnings.catch_warnings():\n warnings.simplefilter('ignore')\n distribution = np.log(original_distribution) / temperature\n distribution = np.exp(distribution)\n return distribution / np.sum(distribution)","def exp(X):\n X = np.maximum(X,100)\n return np.exp(X)","def _cross_over(self,mp,cross_rate,eta):","def exponential_decay(param: float, decay_factor: float, min_val: float) -> float:\n if param > min_val:\n param *= decay_factor\n param = max(param, min_val)\n return param","def exponential_decay(learning_rate, global_step, decay_steps, decay_rate,\n staircase=False, name=None):\n with ops.op_scope([learning_rate, global_step, decay_steps, decay_rate],\n name, \"ExponentialDecay\") as name:\n learning_rate = ops.convert_to_tensor(learning_rate, name=\"learning_rate\")\n dtype = learning_rate.dtype\n global_step = math_ops.cast(global_step, dtype)\n decay_steps = math_ops.cast(decay_steps, dtype)\n decay_rate = math_ops.cast(decay_rate, dtype)\n p = global_step / decay_steps\n if staircase:\n p = math_ops.floor(p)\n return math_ops.mul(learning_rate, math_ops.pow(decay_rate, p), name=name)","def cont_ret(self, rate, T, t = 0):\n return np.exp(rate * (T - t))","def energy_function(self, x):\n \n return -T.dot(T.transpose(x), T.dot(self.W, x)) -\\\n T.dot(T.transpose(self.b), x)","def entropy(temp,pres):\n g_t = liq_g(1,0,temp,pres)\n s = -g_t\n return s","def manipulate_heat_data(self): \n self.exh.T_array = ( 0.5 * (self.exh.T_inlet_array +\n self.exh.T_outlet_array) + 273.15)\n self.exh.delta_T_array = ( self.exh.T_inlet_array -\n self.exh.T_outlet_array )\n \n self.cool.delta_T_array = ( self.cool.T_inlet_array -\n self.cool.T_outlet_array )\n self.cool.C = self.cool.mdot * self.cool.c_p","def wce(B):\n return eme*B","def tempWater(sample):\n sample *= .0009\n sample *= 1000\n celsius = (sample - 20.5128) * 0.0512\n return round(celsius,2)","def zeta(self):\r\n raise NotImplementedError('not implemented yet')","def half_space_cooling_temperature(z, t, T1, T0, kappa):\n return [math.erfc(z1 / (2 * numpy.sqrt(kappa * t))) * (T0 - T1) + T1 for z1 in z]","def BernoulliExponentialLoss(lamb) :\n def bexl(x, p) :\n N = K.int_shape(p)[1]\n recon = N*metrics.binary_crossentropy(x, p)\n dkl = K.sum((-1./lamb) + K.log(lamb) - 1, axis=-1)\n return recon+dkl\n return bexl","def _exponential_backoff(backoff=0.1, max_delay=5):\n attempt = 0\n while True:\n delay = backoff * (2 ** attempt)\n if delay > max_delay:\n \"\"\"prevent redundant calculations\"\"\"\n break\n attempt += 1\n yield delay\n while True:\n yield max_delay","def evaluate(self, _t):\n\n temp = self.init_temp*np.exp(-1.0*self.exp_const*_t)\n\n if temp < self.min_temp:\n temp = self.min_temp\n\n return temp","def DyCheat(x, t, T0, r2, K, alpha, n):\n D=dmax*x[0]**n/(x[0]**n+K**n)\n #defune the degradation effect\n deg=0\n #define ODEs\n y=np.zeros([np.size(x)])\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\n y[1]=x[1]*(r2*(1-x[1])-D-alpha)#d Co/dt\n \n return y","def erfc(x):\n return 0.0","def sim_an_exp(neighborhood, Tmax, Tmin, iterations):\n\n temp = Tmax\n\n # set iteration number to 0 at start\n n = 0\n\n plot_list = []\n\n cooling_rate = float(Tmin/Tmax)**(1/iterations)\n\n current_costs = neighborhood.get_total_costs()\n\n while (n < iterations):\n temp = Tmax * (float(cooling_rate)**float(n))\n\n swap_succes = False\n while not swap_succes:\n cable_1 = random.choice(neighborhood.cables)\n cable_2 = random.choice(neighborhood.cables)\n swap_succes = neighborhood.swap_connection(cable_1, cable_2)\n\n new_costs = neighborhood.get_total_costs()\n if (acceptance_probability(current_costs, new_costs, temp) > random.random()):\n current_costs = new_costs\n else:\n cable_1 = neighborhood.cables[-1]\n cable_2 = neighborhood.cables[-2]\n neighborhood.swap_connection(cable_1, cable_2)\n\n plot_list.append(current_costs)\n n += 1","def cost_derivative(output_activations, y):\n return (output_activations - y)","def noiseless_function(x):\n return 1/(1+np.exp(-x+5))-0.5","def _auto_mix(self):\n gamma = np.random.choice([0.5, 1, 1.5, 2])\n offset = np.random.uniform(0, self.n * self.dt)\n empty_window = np.random.uniform(0, self.n * self.dt * 0.5)\n self.t.sort()\n self.t[2 * (self.n // 5):4 * (self.n // 5)] *= gamma\n self.t[3 * (self.n // 5):] += empty_window\n self._add_irregularities(epsilon=np.random.normal(0,\n 0.05 * self.dt,\n self.n))\n self.t.sort()\n self._normalize(offset=offset)","def _etaM_cool(self,x):\n return self._eta_sfr_scaling(x,'M_cool')","def exp_decr_lr():\n minlr_div_maxlr = tf.divide(min_lr, max_lr)\n power_iter = tf.divide(global_step, num_iters)\n pow_div = tf.pow(minlr_div_maxlr, power_iter)\n return tf.multiply(max_lr, pow_div, name=name)","def anneal_temp(self, T):\n new_T = self.anneal_rate * T\n return(new_T)","def hot_cold_process(\n curr_yr,\n p_cold_rolling_steel,\n assumptions\n ):\n # Reduce demand depending on fraction of hot and cold steel rolling process\n p_cold_rolling_by = assumptions.p_cold_rolling_steel_by\n p_hot_rolling_by = 1.0 - p_cold_rolling_by\n\n # Current year fractions\n p_cold_rolling_cy = p_cold_rolling_steel[curr_yr]\n p_hot_rolling_cy = 1 - p_cold_rolling_cy\n\n # Efficiencies of processes\n eff_cold = assumptions.eff_cold_rolling_process\n eff_hot = assumptions.eff_hot_rolling_process\n\n p_by = p_cold_rolling_by * eff_cold + p_hot_rolling_by * eff_hot\n p_cy = p_cold_rolling_cy * eff_cold + p_hot_rolling_cy * eff_hot\n\n factor = p_cy / p_by\n\n return factor","def get_evaporation_latent_heat() -> float:\n theta = 28.0\n return 2500.8 - 2.3668 * theta","def optimal_alpha():\n\n # When I checked all of alphas, -0.01 was the best\n alpha = -0.01\n # np.random.choice([-0.06, -0.01, 0.04, 0.1])\n return alpha","def eco_temperature_high_c(self) -> float:\r\n self._logger.debug(log_message_formatter(\r\n \"get\", f\"{self}\", \"eco_temperature_high_c\"))\r\n return kelvin_to_celsius(self._eco_temperature_high)","def empirical_erm(self):\n return lambda samples: np.mean(samples) - 0.5 * self.alpha * np.var(samples)","def activate(self, x):\n\n return 1.0 / (1 + np.exp(-x))","def energy_func(self):\n i = self.inl[0].to_flow()\n o = self.outl[0].to_flow()\n\n T_m = (T_mix_ph(i, T0=self.inl[0].T.val_SI) +\n T_mix_ph(o, T0=self.outl[0].T.val_SI)) / 2\n\n return (i[0] * (o[2] - i[2]) -\n self.A.val * (\n self.E.val * self.eta_opt.val -\n (T_m - self.Tamb.val_SI) * self.lkf_lin.val -\n self.lkf_quad.val * (T_m - self.Tamb.val_SI) ** 2))","def _etaM(self,x):\n return self._etaM_cool(x) + self._etaM_hot(x)","def activation(x):\n return 1 / (1 + torch.exp(-x))","def wind_heat_transfer_coefficient(self) -> float:\n\n return 3.8 + 2 * self.wind_speed\n # return 4.5 + 2.9 * self.wind_speed","def E_generator(beta, eta, h):\n def E(x, y):\n \"\"\"Calculate energy for matrices x, y.\n\n Note: the computation is not localized, so this is quite expensive.\n \"\"\"\n # sum of products of neighboring paris {xi, yi}\n xxm = np.zeros_like(x)\n xxm[:-1, :] = x[1:, :] # down\n xxm[1:, :] += x[:-1, :] # up\n xxm[:, :-1] += x[:, 1:] # right\n xxm[:, 1:] += x[:, :-1] # left\n xx = np.sum(xxm * x)\n xy = np.sum(x * y)\n xsum = np.sum(x)\n return h * xsum - beta * xx - eta * xy\n\n def is_valid(i, j, shape):\n \"\"\"Check if coordinate i, j is valid in shape.\"\"\"\n return i >= 0 and j >= 0 and i < shape[0] and j < shape[1]\n\n def localized_E(E1, i, j, x, y):\n \"\"\"Localized version of Energy function E.\n\n Usage: old_x_ij, new_x_ij, E1, E2 = localized_E(Ecur, i, j, x, y)\n \"\"\"\n oldval = x[i, j]\n newval = oldval * -1 # flip\n # local computations\n E2 = E1 - (h * oldval) + (h * newval)\n E2 = E2 + (eta * y[i, j] * oldval) - (eta * y[i, j] * newval)\n adjacent = [(0, 1), (0, -1), (1, 0), (-1, 0)]\n neighbors = [x[i + di, j + dj] for di, dj in adjacent\n if is_valid(i + di, j + dj, x.shape)]\n E2 = E2 + beta * sum(a * oldval for a in neighbors)\n E2 = E2 - beta * sum(a * newval for a in neighbors)\n return oldval, newval, E1, E2\n\n return E, localized_E","def apply_temperature(prob, temperature):\r\n # Apply temperature\r\n if temperature != 1:\r\n # Inverse sigmoid\r\n x = -np.log(1 / prob - 1)\r\n # Apply temperature to sigmoid function\r\n prob = 1 / (1 + np.exp(-x / temperature))\r\n return prob","def true_y_exp(x):\n y = torch.exp(x)#torch.sigmoid(x * 5) * 2 #exp(x)\n return y","def temperature(k, kmax):\n return 1.0 / 500 * (1.0 / k - 1.0 / kmax)","def compute_activation(self):\r\n\r\n x=0\r\n edges=self.in_edges\r\n for edge in edges:\r\n x+= edge.source.activation*edge.weight\r\n self.activation=1/(1+exp(-x))","def fun_decay_exp_gen(r0):\n def fit_fun(p,r):\n return (p[2] ) * np.exp(-(r-r0)/p[0] ) * np.cos(p[1]*r + p[3]) + (r)*p[4] + p[5]\n return fit_fun","def InitialCondition():\n maxX = getX(C.N + 1,C.N+1,C.alpha_max)\n y0 = np.zeros(maxX,dtype=complex)\n for i in range(0, C.N+2):\n for j in range(0, C.N+2):\n for alpha in [1]:\n\n X = getX(i, j, alpha)\n\n y0[X] = 1./2./C.N * (1-delta(i, C.N+1))*(1-delta(j, C.N+1))+1./2*delta(i, C.N+1)*delta(j, C.N+1) +\\\n 1./2./(C.N)**0.5 * ((1-delta(i, C.N+1)) *\n delta(j, C.N+1)+(1-delta(j, C.N+1))*delta(i, C.N+1))","def calculate_probability(energy, new_energy, temperature):\n if new_energy < energy:\n return 1.0\n else:\n return exp(float(energy - new_energy) / temperature)","def looptcs(self): \n while self.itr < 1: \n #self.genRandomNoise() #developing\n self.tcs(lpf=1)\n #self.itr +=1 ","def cool_down(heatmap, amount):\n heatmap[heatmap <= amount] = 0\n heatmap[heatmap > amount] -= amount\n return heatmap","def exponential_decay(mul, base, n, min=0.1):\n return np.vstack([mul * np.power(base, np.arange(n)), [min] * n]).max(0).tolist()","def decay(time_, max_time, coeff):\n threshold = max_time - time_\n if threshold < 0:\n threshold = 0\n return 1 + threshold * coeff / max_time","def expansion(temp,pres):\n g_p = liq_g(0,1,temp,pres)\n g_tp = liq_g(1,1,temp,pres)\n alpha = g_tp / g_p\n return alpha"],"string":"[\n \"def constant_temp(self, numIterations):\\n return 1 + self.alpha\",\n \"def _etaE_cool(self,x):\\n return self._eta_sfr_scaling(x,'E_cool')\",\n \"def _etaE(self,x):\\n return self._etaE_cool(x) + self._etaE_hot(x)\",\n \"def sim_alternating_exp():\\n catches = 0\\n for _ in range(100000):\\n j = np.random.uniform()*1000\\n # j = np.random.exponential(500)\\n t_i = 0\\n i = 0\\n while t_i < j+100:\\n if i % 2 == 1:\\n t_i += np.random.exponential(10)\\n else:\\n t_i += np.random.exponential(20)\\n if j < t_i and t_i < j+1:\\n catches += 1\\n i += 1\\n print(catches/100000)\",\n \"def simpleCool(T0, i):\\n\\talpha = 0.99995\\n\\treturn (alpha ** i) * T0\",\n \"def activation(self,z):\\n #using the clipping function as there is no need for it because the values larger or smaller would be very close to zero\\n return 1./(1. + np.exp(-np.clip(z,-250,250)))\",\n \"def exponential(min_iterations, i, start = start_temp, final = final_temp):\\n\\n\\ttemperature = (start * (final / start) ** (i / min_iterations))\\n\\n\\treturn temperature\",\n \"def linear_decrease_temp(self, numIterations):\\n\\n denom = numIterations*self.alpha\\n return self.maxCount/denom if denom > 0 else 0\",\n \"def cool(self):\\n self.t = self.t - 1\",\n \"def temp(self, numIterations):\\n return self.linear_decrease_temp(numIterations)\",\n \"def __call__(self, epoch):\\n exp = np.floor((1 + epoch) / self.dropEvery)\\n alpha = initAlpha * (self.factor ** exp)\\n \\n # return alpha \\n return float(alpha)\",\n \"def exponentialLearningRate(base):\\n def function(t):\\n return base ** (t-1)\\n return function\",\n \"def activation(self, z):\\r\\n denominator = 1 + np.exp(-z)\\r\\n result = 1/denominator\\r\\n return result\",\n \"def exponentialMovingAverage(self,new,old, alpha):\\n return alpha * new + (1 - alpha)* old\",\n \"def exp_warmup(base_value, max_warmup_iter, cur_step):\\n if max_warmup_iter <= cur_step:\\n return base_value\\n return base_value * math.exp(-5 * (1 - cur_step/max_warmup_iter)**2)\",\n \"def _etaE_hot(self,x):\\n return self._eta_sfr_scaling(x,'E_hot')\",\n \"def _decay_rate_pow(i: int, exponent: float = 0.8) -> float:\\n t = jnp.array(i, jnp.float32) + 1.0\\n return 1.0 - t**(-exponent)\",\n \"def evaluate(self, _t):\\n\\n temp = self.init_temp*(self.decay**_t)\\n\\n if temp < self.min_temp:\\n temp = self.min_temp\\n\\n return temp\",\n \"def cubic_evolve(self,nt=1):\\n #loop through time steps\\n for l in range(nt):\\n # temporary array\\n y_temp = np.zeros(self.y.shape[0])\\n # loop through array\\n for i in range(self.y.shape[0]):\\n # idx left to departure point\\n x_dep = self.x[i]-self.u[i]*self.dt\\n j = int(np.floor(x_dep/self.dx))\\n # alpha\\n a = (self.x[i]-self.u[i]*self.dt - j*self.dx)/self.dx\\n # calculate next time step\\n f = lambda x: x % self.y.shape[0] if x >= self.y.shape[0] else x\\n y_temp[i] = - a * (1-a)*(2-a)/6 * self.y[f(j-1)]\\n y_temp[i] += (1-a**2)*(2-a)/2 * self.y[f(j)]\\n y_temp[i] += a*(1+a)*(2-a)/2 * self.y[f(j+1)]\\n y_temp[i] -= a*(1-a**2)/6 * self.y[f(j+2)]\\n self.y = np.copy(y_temp)\\n return self.y\",\n \"def linear_decay(x0, alpha, T, t):\\n if t <= T:\\n return x0 - (1 - alpha) * x0 * t / T\\n else:\\n return alpha * x0\",\n \"def evaluate(self, _t):\\n\\n temp = self.init_temp - (self.decay*_t)\\n\\n if temp < self.min_temp:\\n temp = self.min_temp\\n\\n return temp\",\n \"def test_exp_decay(self, alpha: float):\\n x = np.linspace(0, 1, 100)\\n y = np.exp(alpha * x)\\n\\n alpha_guess = guess.exp_decay(x, y)\\n\\n self.assertAlmostEqualAbsolute(alpha_guess, alpha)\",\n \"def activation_function(self, z):\\n return 1. / (1. + np.exp(-np.clip(z, -250, 250)))\",\n \"def sigmoid_decay(ep, static =5, k=5):\\n static = static\\n if ep < static:\\n return float(1.)\\n else:\\n ep = ep - static\\n factor = k/(k + np.exp(ep / k))\\n return float(factor)\",\n \"def next(self, dt):\\n self.x = self.x + \\\\\\n (self.rate-0.5*self.vola*self.vola)*dt + \\\\\\n sqrt(dt)*self.vola*np.random.normal()\\n return exp(self.x)\",\n \"def safe_cumprod(x, eps):\\n return torch.exp(exclusive_cumsum(torch.log(torch.clamp(x, min=eps, max=1.0))))\",\n \"def get_duct_linear_heat_loss_coefficient() -> float:\\n return 0.49\",\n \"def thermal_expansivity_of_air(self) -> float:\\n\\n return 1 / self.ambient_temperature\",\n \"def elo(old, exp, score, k=10):\\n return old + k * (score - exp)\",\n \"def probability(delta_cost: float, temperature: float, k: float = 1) -> float:\\n if delta_cost < 0:\\n return 1\\n else:\\n return np.exp(-delta_cost / (k * temperature))\",\n \"def forward(self):\\n self.iteration_number += 1\\n x = self.x\\n self.x = self.alpha * self.x + self.betta\\n t = x - self.x\\n\\n return (t * t).sum()\",\n \"def powAlpha( n ):\\n return (1-betaval)*Fib(n) + Fib(n-1)\\n #return Fib(n+1) - Fib(n) * betaval\",\n \"def dielectric_constant_water(temperature=298.15):\\n tabulated_data = np.array([[263.15, 92.10],\\n [268.15, 89.96],\\n [273.15, 87.90],\\n [278.15, 85.90],\\n [283.15, 83.96],\\n [288.15, 82.06],\\n [293.15, 80.20],\\n [298.15, 78.38],\\n [303.15, 76.60],\\n [308.15, 74.86],\\n [313.15, 73.17],\\n [318.15, 71.50],\\n [323.15, 69.88],\\n [328.15, 68.29],\\n [333.15, 66.74],\\n [338.15, 65.22],\\n [343.15, 63.73],\\n [348.15, 62.28],\\n [353.15, 60.87],\\n [358.15, 59.48],\\n [363.15, 58.13],\\n [368.15, 56.81],\\n [373.15, 55.51]])\\n polynomal_degree = 5\\n fitdata = np.polyfit(tabulated_data[:, 0], tabulated_data[:, 1],\\n polynomal_degree)\\n fitfunction = np.poly1d(fitdata)\\n return fitfunction(temperature)\",\n \"def exponential(self, data=[], init_lambdas=[1,0.75], max_iteration=500):\\r\\n xaxis = np.arange(1, len(data)+1)\\r\\n data = np.array(data)\\r\\n idx = 1\\r\\n lambdas = np.array(init_lambdas)\\r\\n while idx < max_iteration:\\r\\n y = [lmbda*np.exp(data*(-lmbda)) for lmbda in lambdas]\\r\\n weights = y/np.sum(y, axis=0)\\r\\n coefficients = np.mean(weights, axis=1)\\r\\n lambdas = np.sum(weights, axis=1)/np.sum(weights*data, axis=1)\\r\\n idx+=1 \\r\\n print lambdas, coefficients\\r\\n return lambdas, coefficients\",\n \"def _func_pen(self, coeffs_ext):\\n l_elastic_net = self.l_elastic_net\\n eta = self.eta\\n n_features = self.n_features\\n coeffs = coeffs_ext[:n_features] - coeffs_ext[n_features:]\\n return l_elastic_net * ((1. - eta) * coeffs_ext.sum()\\n + 0.5 * eta * np.linalg.norm(coeffs) ** 2)\",\n \"def oactivate(self,x):\\n value = 1 / (1 + math.exp(-x))\\n if value > 0.5:\\n return 1\\n else:\\n return -1\",\n \"def sigmoidal(min_iterations, i, start = start_temp, final = final_temp ):\\n\\n\\t# to prevent a math overflow a scale (x^(1/ (i - min_iterations))) is used\\n\\ttemperature = final + ((start - final)**( 1/ (i - min_iterations))) / \\\\\\n\\t\\t\\t\\t\\t(1 **(i - min_iterations)) + math.exp(0.3 * ((i - min_iterations / 2) /(i - min_iterations)))\\n\\n\\treturn temperature\",\n \"def exponential_window_lssm(self):\\n self.A = np.array([self.decay])\\n self.s = np.ones(1)\\n self.C = np.ones(1)\",\n \"def set_coefs_decay(self):\\n wt_phenotype = self.epistasis.values[0]\\n for order in range(1, self.epistasis.order + 1):\\n # Get epistasis map for this order.\\n em = self.epistasis.get_orders(order)\\n index = em.index\\n\\n # Randomly choose values for the given order\\n vals = 10**(-order) * np.random.uniform(-wt_phenotype,\\n wt_phenotype,\\n size=len(index))\\n\\n # Map to epistasis object.\\n self.epistasis.data.values[index[0]: index[-1] + 1] = vals\\n self.build()\\n return self\",\n \"def activate(self,x):\\n return 1 / (1 + np.exp(-x))\",\n \"def schechter(l,alpha):\\n return exp(-l)*(l**alpha)\",\n \"def exp_func(x, initial, lifetime):\\n return initial * np.exp(-x/lifetime)\",\n \"def activate_der(self):\\r\\n\\t\\treturn self.value * (1 - self.value)\",\n \"def calculate_energy(self):\\n temp_e = 0\\n\\n for i in range(0,self.neuron_count):\\n for j in range(0, self.neuron_count):\\n if i != j:\\n temp_e += self.get_weight(i, j) * self.current_state[i] * \\\\\\n self.current_state[j]\\n return -1 * temp_e / 2\",\n \"def helmholtzenergy(temp,pres):\\n g = liq_g(0,0,temp,pres)\\n g_p = liq_g(0,1,temp,pres)\\n f = g - pres*g_p\\n return f\",\n \"def test_exp_decay_with_invalid_y(self):\\n x = np.array([9.0e-06, 1.9e-05, 2.9e-05, 3.9e-05])\\n y = np.array([0.16455749, 0.07045296, 0.02702439, -0.00135192])\\n\\n # The last point is excluded. This point might be some artifact due to filtering.\\n alpha_guess = guess.exp_decay(x, y)\\n\\n np.testing.assert_almost_equal(alpha_guess, -90326, decimal=0)\",\n \"def _etaZ(self,x):\\n return self._eta_sfr_scaling(x,'Z_cool')+self._eta_sfr_scaling(x,'Z_hot')\",\n \"def test_exp_osci_decay(self, alpha, freq):\\n x = np.linspace(0, 1, 100)\\n y = np.exp(alpha * x) * np.cos(2 * np.pi * freq * x)\\n\\n alpha_guess = guess.oscillation_exp_decay(x, y)\\n\\n self.assertAlmostEqualAbsolute(alpha_guess, alpha)\",\n \"def update_exponential(self, Z, eta, BDpair=None):\\r\\n if eta == 0:\\r\\n return\\r\\n if BDpair:\\r\\n B, D = BDpair\\r\\n else:\\r\\n D, B = self.opts['CMA_eigenmethod'](self.C)\\r\\n D **= 0.5\\r\\n Csi = dot(B, (B / D).T)\\r\\n Cs = dot(B, (B * D).T)\\r\\n self.C = dot(Cs, dot(Mh.expms(eta * dot(Csi, dot(Z, Csi)), self.opts['CMA_eigenmethod']), Cs))\",\n \"def _etap(self,x):\\n return self._eta_sfr_scaling(x,'p_cool') + self._eta_sfr_scaling(x,'p_hot')\",\n \"def activation_func(x):\\r\\n a = -1\\r\\n return 1/(1+np.exp(-a*x))\",\n \"def adjust_cost(self) -> None:\\n\\n n_iterations = self.array.shape[-1]\\n n_year = len(self.array.year.values)\\n\\n # If uncertainty is not considered, the cost factor equals 1.\\n # Otherwise, a variability of +/-30% is added.\\n\\n if n_iterations == 1:\\n cost_factor = 1\\n else:\\n if \\\"reference\\\" in self.array.value.values.tolist():\\n cost_factor = np.ones((n_iterations, 1))\\n else:\\n cost_factor = np.random.triangular(0.7, 1, 1.3, (n_iterations, 1))\\n\\n # Correction of hydrogen tank cost, per kg\\n # Correction of fuel cell stack cost, per kW\\n if \\\"FCEV\\\" in self.array.powertrain:\\n self.array.loc[\\n dict(powertrain=\\\"FCEV\\\", parameter=\\\"fuel tank cost per kg\\\")\\n ] = np.reshape(\\n (1.078e58 * np.exp(-6.32e-2 * self.array.year.values) + 3.43e2)\\n * cost_factor,\\n (1, n_year, n_iterations),\\n )\\n\\n self.array.loc[\\n dict(powertrain=\\\"FCEV\\\", parameter=\\\"fuel tank cost per kg\\\")\\n ] = np.reshape(\\n (3.15e66 * np.exp(-7.35e-2 * self.array.year.values) + 2.39e1)\\n * cost_factor,\\n (1, n_year, n_iterations),\\n )\\n\\n # Correction of energy battery system cost, per kWh\\n list_batt = [\\n i\\n for i in [\\\"BEV\\\", \\\"PHEV-e\\\", \\\"PHEV-c-p\\\", \\\"PHEV-c-d\\\"]\\n if i in self.array.powertrain\\n ]\\n if len(list_batt) > 0:\\n self.array.loc[\\n dict(powertrain=list_batt, parameter=\\\"energy battery cost per kWh\\\")\\n ] = np.reshape(\\n (2.75e86 * np.exp(-9.61e-2 * self.array.year.values) + 5.059e1)\\n * cost_factor,\\n (1, 1, n_year, n_iterations),\\n )\\n\\n # Correction of power battery system cost, per kW\\n list_pwt = [\\n i\\n for i in [\\n \\\"ICEV-p\\\",\\n \\\"ICEV-d\\\",\\n \\\"ICEV-g\\\",\\n \\\"PHEV-c-p\\\",\\n \\\"PHEV-c-d\\\",\\n \\\"FCEV\\\",\\n \\\"HEV-p\\\",\\n \\\"HEV-d\\\",\\n ]\\n if i in self.array.powertrain\\n ]\\n\\n if len(list_pwt) > 0:\\n self.array.loc[\\n dict(powertrain=list_pwt, parameter=\\\"power battery cost per kW\\\")\\n ] = np.reshape(\\n (8.337e40 * np.exp(-4.49e-2 * self.array.year.values) + 11.17)\\n * cost_factor,\\n (1, 1, n_year, n_iterations),\\n )\\n\\n # Correction of combustion powertrain cost for ICEV-g\\n if \\\"ICEV-g\\\" in self.array.powertrain:\\n self.array.loc[\\n dict(powertrain=\\\"ICEV-g\\\", parameter=\\\"combustion powertrain cost per kW\\\")\\n ] = np.clip(\\n np.reshape(\\n (5.92e160 * np.exp(-0.1819 * self.array.year.values) + 26.76)\\n * cost_factor,\\n (1, n_year, n_iterations),\\n ),\\n None,\\n 100,\\n )\",\n \"def reweight_distribution(original_distribution, temperature=0.5):\\n\\n with warnings.catch_warnings():\\n warnings.simplefilter('ignore')\\n distribution = np.log(original_distribution) / temperature\\n distribution = np.exp(distribution)\\n return distribution / np.sum(distribution)\",\n \"def exp(X):\\n X = np.maximum(X,100)\\n return np.exp(X)\",\n \"def _cross_over(self,mp,cross_rate,eta):\",\n \"def exponential_decay(param: float, decay_factor: float, min_val: float) -> float:\\n if param > min_val:\\n param *= decay_factor\\n param = max(param, min_val)\\n return param\",\n \"def exponential_decay(learning_rate, global_step, decay_steps, decay_rate,\\n staircase=False, name=None):\\n with ops.op_scope([learning_rate, global_step, decay_steps, decay_rate],\\n name, \\\"ExponentialDecay\\\") as name:\\n learning_rate = ops.convert_to_tensor(learning_rate, name=\\\"learning_rate\\\")\\n dtype = learning_rate.dtype\\n global_step = math_ops.cast(global_step, dtype)\\n decay_steps = math_ops.cast(decay_steps, dtype)\\n decay_rate = math_ops.cast(decay_rate, dtype)\\n p = global_step / decay_steps\\n if staircase:\\n p = math_ops.floor(p)\\n return math_ops.mul(learning_rate, math_ops.pow(decay_rate, p), name=name)\",\n \"def cont_ret(self, rate, T, t = 0):\\n return np.exp(rate * (T - t))\",\n \"def energy_function(self, x):\\n \\n return -T.dot(T.transpose(x), T.dot(self.W, x)) -\\\\\\n T.dot(T.transpose(self.b), x)\",\n \"def entropy(temp,pres):\\n g_t = liq_g(1,0,temp,pres)\\n s = -g_t\\n return s\",\n \"def manipulate_heat_data(self): \\n self.exh.T_array = ( 0.5 * (self.exh.T_inlet_array +\\n self.exh.T_outlet_array) + 273.15)\\n self.exh.delta_T_array = ( self.exh.T_inlet_array -\\n self.exh.T_outlet_array )\\n \\n self.cool.delta_T_array = ( self.cool.T_inlet_array -\\n self.cool.T_outlet_array )\\n self.cool.C = self.cool.mdot * self.cool.c_p\",\n \"def wce(B):\\n return eme*B\",\n \"def tempWater(sample):\\n sample *= .0009\\n sample *= 1000\\n celsius = (sample - 20.5128) * 0.0512\\n return round(celsius,2)\",\n \"def zeta(self):\\r\\n raise NotImplementedError('not implemented yet')\",\n \"def half_space_cooling_temperature(z, t, T1, T0, kappa):\\n return [math.erfc(z1 / (2 * numpy.sqrt(kappa * t))) * (T0 - T1) + T1 for z1 in z]\",\n \"def BernoulliExponentialLoss(lamb) :\\n def bexl(x, p) :\\n N = K.int_shape(p)[1]\\n recon = N*metrics.binary_crossentropy(x, p)\\n dkl = K.sum((-1./lamb) + K.log(lamb) - 1, axis=-1)\\n return recon+dkl\\n return bexl\",\n \"def _exponential_backoff(backoff=0.1, max_delay=5):\\n attempt = 0\\n while True:\\n delay = backoff * (2 ** attempt)\\n if delay > max_delay:\\n \\\"\\\"\\\"prevent redundant calculations\\\"\\\"\\\"\\n break\\n attempt += 1\\n yield delay\\n while True:\\n yield max_delay\",\n \"def evaluate(self, _t):\\n\\n temp = self.init_temp*np.exp(-1.0*self.exp_const*_t)\\n\\n if temp < self.min_temp:\\n temp = self.min_temp\\n\\n return temp\",\n \"def DyCheat(x, t, T0, r2, K, alpha, n):\\n D=dmax*x[0]**n/(x[0]**n+K**n)\\n #defune the degradation effect\\n deg=0\\n #define ODEs\\n y=np.zeros([np.size(x)])\\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\\n y[1]=x[1]*(r2*(1-x[1])-D-alpha)#d Co/dt\\n \\n return y\",\n \"def erfc(x):\\n return 0.0\",\n \"def sim_an_exp(neighborhood, Tmax, Tmin, iterations):\\n\\n temp = Tmax\\n\\n # set iteration number to 0 at start\\n n = 0\\n\\n plot_list = []\\n\\n cooling_rate = float(Tmin/Tmax)**(1/iterations)\\n\\n current_costs = neighborhood.get_total_costs()\\n\\n while (n < iterations):\\n temp = Tmax * (float(cooling_rate)**float(n))\\n\\n swap_succes = False\\n while not swap_succes:\\n cable_1 = random.choice(neighborhood.cables)\\n cable_2 = random.choice(neighborhood.cables)\\n swap_succes = neighborhood.swap_connection(cable_1, cable_2)\\n\\n new_costs = neighborhood.get_total_costs()\\n if (acceptance_probability(current_costs, new_costs, temp) > random.random()):\\n current_costs = new_costs\\n else:\\n cable_1 = neighborhood.cables[-1]\\n cable_2 = neighborhood.cables[-2]\\n neighborhood.swap_connection(cable_1, cable_2)\\n\\n plot_list.append(current_costs)\\n n += 1\",\n \"def cost_derivative(output_activations, y):\\n return (output_activations - y)\",\n \"def noiseless_function(x):\\n return 1/(1+np.exp(-x+5))-0.5\",\n \"def _auto_mix(self):\\n gamma = np.random.choice([0.5, 1, 1.5, 2])\\n offset = np.random.uniform(0, self.n * self.dt)\\n empty_window = np.random.uniform(0, self.n * self.dt * 0.5)\\n self.t.sort()\\n self.t[2 * (self.n // 5):4 * (self.n // 5)] *= gamma\\n self.t[3 * (self.n // 5):] += empty_window\\n self._add_irregularities(epsilon=np.random.normal(0,\\n 0.05 * self.dt,\\n self.n))\\n self.t.sort()\\n self._normalize(offset=offset)\",\n \"def _etaM_cool(self,x):\\n return self._eta_sfr_scaling(x,'M_cool')\",\n \"def exp_decr_lr():\\n minlr_div_maxlr = tf.divide(min_lr, max_lr)\\n power_iter = tf.divide(global_step, num_iters)\\n pow_div = tf.pow(minlr_div_maxlr, power_iter)\\n return tf.multiply(max_lr, pow_div, name=name)\",\n \"def anneal_temp(self, T):\\n new_T = self.anneal_rate * T\\n return(new_T)\",\n \"def hot_cold_process(\\n curr_yr,\\n p_cold_rolling_steel,\\n assumptions\\n ):\\n # Reduce demand depending on fraction of hot and cold steel rolling process\\n p_cold_rolling_by = assumptions.p_cold_rolling_steel_by\\n p_hot_rolling_by = 1.0 - p_cold_rolling_by\\n\\n # Current year fractions\\n p_cold_rolling_cy = p_cold_rolling_steel[curr_yr]\\n p_hot_rolling_cy = 1 - p_cold_rolling_cy\\n\\n # Efficiencies of processes\\n eff_cold = assumptions.eff_cold_rolling_process\\n eff_hot = assumptions.eff_hot_rolling_process\\n\\n p_by = p_cold_rolling_by * eff_cold + p_hot_rolling_by * eff_hot\\n p_cy = p_cold_rolling_cy * eff_cold + p_hot_rolling_cy * eff_hot\\n\\n factor = p_cy / p_by\\n\\n return factor\",\n \"def get_evaporation_latent_heat() -> float:\\n theta = 28.0\\n return 2500.8 - 2.3668 * theta\",\n \"def optimal_alpha():\\n\\n # When I checked all of alphas, -0.01 was the best\\n alpha = -0.01\\n # np.random.choice([-0.06, -0.01, 0.04, 0.1])\\n return alpha\",\n \"def eco_temperature_high_c(self) -> float:\\r\\n self._logger.debug(log_message_formatter(\\r\\n \\\"get\\\", f\\\"{self}\\\", \\\"eco_temperature_high_c\\\"))\\r\\n return kelvin_to_celsius(self._eco_temperature_high)\",\n \"def empirical_erm(self):\\n return lambda samples: np.mean(samples) - 0.5 * self.alpha * np.var(samples)\",\n \"def activate(self, x):\\n\\n return 1.0 / (1 + np.exp(-x))\",\n \"def energy_func(self):\\n i = self.inl[0].to_flow()\\n o = self.outl[0].to_flow()\\n\\n T_m = (T_mix_ph(i, T0=self.inl[0].T.val_SI) +\\n T_mix_ph(o, T0=self.outl[0].T.val_SI)) / 2\\n\\n return (i[0] * (o[2] - i[2]) -\\n self.A.val * (\\n self.E.val * self.eta_opt.val -\\n (T_m - self.Tamb.val_SI) * self.lkf_lin.val -\\n self.lkf_quad.val * (T_m - self.Tamb.val_SI) ** 2))\",\n \"def _etaM(self,x):\\n return self._etaM_cool(x) + self._etaM_hot(x)\",\n \"def activation(x):\\n return 1 / (1 + torch.exp(-x))\",\n \"def wind_heat_transfer_coefficient(self) -> float:\\n\\n return 3.8 + 2 * self.wind_speed\\n # return 4.5 + 2.9 * self.wind_speed\",\n \"def E_generator(beta, eta, h):\\n def E(x, y):\\n \\\"\\\"\\\"Calculate energy for matrices x, y.\\n\\n Note: the computation is not localized, so this is quite expensive.\\n \\\"\\\"\\\"\\n # sum of products of neighboring paris {xi, yi}\\n xxm = np.zeros_like(x)\\n xxm[:-1, :] = x[1:, :] # down\\n xxm[1:, :] += x[:-1, :] # up\\n xxm[:, :-1] += x[:, 1:] # right\\n xxm[:, 1:] += x[:, :-1] # left\\n xx = np.sum(xxm * x)\\n xy = np.sum(x * y)\\n xsum = np.sum(x)\\n return h * xsum - beta * xx - eta * xy\\n\\n def is_valid(i, j, shape):\\n \\\"\\\"\\\"Check if coordinate i, j is valid in shape.\\\"\\\"\\\"\\n return i >= 0 and j >= 0 and i < shape[0] and j < shape[1]\\n\\n def localized_E(E1, i, j, x, y):\\n \\\"\\\"\\\"Localized version of Energy function E.\\n\\n Usage: old_x_ij, new_x_ij, E1, E2 = localized_E(Ecur, i, j, x, y)\\n \\\"\\\"\\\"\\n oldval = x[i, j]\\n newval = oldval * -1 # flip\\n # local computations\\n E2 = E1 - (h * oldval) + (h * newval)\\n E2 = E2 + (eta * y[i, j] * oldval) - (eta * y[i, j] * newval)\\n adjacent = [(0, 1), (0, -1), (1, 0), (-1, 0)]\\n neighbors = [x[i + di, j + dj] for di, dj in adjacent\\n if is_valid(i + di, j + dj, x.shape)]\\n E2 = E2 + beta * sum(a * oldval for a in neighbors)\\n E2 = E2 - beta * sum(a * newval for a in neighbors)\\n return oldval, newval, E1, E2\\n\\n return E, localized_E\",\n \"def apply_temperature(prob, temperature):\\r\\n # Apply temperature\\r\\n if temperature != 1:\\r\\n # Inverse sigmoid\\r\\n x = -np.log(1 / prob - 1)\\r\\n # Apply temperature to sigmoid function\\r\\n prob = 1 / (1 + np.exp(-x / temperature))\\r\\n return prob\",\n \"def true_y_exp(x):\\n y = torch.exp(x)#torch.sigmoid(x * 5) * 2 #exp(x)\\n return y\",\n \"def temperature(k, kmax):\\n return 1.0 / 500 * (1.0 / k - 1.0 / kmax)\",\n \"def compute_activation(self):\\r\\n\\r\\n x=0\\r\\n edges=self.in_edges\\r\\n for edge in edges:\\r\\n x+= edge.source.activation*edge.weight\\r\\n self.activation=1/(1+exp(-x))\",\n \"def fun_decay_exp_gen(r0):\\n def fit_fun(p,r):\\n return (p[2] ) * np.exp(-(r-r0)/p[0] ) * np.cos(p[1]*r + p[3]) + (r)*p[4] + p[5]\\n return fit_fun\",\n \"def InitialCondition():\\n maxX = getX(C.N + 1,C.N+1,C.alpha_max)\\n y0 = np.zeros(maxX,dtype=complex)\\n for i in range(0, C.N+2):\\n for j in range(0, C.N+2):\\n for alpha in [1]:\\n\\n X = getX(i, j, alpha)\\n\\n y0[X] = 1./2./C.N * (1-delta(i, C.N+1))*(1-delta(j, C.N+1))+1./2*delta(i, C.N+1)*delta(j, C.N+1) +\\\\\\n 1./2./(C.N)**0.5 * ((1-delta(i, C.N+1)) *\\n delta(j, C.N+1)+(1-delta(j, C.N+1))*delta(i, C.N+1))\",\n \"def calculate_probability(energy, new_energy, temperature):\\n if new_energy < energy:\\n return 1.0\\n else:\\n return exp(float(energy - new_energy) / temperature)\",\n \"def looptcs(self): \\n while self.itr < 1: \\n #self.genRandomNoise() #developing\\n self.tcs(lpf=1)\\n #self.itr +=1 \",\n \"def cool_down(heatmap, amount):\\n heatmap[heatmap <= amount] = 0\\n heatmap[heatmap > amount] -= amount\\n return heatmap\",\n \"def exponential_decay(mul, base, n, min=0.1):\\n return np.vstack([mul * np.power(base, np.arange(n)), [min] * n]).max(0).tolist()\",\n \"def decay(time_, max_time, coeff):\\n threshold = max_time - time_\\n if threshold < 0:\\n threshold = 0\\n return 1 + threshold * coeff / max_time\",\n \"def expansion(temp,pres):\\n g_p = liq_g(0,1,temp,pres)\\n g_tp = liq_g(1,1,temp,pres)\\n alpha = g_tp / g_p\\n return alpha\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65226835","0.63014704","0.613545","0.6096842","0.60904115","0.6022001","0.59910226","0.5871977","0.58546734","0.5735474","0.5727299","0.5672892","0.5629865","0.560521","0.55958956","0.558111","0.5577392","0.5571009","0.5570365","0.5565791","0.5564864","0.55440617","0.5510702","0.5491956","0.54869795","0.5478759","0.54577774","0.5449468","0.54316163","0.5416269","0.54105544","0.5399458","0.53962564","0.53885627","0.5387525","0.53819174","0.5378591","0.5376297","0.53761387","0.53750753","0.5365944","0.53625727","0.53605545","0.5355149","0.5348292","0.5330904","0.53304744","0.5320096","0.53185844","0.5316523","0.53077245","0.530181","0.52954644","0.5283666","0.52827805","0.52816284","0.52811813","0.5279139","0.52788097","0.52787495","0.5277568","0.5270399","0.52694213","0.52615285","0.5247024","0.5232637","0.5223291","0.52184063","0.5216903","0.5207022","0.5206471","0.5206335","0.52059746","0.5198742","0.51969945","0.51948285","0.5194112","0.5192266","0.5191623","0.5191507","0.5190452","0.5187025","0.5186606","0.5183956","0.5180515","0.51804","0.5179708","0.5179696","0.51779604","0.5175868","0.5171944","0.5171571","0.5167037","0.5164892","0.5162909","0.5162442","0.51595646","0.5158774","0.5151048","0.5147539"],"string":"[\n \"0.65226835\",\n \"0.63014704\",\n \"0.613545\",\n \"0.6096842\",\n \"0.60904115\",\n \"0.6022001\",\n \"0.59910226\",\n \"0.5871977\",\n \"0.58546734\",\n \"0.5735474\",\n \"0.5727299\",\n \"0.5672892\",\n \"0.5629865\",\n \"0.560521\",\n \"0.55958956\",\n \"0.558111\",\n \"0.5577392\",\n \"0.5571009\",\n \"0.5570365\",\n \"0.5565791\",\n \"0.5564864\",\n \"0.55440617\",\n \"0.5510702\",\n \"0.5491956\",\n \"0.54869795\",\n \"0.5478759\",\n \"0.54577774\",\n \"0.5449468\",\n \"0.54316163\",\n \"0.5416269\",\n \"0.54105544\",\n \"0.5399458\",\n \"0.53962564\",\n \"0.53885627\",\n \"0.5387525\",\n \"0.53819174\",\n \"0.5378591\",\n \"0.5376297\",\n \"0.53761387\",\n \"0.53750753\",\n \"0.5365944\",\n \"0.53625727\",\n \"0.53605545\",\n \"0.5355149\",\n \"0.5348292\",\n \"0.5330904\",\n \"0.53304744\",\n \"0.5320096\",\n \"0.53185844\",\n \"0.5316523\",\n \"0.53077245\",\n \"0.530181\",\n \"0.52954644\",\n \"0.5283666\",\n \"0.52827805\",\n \"0.52816284\",\n \"0.52811813\",\n \"0.5279139\",\n \"0.52788097\",\n \"0.52787495\",\n \"0.5277568\",\n \"0.5270399\",\n \"0.52694213\",\n \"0.52615285\",\n \"0.5247024\",\n \"0.5232637\",\n \"0.5223291\",\n \"0.52184063\",\n \"0.5216903\",\n \"0.5207022\",\n \"0.5206471\",\n \"0.5206335\",\n \"0.52059746\",\n \"0.5198742\",\n \"0.51969945\",\n \"0.51948285\",\n \"0.5194112\",\n \"0.5192266\",\n \"0.5191623\",\n \"0.5191507\",\n \"0.5190452\",\n \"0.5187025\",\n \"0.5186606\",\n \"0.5183956\",\n \"0.5180515\",\n \"0.51804\",\n \"0.5179708\",\n \"0.5179696\",\n \"0.51779604\",\n \"0.5175868\",\n \"0.5171944\",\n \"0.5171571\",\n \"0.5167037\",\n \"0.5164892\",\n \"0.5162909\",\n \"0.5162442\",\n \"0.51595646\",\n \"0.5158774\",\n \"0.5151048\",\n \"0.5147539\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5585291"},"document_rank":{"kind":"string","value":"15"}}},{"rowIdx":5495,"cells":{"query":{"kind":"string","value":"Calculates new and old K. Checks and accepts better solutions than the current solution. Also sometimes accepts solutions that are worse, depending on the current temperature."},"document":{"kind":"string","value":"def check_solution(self, potential_solution):\n \n old_k = self.K\n new_k = potential_solution.set_K(self.len_connections)\n\n # calculate the probability of accepting this solution \n delta = new_k - old_k\n if delta >= 0: \n probability = 1\n probability = np.exp(delta / self.T)\n\n # pull a random number between 0 and 1 and see if we accept the solution\n if random.random() < probability:\n self.column1.append(self.iteration)\n self.column2.append(new_k)\n self.state = potential_solution\n self.K = new_k\n\n # save progress to a csv file \n with open('annealing.csv', 'w', newline='') as csv_file:\n fieldnames = ['Iterations', 'K']\n writer = csv.DictWriter(csv_file, fieldnames=fieldnames)\n writer.writeheader()\n for i, j in zip(self.column1, self.column2):\n writer.writerow({'Iterations': i, 'K': j})\n\n # update the temperature\n self.update_temperature()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def calc_k(self):\n\t\n\tself.k = -np.array([self.sth*self.cphi, self.sth*self.sphi, self.cth])\n\n\treturn","def obrien_fleming_cutoff(K, current_k, alpha):\n\n if not isinstance(K, int) or K < 1 or K > 10:\n raise ValueError('K must be an integer between 1 and 10.')\n\n if not isinstance(current_k, int) or current_k < 1 or current_k > 10:\n raise ValueError('current_k must be an integer between 1 and 10.')\n if current_k > K:\n raise ValueError('current_k must be less than k.')\n\n if alpha not in [0.01, 0.05, 0.1]:\n raise ValueError('alpha must be 0.01, 0.05, or 0.1.')\n\n cutoffs = {\n \"0.01\": [2.576, 2.580, 2.595, 2.939, 2.986, 3.023, 3.053, 3.078, 3.099, 3.117],\n \"0.05\": [1.960, 2.178, 2.289, 2.361, 2.413, 2.453, 2.485, 2.512, 2.535, 2.555],\n \"0.1\": [1.645, 1.875, 1.992, 2.067, 2.122, 2.164, 2.197, 2.225, 2.249, 2.270],\n }\n return cutoffs[str(alpha)][K - 1] * math.sqrt(K / current_k)","def update_kkrimp_params(self):\n\n decrease_mixing_fac = False\n switch_agressive_mixing = False\n switch_higher_accuracy = False\n initial_settings = False\n\n # only do something other than simple mixing after first kkr run\n if self.ctx.loop_count != 1:\n # first determine if previous step was successful (otherwise try to find some rms value and decrease mixing to try again)\n if not self.ctx.kkr_step_success:\n decrease_mixing_fac = True\n message = 'INFO: last KKR calculation failed. Trying decreasing mixfac'\n self.report(message)\n\n convergence_on_track = self.convergence_on_track()\n\n # check if calculation was on its way to converge\n if not convergence_on_track:\n decrease_mixing_fac = True\n message = 'INFO: Last KKR did not converge. Trying decreasing mixfac'\n self.report(message)\n # reset last_remote to last successful calculation\n last_calcs_list = list(range(len(self.ctx.calcs))) # needs to be list to support slicing\n if len(last_calcs_list) > 1:\n last_calcs_list = array(last_calcs_list)[::-1] # make sure to go from latest calculation backwards\n for icalc in last_calcs_list:\n message = f\"INFO: last calc success? {icalc} {self.ctx.KKR_steps_stats['success'][icalc]}\"\n self.report(message)\n if self.ctx.KKR_steps_stats['success'][icalc]:\n if self.ctx.KKR_steps_stats['last_rms'][icalc] < self.ctx.KKR_steps_stats['first_rms'][icalc]:\n self.ctx.last_remote = self.ctx.calcs[icalc].outputs.remote_folder\n break # exit loop if last_remote was found successfully\n else:\n self.ctx.last_remote = None\n else:\n self.ctx.last_remote = None\n # now cover case when last_remote needs to be set to initial remote folder (from input)\n if self.ctx.last_remote is None:\n if 'kkrimp_remote' in self.inputs:\n messager = 'INFO: no successful and converging calculation to take RemoteData from. Reuse RemoteData from input instead.'\n self.report(message)\n self.ctx.last_remote = self.inputs.kkrimp_remote\n elif 'impurity_info' in self.inputs or 'remote_data' in self.inputs:\n self.ctx.last_remote = None\n # check if last_remote has finally been set and abort if this is not the case\n if self.ctx.last_remote is None:\n messager = 'ERROR: last remote not found'\n self.report(message)\n return self.exit_codes.ERROR_SETTING_LAST_REMOTE # pylint: disable=no-member\n\n # check if mixing strategy should be changed\n last_mixing_scheme = self.ctx.last_params.get_dict()['IMIX']\n if last_mixing_scheme is None:\n last_mixing_scheme = 0\n\n if convergence_on_track:\n last_rms = self.ctx.last_rms_all[-1]\n if last_rms < self.ctx.threshold_aggressive_mixing and last_mixing_scheme == 0:\n switch_agressive_mixing = True\n message = 'INFO: rms low enough, switch to agressive mixing'\n self.report(message)\n\n # check if switch to higher accuracy should be done\n if not self.ctx.kkr_higher_accuracy:\n if self.ctx.kkr_converged: # or last_rms < self.ctx.threshold_switch_high_accuracy:\n switch_higher_accuracy = True\n\n\n# self.report(\"INFO: rms low enough, switch to higher accuracy settings\")\n else:\n initial_settings = True\n self.ctx.kkr_step_success = True\n\n if self.ctx.loop_count > 1:\n last_rms = self.ctx.last_rms_all[-1]\n\n # extract values from host calculation\n host_GF_calc = self.inputs.remote_data.get_incoming(node_class=CalcJobNode).first().node\n host_GF_outparams = host_GF_calc.outputs.output_parameters.get_dict()\n host_GF_inparams = host_GF_calc.inputs.parameters.get_dict()\n nspin = host_GF_outparams.get('nspin')\n non_spherical = host_GF_inparams.get('INS')\n if non_spherical is None:\n non_spherical = kkrparams.get_KKRcalc_parameter_defaults()[0].get('INS')\n self.ctx.spinorbit = host_GF_outparams.get('use_newsosol')\n\n # if needed update parameters\n if decrease_mixing_fac or switch_agressive_mixing or switch_higher_accuracy or initial_settings or self.ctx.mag_init:\n if initial_settings:\n label = 'initial KKR scf parameters'\n description = 'initial parameter set for scf calculation'\n else:\n label = ''\n description = ''\n\n # step 1: extract info from last input parameters and check consistency\n para_check = kkrparams(params_type='kkrimp')\n para_check.get_all_mandatory()\n message = 'INFO: get kkrimp keywords'\n self.report(message)\n\n # init new_params dict where updated params are collected\n new_params = {}\n\n # step 1.2: check if all mandatory keys are there and add defaults if missing\n missing_list = para_check.get_missing_keys(use_aiida=True)\n if missing_list != []:\n kkrdefaults = kkrparams.get_KKRcalc_parameter_defaults()[0]\n kkrdefaults_updated = []\n for key_default, val_default in list(kkrdefaults.items()):\n if key_default in missing_list:\n new_params[key_default] = kkrdefaults.get(key_default)\n kkrdefaults_updated.append(key_default)\n if len(kkrdefaults_updated) > 0:\n self.report('ERROR: no default param found')\n return self.exit_codes.ERROR_MISSING_PARAMS # pylint: disable=no-member\n else:\n message = f'updated KKR parameter node with default values: {kkrdefaults_updated}'\n self.report(message)\n\n # step 2: change parameter (contained in new_params dictionary)\n last_mixing_scheme = para_check.get_value('IMIX')\n if last_mixing_scheme is None:\n last_mixing_scheme = 0\n\n strmixfac = self.ctx.strmix\n aggrmixfac = self.ctx.aggrmix\n nsteps = self.ctx.nsteps\n\n # TODO: maybe add decrease mixing factor option as in kkr_scf wc\n # step 2.1 fill new_params dict with values to be updated\n if decrease_mixing_fac:\n if last_mixing_scheme == 0:\n self.report(f'(strmixfax, mixreduce)= ({strmixfac}, {self.ctx.mixreduce})')\n self.report(f'type(strmixfax, mixreduce)= {type(strmixfac)} {type(self.ctx.mixreduce)}')\n strmixfac = strmixfac * self.ctx.mixreduce\n self.ctx.strmix = strmixfac\n label += f'decreased_mix_fac_str (step {self.ctx.loop_count})'\n description += f'decreased STRMIX factor by {self.ctx.mixreduce}'\n else:\n self.report(f'(aggrmixfax, mixreduce)= ({aggrmixfac}, {self.ctx.mixreduce})')\n self.report(f'type(aggrmixfax, mixreduce)= {type(aggrmixfac)} {type(self.ctx.mixreduce)}')\n aggrmixfac = aggrmixfac * self.ctx.mixreduce\n self.ctx.aggrmix = aggrmixfac\n label += 'decreased_mix_fac_bry'\n description += f'decreased AGGRMIX factor by {self.ctx.mixreduce}'\n\n if switch_agressive_mixing:\n last_mixing_scheme = self.ctx.type_aggressive_mixing\n label += ' switched_to_agressive_mixing'\n description += f' switched to agressive mixing scheme (IMIX={last_mixing_scheme})'\n\n # add number of scf steps, spin\n new_params['SCFSTEPS'] = nsteps\n new_params['NSPIN'] = nspin\n new_params['INS'] = non_spherical\n\n # add ldos runoption if dos_run = True\n if self.ctx.dos_run:\n if self.ctx.lmdos:\n runflags = new_params.get('RUNFLAG', []) + ['lmdos']\n else:\n runflags = new_params.get('RUNFLAG', []) + ['ldos']\n new_params['RUNFLAG'] = runflags\n new_params['SCFSTEPS'] = 1\n\n # turn on Jij calculation if jij_run == True\n if self.ctx.jij_run:\n new_params['CALCJIJMAT'] = 1\n\n # add newsosol\n if self.ctx.spinorbit:\n testflags = new_params.get('TESTFLAG', []) + ['tmatnew']\n new_params['TESTFLAG'] = testflags\n new_params['SPINORBIT'] = 1\n new_params['NCOLL'] = 1\n # TODO add deprecation warning and remove these lines (can be set with params_overwrite instead)\n if self.ctx.mesh_params.get('RADIUS_LOGPANELS', None) is not None:\n new_params['RADIUS_LOGPANELS'] = self.ctx.mesh_params['RADIUS_LOGPANELS']\n if self.ctx.mesh_params.get('NCHEB', None) is not None:\n new_params['NCHEB'] = self.ctx.mesh_params['NCHEB']\n if self.ctx.mesh_params.get('NPAN_LOG', None) is not None:\n new_params['NPAN_LOG'] = self.ctx.mesh_params['NPAN_LOG']\n if self.ctx.mesh_params.get('NPAN_EQ', None) is not None:\n new_params['NPAN_EQ'] = self.ctx.mesh_params['NPAN_EQ']\n new_params['CALCORBITALMOMENT'] = 1\n else:\n new_params['SPINORBIT'] = 0\n new_params['NCOLL'] = 0\n new_params['CALCORBITALMOMENT'] = 0\n new_params['TESTFLAG'] = []\n\n # set mixing schemes and factors\n if last_mixing_scheme > 2:\n new_params['ITDBRY'] = self.ctx.broyden_num\n new_params['IMIX'] = last_mixing_scheme\n new_params['MIXFAC'] = aggrmixfac\n new_params['NSIMPLEMIXFIRST'] = self.ctx.nsimplemixfirst\n elif last_mixing_scheme == 0:\n new_params['IMIX'] = last_mixing_scheme\n new_params['MIXFAC'] = strmixfac\n\n # add mixing scheme to context\n self.ctx.last_mixing_scheme = last_mixing_scheme\n\n if switch_higher_accuracy:\n self.ctx.kkr_higher_accuracy = True\n\n # add convergence settings\n if self.ctx.loop_count == 1 or self.ctx.last_mixing_scheme == 0:\n new_params['QBOUND'] = self.ctx.threshold_aggressive_mixing\n else:\n new_params['QBOUND'] = self.ctx.convergence_criterion\n\n # initial magnetization\n if initial_settings and self.ctx.mag_init:\n if self.ctx.hfield[0] <= 0.0 or self.ctx.hfield[1] == 0:\n self.report(\n '\\nWARNING: magnetization initialization chosen but hfield is zero. Automatically change back to default value (hfield={})\\n'\n .format(self._wf_default['hfield'])\n )\n self.ctx.hfield = self._wf_default['hfield']\n new_params['HFIELD'] = self.ctx.hfield\n elif self.ctx.mag_init and self.ctx.mag_init_step_success: # turn off initialization after first (successful) iteration\n new_params['HFIELD'] = [0.0, 0]\n elif not self.ctx.mag_init:\n self.report(\"INFO: mag_init is False. Overwrite 'HFIELD' to '0.0' and 'LINIPOL' to 'False'.\")\n # reset mag init to avoid resinitializing\n new_params['HFIELD'] = [0.0, 0]\n\n # set nspin to 2 if mag_init is used\n if self.ctx.mag_init:\n nspin_in = nspin\n if nspin_in is None:\n nspin_in = 1\n if nspin_in < 2:\n self.report('WARNING: found NSPIN=1 but for maginit needs NPIN=2. Overwrite this automatically')\n new_params['NSPIN'] = 2\n message = f'new_params: {new_params}'\n self.report(message)\n\n # overwrite values from additional input node\n if 'params_overwrite' in self.inputs:\n print('use params_overwrite', self.inputs.params_overwrite.get_dict())\n self._overwrite_parameters_from_input(new_params)\n\n # step 2.2 update values\n try:\n for key, val in new_params.items():\n para_check.set_value(key, val, silent=True)\n except:\n message = 'ERROR: failed to set some parameters'\n self.report(message)\n return self.exit_codes.ERROR_PARAMETER_UPDATE # pylint: disable=no-member\n\n # step 3:\n message = f'INFO: update parameters to: {para_check.get_set_values()}'\n self.report(message)\n updatenode = Dict(para_check.get_dict())\n updatenode.label = label\n updatenode.description = description\n paranode_new = updatenode #update_params_wf(self.ctx.last_params, updatenode)\n self.ctx.last_params = paranode_new\n else:\n message = 'INFO: reuse old settings'\n self.report(message)\n\n message = 'INFO: done updating kkr param step'\n self.report(message)","def check_solution(self, potential_solution):\n\n old_k = self.K\n new_k = potential_solution.set_K(self.len_connections)\n\n # accept the new state when K is higher\n if new_k > old_k:\n self.state = potential_solution\n self.K = new_k","def ekf(z_k_observation_vector, state_estimate_k_minus_1, control_vector_k_minus_1, P_k_minus_1, dk):\n ######################### Predict #############################\n # Predict the state estimate at time k based on the state\n # estimate at time k-1 and the control input applied at time k-1.\n state_estimate_k = A_k_minus_1 @ (state_estimate_k_minus_1) + (getB(state_estimate_k_minus_1[2],dk)) @ (control_vector_k_minus_1) + (process_noise_v_k_minus_1)\n print(f'State Estimate Before EKF={state_estimate_k}\\r\\n')\n \n # Predict the state covariance estimate based on the previous\n # covariance and some noise\n P_k = A_k_minus_1 @ P_k_minus_1 @ A_k_minus_1.T + (Q_k)\n \n ################### Update (Correct) ##########################\n # Calculate the difference between the actual sensor measurements\n # at time k minus what the measurement model predicted \n # the sensor measurements would be for the current timestep k.\n measurement_residual_y_k = z_k_observation_vector - (\n (H_k @ state_estimate_k) + (\n sensor_noise_w_k))\n \n print(f'Observation={z_k_observation_vector}\\r\\n')\n \n # Calculate the measurement residual covariance\n S_k = H_k @ P_k @ H_k.T + R_k\n \n # Calculate the near-optimal Kalman gain\n # We use pseudoinverse since some of the matrices might be\n # non-square or singular.\n K_k = P_k @ H_k.T @ np.linalg.pinv(S_k)\n \n # Calculate an updated state estimate for time k\n state_estimate_k = state_estimate_k + (K_k @ measurement_residual_y_k)\n \n # Update the state covariance estimate for time k\n P_k = P_k - (K_k @ H_k @ P_k)\n \n # Print the best (near-optimal) estimate of the current state of the robot\n print(f'State Estimate After EKF={state_estimate_k}\\r\\n')\n \n # Return the updated state and covariance estimates\n return state_estimate_k, P_k","def delta_kpoints(self):\n self.get_kpoints('no')\n ori_kp = self.kps\n omk = min(ori_kp)\n nmk = omk+self.diff\n self.kps = [v*nmk/omk for v in ori_kp]\n self.write_output()","def adjust_k(self, ):\n self.iteration += 1\n\n if self.max_violation:\n self.k = 1\n return 1.\n\n self.k = (1.-self.beta**np.float(self.iteration))\n return self.k","def adjust_k(self, ):\n self.iteration += 1\n\n if self.max_violation:\n self.k = 1\n return 1.\n\n self.k = (1.-self.beta**np.float(self.iteration))\n return self.k","def find_k(model, data, tol = 1e-3):\n\n # Store the quantities that never change\n pow_mod = 10 ** model\n\n # Make the array x_k 10 times finer than the tolerance\n step = tol * 0.1\n k_arr = np.arange(0, 1 + step, step)\n\n # Get the x_k array\n x_k = np.array([(1 - k_arr) + k_arr * p for p in pow_mod]).T\n\n # And now the really useful arrays\n coef = (pow_mod - 1)/x_k * 2/np.log(10)\n log_x_k = np.log10(x_k)\n\n # Start with the extremes\n k0 = k_arr[0:1]\n k1 = k_arr[-1:]\n km = (k0 + k1) * 0.5\n\n first = True\n while True:\n\n # Each of the gradients\n gradm = get_one_gradient(k_arr, coef, log_x_k, data, km)\n if first:\n # If first time, we have to calculate everything\n grad0 = get_one_gradient(k_arr, coef, log_x_k, data, k0)\n grad1 = get_one_gradient(k_arr, coef, log_x_k, data, k1)\n\n first = False\n else:\n # Otherwise we can use the previous calculation\n grad0 = (sum0 * gradm + dif0 * grad0) * 0.5\n grad1 = (sum1 * gradm + dif1 * grad1) * 0.5\n\n # Get signs\n sign0 = np.sign(grad0)\n signm = np.sign(gradm)\n sign1 = np.sign(grad1)\n\n # Get differences\n sum0 = np.abs(signm + sign0)\n dif0 = np.abs(signm - sign0)\n sum1 = np.abs(signm + sign1)\n dif1 = np.abs(signm - sign1)\n\n # Vectorized change\n k0 = (sum0 * km + dif0 * k0) * 0.5\n k1 = (sum1 * km + dif1 * k1) * 0.5\n\n # Get the middle point\n new_km = (k0 + k1) * 0.5\n\n # Check if converged\n dif = np.abs(new_km[0] - km[0])\n if dif < tol:\n return new_km\n\n # Update\n km = new_km","def KL_calc(self, Rs, q_mu):\n k_inv_mu = kron_mvp(self.K_invs, self.mu - q_mu)\n mu_penalty = np.sum(np.multiply(self.mu - q_mu, k_inv_mu))\n det_S = self.log_det_S(Rs)\n trace_term = self.calc_trace_term(Rs)[0]\n kl = 0.5 * (self.det_K - self.n - det_S +\n trace_term + mu_penalty)\n return max(0, kl)","def rk8(accel,m,r,h,v): \n k1v = accel(m,r)\n k1r = v\n k2v = accel(m,r + 0.25*k1r*h)\n k2r = v + (0.25*k1v)*h\n k3v = accel(m,r + (5/72.*k1r + 1/72.*k2r)*h)\n k3r = v + (5/72.*k1v + 1/72.*k2v)*h\n k4v = accel(m,r + (1/32.*k1r +3/32.*k3r)*h)\n k4r = v + (1/32.*k1v +3/32.*k3v)*h\n k5v = accel(m,r + (106/125.*k1r- 408/125.*k3r + 352/125.*k4r)*h)\n k5r = v + (106/125.*k1v- 408/125.*k3v + 352/125.*k4v)*h\n k6v = accel(m,r + (1/48.*k1r+ 8/33.*k4r - 125/528.*k5r)*h)\n k6r = v + (1/48.*k1v+ 8/33.*k4v - 125/528.*k5v)*h\n k7v = accel(m,r + (-13893*k1r+ 39936*k4r -64125*k5r+ 60720*k6r)*h/26411.)\n k7r = v +(-13893*k1v+ 39936*k4v -64125*k5v+ 60720*k6v)*h/26411.\n k8v = accel(m,r + (37/392.*k1r+ 1625/9408.*k5r -2/15.*k6r+ 61/6720*k7r)*h)\n k8r = v + (37/392.*k1v+ 1625/9408.*k5v -2/15.*k6v+ 61/6720*k7v)*h\n k9v = accel(m,r +(17176/25515.*k1r - 47104/25515.*k4r + 1325/504.*k5r - 41792/25515.*k6r + 20237/145800.*k7r + 4312/6075.*k8r)*h)\n k9r = v + (17176/25515.*k1v - 47104/25515.*k4v + 1325/504.*k5v - 41792/25515.*k6v + 20237/145800.*k7v + 4312/6075.*k8v)*h\n k10v = accel(m,r + ( -23834/180075.*k1r - 77824/1980825.*k4r- 636635/633864.*k5r + 254048/300125.*k6r - 183/7000.*k7r + 8/11.*k8r - 324/3773.*k9r)*h)\n k10r = v + ( -23834/180075.*k1v - 77824/1980825.*k4v- 636635/633864.*k5v + 254048/300125.*k6v - 183/7000.*k7v + 8/11.*k8v - 324/3773.*k9v)*h\n k11v= accel(m,r + (12733/7600.*k1r - 20032/5225.*k4r + 456485/80256.*k5r - 42599/7125.*k6r + 339227/912000.*k7r - 1029/4108.*k8r + 1701/1408.*k9r + 5145/2432.*k10r)*h)\n k11r = v + (12733/7600.*k1v - 20032/5225.*k4v + 456485/80256.*k5v - 42599/7125.*k6v + 339227/912000.*k7v - 1029/4108.*k8v + 1701/1408.*k9v + 5145/2432.*k10v)*h\n k12v = accel(m,r + h*(-27061/204120.*k1r + 40448/280665.*k4r -1353775/1197504.*k5r + 17662/25515.*k6r - 71687/1166400.*k7r + 98/225.*k8r + 1/16.*k9r + 3773/11664.*k10r))\n k12r = v + h*(-27061/204120.*k1v + 40448/280665.*k4v -1353775/1197504.*k5v + 17662/25515.*k6v - 71687/1166400.*k7v + 98/225.*k8v + 1/16.*k9v + 3773/11664.*k10v)\n k13v = accel(m,r + h*(11203/8680.*k1r - 38144/11935.*k4r + 2354425/458304.*k5r - 84046/16275.*k6r + 673309/1636800.*k7r + 4704/8525.*k8r + 9477/10912.*k9r - 1029/992.*k10r + 19/341.*k12r))\n k13r = v + h*(11203/8680.*k1v - 38144/11935.*k4v + 2354425/458304.*k5v - 84046/16275.*k6v + 673309/1636800.*k7v + 4704/8525.*k8v + 9477/10912.*k9v - 1029/992.*k10v + 19/341.*k12v)\n\n\n new_v8 = v + h*(13/288.*k1v +32/125.*k6v + 31213/144000.*k7v + 2401/12375.*k8v + 1701/14080.*k9v + 2401/19200.*k10v + 19/450.*k11v) \n new_r8 = r + h*(13/288.*k1r +32/125.*k6r + 31213/144000.*k7r + 2401/12375.*k8r + 1701/14080.*k9r + 2401/19200.*k10r + 19/450.*k11r) \n \n return new_v8,new_r8","def energyK(k):\r\n C1 = 9.7846113e-07\r\n C2 = 12.263868e0 \r\n E = (-1.0 + np.sqrt(1.0 + 4.0 * C1 * C2**2 * k**2))/(2.0 * C1)\r\n return E","def _k(self, T):\n RT = Rgas * T\n return (self.parameters.A1 / np.exp(self.parameters.E1 / RT),\n self.parameters.A2 / np.exp(self.parameters.E2 / RT))","def _K_compute_eq(self):\r\n t_eq = self._t[self._index==0]\r\n if self._t2 is None:\r\n if t_eq.size==0:\r\n self._K_eq = np.zeros((0, 0))\r\n return\r\n self._dist2 = np.square(t_eq[:, None] - t_eq[None, :])\r\n else:\r\n t2_eq = self._t2[self._index2==0]\r\n if t_eq.size==0 or t2_eq.size==0:\r\n self._K_eq = np.zeros((t_eq.size, t2_eq.size))\r\n return\r\n self._dist2 = np.square(t_eq[:, None] - t2_eq[None, :])\r\n \r\n self._K_eq = np.exp(-self._dist2/(2*self.lengthscale*self.lengthscale))\r\n if self.is_normalized:\r\n self._K_eq/=(np.sqrt(2*np.pi)*self.lengthscale)","def get_best_k_cv(air_quality_model):\n\n locations = air_quality_model.air_quality_locations\n time_series = air_quality_model.air_quality_time_series\n\n for each_location in locations:\n\n other_locations = [i for i in locations if i != each_location]\n training_time_series = time_series[other_locations]\n scaled_training_time_series = air_quality_model.scaler.transform(training_time_series)\n training_time_series_dropna = scaled_training_time_series.dropna().T\n\n # k means determine k\n distortions = []\n K = range(1, len(other_locations) + 1, 1)\n for k in K:\n kmeans = KMeans(n_clusters=k, max_iter=300).fit(training_time_series_dropna)\n # err = sum(np.min(cdist(training_time_series_dropna, kmeans.cluster_centers_, 'euclidean'), axis=1)) \\\n # / training_time_series_dropna.shape[0]\n\n # Sum of squared distances of samples to their closest cluster center\n err = kmeans.inertia_\n distortions.append(err)\n print(k, dict(zip(other_locations, kmeans.labels_)))\n print(each_location, k, 'err=', err)\n\n # Plot the elbow\n plt.figure(figsize=(15, 20))\n plt.plot(K, distortions, 'bx-')\n plt.xlabel('k')\n plt.ylabel('Distortion')\n plt.title(str(each_location) + ' The Elbow Method showing the optimal k')\n plt.show()","def get_keff(self, take_final=False):\n \n # find max in rec (or final value, don't force as default)\n if take_final:\n _rec_max = self.rec_curve[-1, 1]\n else:\n _rec_max = numpy.max(self.rec_curve[:, 1])\n \n _rec_min = self.rec_curve[0, 1] \n #Bit of a cheat - take the first point. Will be wrong in the case of \n #very fast recovery compared to 1st interval. But in this case, _rec_min and _rec_max \n #should be similar and caught below\n \n if _rec_min > 0.95 * _rec_max:\n print (\"No recovery because too little desensitization (fast limit)\")\n print (\"Setting k_eff = 1000\")\n self.k_eff = 1000 #We could certainly not measure a rate this fast\n \n else:\n _half_rec_amp = _rec_max - 0.5 * (_rec_max - _rec_min)\n _near_idx = (numpy.abs(self.rec_curve[:, 1] - _half_rec_amp)).argmin()\n _near_value = self.rec_curve [_near_idx, 1]\n\n #interpolate\n #must be a smarter way to combine the two possibilities?\n if _near_value > _half_rec_amp:\n #true half time was before our nearest neighbor\n _left = self.rec_curve[_near_idx - 1, 1]\n _right = self.rec_curve[_near_idx, 1]\n _tl = self.rec_curve[_near_idx - 1, 0]\n _tr = self.rec_curve[_near_idx, 0]\n #inverse of time difference scaled by normalized (point-threshold distance)\n self.k_eff = 1 / (_tr - (_tr - _tl) * float(_right - _half_rec_amp)/(_right - _left))\n\n elif _near_value < _half_rec_amp:\n #true half time was after our nearest neighbor\n _left = self.rec_curve[_near_idx, 1]\n _right = self.rec_curve[_near_idx + 1, 1]\n _tl = self.rec_curve[_near_idx, 0]\n _tr = self.rec_curve[_near_idx + 1, 0]\n #as above rearranged to approach from below.\n self.k_eff = 1 / (_tl + (_tr - _tl) * float(_half_rec_amp - _left)/(_right - _left))\n\n elif _near_value == _half_rec_amp:\n\n self.k_eff = 1 / self.rec_curve[near_hi_idx, 0]","def k_Li86(wind_ms, temp_C):\n from numpy import zeros_like\n\n U = wind_ms\n T = temp_C\n\n Sc = schmidt_number(T)\n k = zeros_like(temp_C)\n\n i1 = U <= 3.6\n i2 = (U > 3.6) & (U < 13.0)\n i3 = U >= 13.0\n\n k[i1] = (0.17 * U[i1]) * (Sc[i1] / 600) ** (-2.0 / 3.0)\n k[i2] = ((U[i2] - 3.4) * 2.8) * (600 / Sc[i2]) ** 0.5\n k[i3] = ((U[i3] - 8.4) * 5.9) * (600 / Sc[i3]) ** 0.5\n\n return k","def get_k_gain(self, A, B, Q, R, output = 0):\n\n # solve the Ricatti equation\n X = matrix(scipy.linalg.solve_continuous_are(A, B, Q, R))\n\n # compute the LQR gain\n K = matrix((R)*(B.T*X))\n\n if output:\n print(\"X-axis K Matrix Gains: \")\n print(K[0])\n print(\"Y-axis K Matrix Gains: \")\n print(K[1])\n\n return K","def gather_krec(self):\n \n #getting Qlo and Qhi the wrong way round here gives perfect flat s.s. recovery\n rec1 = Recovery_Qmade(self.m1.param, self.m1.N_states, \n self.m1.open_states, self.m1.Qlo, self.m1.Qhi, self.m1.P_init_hi, t_range=1e4)\n\n rec1.build_curve()\n rec1.get_keff()\n \n rec2 = Recovery_Qmade(self.m2.param, self.m2.N_states, \n self.m2.open_states, self.m2.Qlo, self.m2.Qhi, self.m2.P_init_hi, t_range=1e4)\n\n rec2.build_curve()\n rec2.get_keff()\n \n self.k_eff1 = rec1.k_eff\n self.k_eff2 = rec2.k_eff\n \n self.mean_keff = (rec1.k_eff + rec2.k_eff ) / 2","def test_ks2x(self):\n D, Pval = ks_test(self.x1, self.x2)\n self.assertFloatEqual((D, Pval), (0.46, 3.801e-05), eps=1e-4)\n D, Pval = ks_test(self.x1, self.x2, exact=False)\n self.assertFloatEqual((D, Pval), (0.46, 5.084e-05), eps=1e-4)\n D, Pval = ks_test(self.x1, self.x2[:20])\n self.assertFloatEqual((D,Pval), (0.53, 0.0003576), eps=1e-4)\n D, Pval = ks_test(self.x2[:20], self.x1)\n self.assertFloatEqual((D,Pval), (0.53, 0.0003576), eps=1e-4)\n D, Pval = ks_test(self.x1[:20], self.x2)\n self.assertFloatEqual((D,Pval), (0.48, 0.001772), eps=1e-4)\n D, Pval = ks_test(self.x1, self.x2, alt=\"greater\")\n self.assertFloatEqual((D,Pval), (0.46, 2.542e-05), eps=1e-4)\n D, Pval = ks_test(self.x1, self.x2, alt=\"g\")\n self.assertFloatEqual((D,Pval), (0.46, 2.542e-05), eps=1e-4)\n D, Pval = ks_test(self.x1, self.x2, alt=\"less\")\n self.assertFloatEqual((D,Pval), (6.9388939039072284e-18, 1.), eps=1e-4)\n D, Pval = ks_test(self.x2, self.x1, alt=\"l\")\n self.assertFloatEqual((D,Pval), (0.46, 2.542e-05), eps=1e-4)","def kge(self, return_all=False):\n cc = np.corrcoef(self.true, self.predicted)[0, 1]\n alpha = np.std(self.predicted) / np.std(self.true)\n beta = np.sum(self.predicted) / np.sum(self.true)\n return post_process_kge(cc, alpha, beta, return_all)","def calc_K(tau, delta_t, var_n):\n var_f = 1. - var_n\n rval = var_f * np.exp(-(delta_t)**2 / (2. * tau**2))\n if delta_t == 0:\n rval += var_n\n return rval","def improved_initialization(X, k):\n new_values = X.copy()\n best_like = float('-inf')\n MU, SIGMA, PI = None, None, None\n for _ in range(10):\n initial_means = get_initial_means(new_values, k)\n pi = np.full(k, 1 / k)\n while True:\n mu, clusters = k_means_step(new_values, k, initial_means)\n diff = np.sum(mu - initial_means)\n if not diff:\n sigma = compute_sigma(X, mu)\n break\n initial_means = mu\n mu, sigma, pi, res = train_model(X, k, default_convergence, (mu, sigma, pi))\n lk = likelihood(X, pi, mu, sigma, k)\n if lk > best_like:\n best_like = lk\n MU = mu\n SIGMA = sigma\n PI = pi\n return MU, SIGMA, PI","def compute_kalman_gain(jacobian, oldCovariance, measurementCovariance):\n\n return None","def calibration(N,kb,T,Ekinv,V):\n lamb = np.sqrt((N-1)*3*kb*T/(Ekinv*2))\n \n if lamb < 0.9999:\n V = lamb*V\n elif lamb>1.0001:\n V = lamb*V\n \n return V","def kappas(self):\n a, c, d, b = self.to_ccw()\n p1, q1 = a + b, c + d\n p2, q2 = a + c, b + d\n n = a + b + c + d\n\n if a == n or d == n:\n k0, k1 = np.nan, np.nan\n elif b == n:\n k0, k1 = np.NINF, -0.0\n elif c == n:\n k0, k1 = -0.0, np.NINF\n elif p1 == n or q2 == n:\n k0, k1 = np.nan, 0.0\n elif p2 == n or q1 == n:\n k0, k1 = 0.0, np.nan\n else:\n cov = self.covar()\n p2_q1, p1_q2 = p2 * q1, p1 * q2\n k0, k1 = _div(cov, p2_q1), _div(cov, p1_q2)\n\n return k0, k1, self.kappa()","def metropolis_accept(self, old_protein, new_protein, T):\n delta_E = self.compute_energy(new_protein) - self.compute_energy(old_protein)\n \n if delta_E <= 0: \n p = 1\n else: \n p = math.e**(-delta_E/T)\n return(p)","def KPMO(XVal,YVal_State_1,YVal_State_2,YVal_State_3,XVal_Mean_Trans_1,XVal_Mean_Trans_2,XVal_Sig_Trans_1,XVal_Sig_Trans_2,iOpt):\n#\t1. Computations:\n\tTiny=1E-20\n\tP_Trans_1 = fCPD(XVal,XVal_Mean_Trans_1, XVal_Sig_Trans_1) # Transition of kerogen from State #1 to State #2\n\tP_Trans_2 = fCPD(XVal,XVal_Mean_Trans_2, XVal_Sig_Trans_2) # Transition of kerogen from State #2 to State #3\n\tFunVal=0\n\tif(iOpt==0):\n\t\tP_State_1=(1-P_Trans_1)*(1-P_Trans_2)\n\t\tP_State_2=P_Trans_1*(1 - P_Trans_2)\n\t\tP_State_3=1-P_State_1-P_State_2\n\t\tFunVal=(YVal_State_1*P_State_1)+(YVal_State_2*P_State_2)+(YVal_State_3*P_State_3)\n\tif(iOpt==1):\n\t\tFunVal=YVal_State_1+P_Trans_1*YVal_State_2+P_Trans_2*YVal_State_3\n\tif(FunVal==0):\n\t\tFunVal=Tiny\n\treturn FunVal","def EstimateKFTimeStep(u1,y1,z0,Xxd,Xud,Yx,Yu,P0,Q,R):\n \n # estimate next step\n z1m = Xxd.dot(z0) + Xud.dot(u1)\n y1hat = Yx.dot(z1m) + Yu.dot(u1)\n P1m = (Xxd.dot(P0)).dot(Xxd.T) + Q\n \n # Calculate Kalman gain\n # same as Lk from [1] - And their Rtilde_k is G*P1m*G'+R\n Kk = np.dot(P1m,Yx.T).dot( np.linalg.inv(((Yx.dot(P1m)).dot(Yx.T) + R))) \n # update estimate with measurement\n z1 = z1m + Kk.dot(y1 - y1hat)\n \n P1 = (np.eye(Xxd.shape[0]) - Kk.dot(Yx) ).dot(P1m)\n return z1,P1,Kk","def epsilon_fit_Chang(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_l1,f_l2,f_t1,f_t2,epsinf1,epsinf2):\n # Chang PRB38 12369\n v = 1e4/l_onde\n \n epsx = (epsinf1+epsinf2)/2 - (f_t1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_t2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\n epsz = 1/(((1/2)*(1/epsinf1 + 1/epsinf2)) + (f_l1*(vl1**2 - vt1**2))/(-vl1**2 + v**2 + 1j*v*gl1) + (f_l2*(vl2**2 - vt2**2))/(-vl2**2 + v**2 + 1j*v*gl2))\n \n# eps1 = epsinf1*(1 - (f_t1*(vl1**2 - vt1**2))/(vt1**2 - v**2 - 1j*v*gt1))\n# eps2 = epsinf2*(1 - (f_t2*(vl2**2 - vt2**2))/(vt2**2 - v**2 - 1j*v*gt2))\n# epsx = (1/2)*(eps1+eps2)\n# epsz = 1/((1/2)*(1/eps1 + 1/eps2))\n \n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))","def epsilon_fit_Chang_homemade(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_t1,f_t2,f_l1,f_l2,epsinf1,epsinf2):\n # Chang PRB38 12369\n v = 1e4/l_onde\n \n epsx = (epsinf1+epsinf2)/2 - (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\n epsz = 1/(1/((epsinf1+epsinf2)/2) + (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) + (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2))\n #epsx = (1/2)*(eps1+eps2)\n #epsz = 1/((1/2)*(1/eps1 + 1/eps2))\n \n #epsx = (1/2)*epsinf1*(1-(f_t1*(v**2 - vl1**2 + 1j*v*gl1)/(v**2 - vt1**2 + 1j*v*gt1))-\\\n # (f_t2*(v**2 - vl2**2 + 1j*v*gl2)/(v**2 - vt2**2 + 1j*v*gt2)))\n #epsz = 1/((1/2)*(1/epsinf2)*(1+(f_l1*(v**2 - vt1**2 +1j*v*gl1)/(v**2 - vl1**2 +1j*v*gl1))+\\\n # (f_l2*(v**2 - vt2**2 +1j*v*gl2)/(v**2 - vl2**2 +1j*v*gl2))))\n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))","def test_k_index():\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\n 400.]) * units.hPa\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\n -23.5]) * units.degC\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\n -57.5]) * units.degC\n ki = k_index(pressure, temperature, dewpoint)\n assert_almost_equal(ki, 33.5 * units.degC, 2)","def converged(old, new):\n # https://github.com/amirgholami/PyHessian/commit/0f7e0f63a0f132998608013351ba19955fc9d861#diff-ba06409ffbc677fe556485172e62649fe7a069631390f5a780766bff3289b06bR149-R150 # noqa: B950\n return (old - new).abs() / (old.abs() + 1e-6) < tol","def KRC(self, ik, ipd, ipl, t):\n idx = ik - 1\n\n den1 = 1 - self.delta[idx] * self.coca.PK(ik, t)\n num1 = self.delta[idx] * self.thetak[idx]\n ins = num1 / den1\n\n for l in np.arange(0, self.L):\n pl = self.coca.PL(l, t)\n ins += ((self.thetal[l] * self.gamma[l][idx]) / (1 - pl))\n\n ans = ipd * np.exp(t * ipl) * ins\n\n return ans","def jansky_to_kelvin(self):\n this_unit = self.stokes.unit\n if self.component_type == \"point\":\n if this_unit.is_equivalent(\"K sr\"):\n return\n\n else:\n if this_unit.is_equivalent(\"K\"):\n return\n\n if self.spectral_type == \"spectral_index\" or (\n self.spectral_type == \"flat\" and self.reference_frequency is not None\n ):\n conv_factor = skyutils.jy_to_ksr(self.reference_frequency)\n conv_factor = np.repeat(\n np.repeat(conv_factor[np.newaxis, np.newaxis, :], 4, axis=0),\n self.Nfreqs,\n axis=1,\n )\n elif self.freq_array is not None:\n conv_factor = skyutils.jy_to_ksr(self.freq_array)\n conv_factor = np.repeat(\n np.repeat(conv_factor[np.newaxis, :, np.newaxis], 4, axis=0),\n self.Ncomponents,\n axis=2,\n )\n else:\n raise ValueError(\n \"Either reference_frequency or freq_array must be set to convert to K.\"\n )\n\n self.stokes = self.stokes * conv_factor\n if self.stokes_error is not None:\n self.stokes_error = self.stokes_error * conv_factor\n\n if self.frame_coherency is not None:\n self.calc_frame_coherency()","def test_calc_k_c():\n\n P_x0 = ufloat(1.75789868673e-12, 1.75789868673e-14) * u.nm**2/u.Hz # 1/100\n f_c = ufloat(50000, 0.5) * u.Hz # 1/100000 relative\n Q = ufloat(10000, 100) * u.dimensionless # 1/100\n T = ufloat(300, 3) * u.K # 1/100\n # ex_k_c is no longer a nice number because I switched from a rounded to\n # more exact value for Boltzmann's constant\n ex_k_c = ufloat(2.9999965233852217, 0.05196147267057527) * u.N/u.m\n k_c = calc_k_c(f_c, Q, P_x0, T)\n assert_almost_equal(k_c.magnitude.n, ex_k_c.magnitude.n)\n assert_almost_equal(k_c.magnitude.s, ex_k_c.magnitude.s)","def advance(self):\n\n f, n, rtol, atol, neq = \\\n self.f, self.n, self.rtol, self.atol, self.neq\n u_n, t_n, t_next = self.u[n], self.t[n], self.t[n+1]\n dt = t_next - t_n\n\n first_step = dt # try one big step to next desired level\n\n def middle(x,y,z): # Auxilary function\n return sorted([x,y,z])[1]\n\n # Extract coefficients from Butcher-tableau\n table = self._butcher_tableau\n k_len = table.shape[1] - 1 # number of internal stages\n\n # coefficients for internal stages\n factors_u = np.asarray(table[:k_len, 1:])\n # coefficients for t\n factors_t = table[:k_len, 0]\n # coefficients for u_new\n factors_u_new = table[k_len, 1:]\n\n # coefficients for local error between 2 levels\n factors_error = table[k_len+1, 1:] - factors_u_new\n\n u_intermediate = [u_n,]\n t_intermediate = [t_n,]\n u, t, h = u_n, t_n, first_step # initial values\n k = np.zeros((k_len, self.neq), self.dtype) # intern stages\n\n if self.verbose > 0:\n print 'advance solution in [%s, %s], h=%g' % (t_n, t_next, h)\n\n # Loop until next time point is reached\n while (abs(t - t_n) < abs(t_next - t_n)):\n u, t = u_intermediate[-1], t_intermediate[-1]\n\n # Internal steps\n k[:, :] = 0. # initialization for next step\n for m in range(k_len):\n k_factors = (np.dot(factors_u, k))[m]\n #print u, u+h*k_factors, f(u+h*k_factor, 0.5), self.dtype\n k[m] = f(u+h*k_factors, t+h*factors_t[m])\n u_new = u + h*(np.dot(factors_u_new, k))\n\n self.info['rejected'] += 1 # reduced below if accepted\n if self.verbose > 0:\n print ' u(t=%g)=%g: ' % (t+h, u_new),\n\n # local error between 2 levels\n error = h*np.abs(np.dot(factors_error, k))\n # Acceptable error tolerance\n tol = rtol*np.abs(u_new) + atol\n\n accurate = (error <= tol).all()\n\n if accurate or h <= self.min_step or h >= self.max_step:\n # Accurate enough,\n # or the step size exceeds valid range,\n # must accept this solution\n u_intermediate.append(u_new)\n t_intermediate.append(t+h)\n if not self.disk_storage:\n self.u_all.append(u_new)\n self.t_all.append(t+h)\n self.info['rejected'] -= 1\n\n if self.verbose > 0:\n print 'accepted, ',\n else:\n if self.verbose > 0:\n print 'rejected, ',\n\n if self.verbose > 0:\n print 'err=%s, ' % str(error),\n if hasattr(self, 'u_exact') and callable(self.u_exact):\n print 'exact-err=%s, ' % \\\n (np.asarray(self.u_exact(t+h))-u_new),\n if h <= self.min_step:\n print 'h=min_step!! ',\n\n\n # Replace 0 values by 1e-16 since we will divide by error\n error = np.asarray([(1e-16 if x == 0. else x) \\\n for x in error])\n\n # Normarized error rate\n rms = error/tol\n rms_norm = np.sqrt(np.sum(rms*rms)/self.neq)\n\n order = float(self._method_order[0])\n # factor to adjust the size of next step\n # Formula is from <Numerical Methods for Engineers,\n # Chappra & Cannle>\n s = .8 *((1./rms_norm)**(1/order))\n # scalar should be in range(0.1, 4.)\n # for better accuracy and smoothness\n s = middle(s, 0.1, 4.0)\n h *= s\n\n # step size should be in range [min_step, max_step]\n h = middle(h, self.min_step, self.max_step)\n # adjust h to fit the last step\n h = min(h, t_next - t_intermediate[-1])\n\n if self.verbose > 0:\n print 'new h=%g' % h\n\n if h == 0:\n break\n\n return u_new","def k_Sw07(wind_second_moment, temp_C):\n\n U2 = wind_second_moment\n\n Sc = schmidt_number(temp_C)\n k = (0.27 * U2) * (660 / Sc) ** 0.5\n\n return k","def check_solution(self, new_protein):\n new_score = new_protein.getscore()\n old_value = self.best_value\n\n if new_score >= old_value:\n self.best_solution = new_protein\n self.best_value = new_score","def _adjust_k(scheme, k, ef=EF):\n scheme = rx.core._check_scheme(scheme) # noqa: SLF001\n is_half_equilibrium = np.asarray(scheme.is_half_equilibrium)\n k = np.asarray(k, dtype=np.float64).copy()\n\n if np.any(is_half_equilibrium):\n # at least one equilibrium\n if np.any(~is_half_equilibrium):\n # at least one true reaction\n\n k_slowest_equil = k[is_half_equilibrium].min()\n k_fastest_react = k[~is_half_equilibrium].max()\n adjustment = ef * (k_fastest_react / k_slowest_equil)\n\n k[is_half_equilibrium] *= adjustment\n logger.warning(f\"equilibria adjustment = {adjustment}\") # noqa: G004\n\n k_slowest_equil = k[is_half_equilibrium].min()\n k_fastest_react = k[~is_half_equilibrium].max()\n logger.warning(\n f\"slow eq. / fast r. = {k_slowest_equil / k_fastest_react}\", # noqa: E501, G004\n )\n else:\n # only equilibria\n\n # set the smallest one to be equal to one\n k = k / k.min()\n\n return jnp.asarray(k)","def SSt_theo_old(D, k):\n\ta1b = k[\"A1B1\"]\n\tba1 = k[\"B1A1\"]\n\tca1 = k[\"C1A1\"]\n\tcb = k[\"B1C1\"]\n\tnum = a1b*ba1*ca1*ca1 + ba1*ba1*ca1*ca1 + 3*a1b*ba1*ca1*cb + 2*ba1*ba1*ca1*cb + \\\n\t\t\ta1b*ca1*ca1*cb + 2*ba1*ca1*ca1*cb + 2*a1b*ba1*cb*cb + ba1*ba1*cb*cb + \\\n\t\t\t2*a1b*ca1*cb*cb + 2*ba1*ca1*cb*cb + ca1*ca1*cb*cb + \\\n\t\t\t\\\n\t\t\t(a1b*ba1*ba1*ca1 + ba1*ba1*ba1*ca1 + a1b*ba1*ca1*ca1 + a1b*ca1*ca1*ca1 + \\\n\t\t\t3*ba1*ca1*ca1*ca1 + 2*a1b*ba1*ba1*cb + ba1*ba1*ba1*cb + 2*a1b*ba1*ca1*cb + \\\n\t\t\t3*ba1*ba1*ca1*cb + 4*a1b*ca1*ca1*cb + 5*ba1*ca1*ca1*cb + 3*ca1*ca1*ca1*cb + \\\n\t\t\t2*a1b*ba1*cb*cb + 2*ba1*ba1*cb*cb + 2*a1b*ca1*cb*cb + 4*ba1*ca1*cb*cb + \\\n\t\t\t2*ca1*ca1*cb*cb) * D + \\\n\t\t\t\\\n\t\t\t(a1b*ba1*ba1*ca1 + a1b*ba1*ca1*ca1 + 4*ba1*ba1*ca1*ca1 + a1b*ca1*ca1*ca1 + \\\n\t\t\t2*ca1*ca1*ca1*ca1 + ba1*ba1*ba1*cb + 3*a1b*ba1*ca1*cb + 3*ba1*ba1*ca1*cb + \\\n\t\t\ta1b*ca1*ca1*cb + 5*ba1*ca1*ca1*cb + 3*ca1*ca1*ca1*cb + ba1*ba1*cb*cb + \\\n\t\t\t2*ba1*ca1*cb*cb + ca1*ca1*cb*cb) * D*D + \\\n\t\t\t\\\n\t\t\t(ba1*ba1*ba1*ca1 + a1b*ba1*ca1*ca1 + 3*ba1*ca1*ca1*ca1 + 2*ba1*ba1*ca1*cb + \\\n\t\t\t2*ba1*ca1*ca1*cb) * D*D*D + \\\n\t\t\t\\\n\t\t\tba1*ba1*ca1*ca1 * D*D*D*D\n\t##\n\tden = a1b*(ba1*ba1*ca1*ca1 + 2*ba1*ba1*ca1*cb + 2*ba1*ca1*ca1*cb + ba1*ba1*cb*cb + \n\t\t\t2*ba1*ca1*cb*cb + ca1*ca1*cb*cb) + \\\n\t\t\t\\\n\t\t\ta1b*(4*ba1*ca1*ca1*ca1 + 2*ba1*ba1*ca1*cb + 6*ba1*ca1*ca1*cb + 4*ca1*ca1*ca1*cb + \n\t\t\t2*ba1*ba1*cb*cb + 4*ba1*ca1*cb*cb + 2*ca1*ca1*cb*cb) * D + \\\n\t\t\t\\\n\t\t\ta1b*(2*ba1*ba1*ca1*ca1 + 4*ca1*ca1*ca1*ca1 + 2*ba1*ba1*ca1*cb + 6*ba1*ca1*ca1*cb + \n\t\t\t4*ca1*ca1*ca1*cb + ba1*ba1*cb*cb + 2*ba1*ca1*cb*cb + ca1*ca1*cb*cb) * D*D + \\\n\t\t\t\\\n\t\t\ta1b*(4*ba1*ca1*ca1*ca1 + 2*ba1*ba1*ca1*cb + 2*ba1*ca1*ca1*cb) * D*D*D + \\\n\t\t\t\\\n\t\t\ta1b*ba1*ba1*ca1*ca1 * D*D*D*D\n\t##\n\ttau = num/den\n\t##\n\treturn tau*np.log(20)","def test_ks2x(self):\n D, Pval = ks_test(self.x1, self.x2)\n assert_allclose((D, Pval), (0.46, 3.801e-05), rtol=1e-4)\n D, Pval = ks_test(self.x1, self.x2, exact=False)\n assert_allclose((D, Pval), (0.46, 5.084e-05), rtol=1e-4)\n D, Pval = ks_test(self.x1, self.x2[:20])\n assert_allclose((D, Pval), (0.53, 0.0003576), rtol=1e-4)\n D, Pval = ks_test(self.x2[:20], self.x1)\n assert_allclose((D, Pval), (0.53, 0.0003576), rtol=1e-4)\n D, Pval = ks_test(self.x1[:20], self.x2)\n assert_allclose((D, Pval), (0.48, 0.001772), rtol=1e-3)\n D, Pval = ks_test(self.x1, self.x2, alt=\"greater\")\n assert_allclose((D, Pval), (0.46, 2.542e-05), rtol=1e-4)\n D, Pval = ks_test(self.x1, self.x2, alt=\"g\")\n assert_allclose((D, Pval), (0.46, 2.542e-05), rtol=1e-4)\n D, Pval = ks_test(self.x1, self.x2, alt=\"less\")\n assert_allclose((D, Pval), (6.9388939039072284e-18, 1.0), rtol=1e-4)\n D, Pval = ks_test(self.x2, self.x1, alt=\"l\")\n assert_allclose((D, Pval), (0.46, 2.542e-05), rtol=1e-4)","def adjust_k(epoch, initial_k, increase_k, max_violation=False):\n if max_violation:\n return 1.\n\n return min(initial_k + (increase_k * epoch), 1.)","def kl(self, old_dist_info, new_dist_info):\n old_prob = old_dist_info[\"prob\"]\n new_prob = new_dist_info[\"prob\"]\n return np.sum(\n old_prob * (np.log(old_prob + TINY) - np.log(new_prob + TINY)),\n axis=2\n )","def kf_algorithm(self, u, y):\n # For the linear filter, x_estimated_state is the difference to the operating point\n cov_matrix_before = self.cov_matrix\n # 0. Calculate difference to operating point\n u = u - self.u_op\n if self.model_type == ModelType.EASY:\n x_est_before = self.x_estimated_state - self.operating_point[0:6].reshape((6, 1))\n # x_est_before.reshape((6, 1))\n else:\n x_est_before = self.x_estimated_state - self.operating_point.reshape((8, 1))\n # x_est_before.reshape((8, 1))\n if self.nOutputs == 3:\n y = y - self.operating_point[0:3].reshape(3, 1)\n elif self.nOutputs == 5:\n y = y - np.concatenate((self.operating_point[0:3], self.operating_point[6:8])).reshape(5, 1)\n # x_est_before = self.x_estimated_state - self.operating_point\n # 1. Prediction\n # predict the state by using the linearized system at the fixed operating point\n v_s = u[0][0] + u[1][0]\n v_d = u[0][0] - u[1][0]\n x_est_predict = self.Ak @ x_est_before + self.Bk @ u\n # predict the new covariance\n cov_matrix_predict = (self.Ak @ cov_matrix_before @ np.transpose(self.Ak)\n + self.Bk @ self.N @ np.transpose(self.Bk))\n # 2. Update\n # compute kalman gain\n Kl = (cov_matrix_predict @ np.transpose(self.Ck) @\n np.linalg.inv(self.Ck @ cov_matrix_predict @ np.transpose(self.Ck) + self.W))\n # update state\n if self.nOutputs == 3:\n y_est = x_est_predict[0:3,]\n elif self.nOutputs == 5:\n y_est = np.concatenate((x_est_predict[0:3], x_est_predict[6:8]))\n x_est_update = x_est_predict + Kl @ (y - y_est)\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ self.Ck) @ cov_matrix_predict\n # add again the operating point\n if self.model_type == ModelType.EASY:\n x_estimated_state = x_est_update + self.operating_point[0:6].reshape((6, 1))\n # self.x_estimated_state = x_estimated_state.reshape((1, 6))[0]\n else:\n x_estimated_state = x_est_update + self.operating_point.reshape((8, 1))\n # self.x_estimated_state = x_estimated_state.reshape((1, 8))[0]\n\n if self.should_check_limits:\n # check if the update step state needs to be changed because of limit crossing\n # if that is the case, correct the state and set the state of the simulation accordingly\n corrected_state = self.heliSim.get_limited_state_and_change_state_without_sim(np.transpose(x_estimated_state)[0],\n self.model_type)\n x_estimated_state = np.resize(corrected_state, (self.nStateVars, 1))\n self.x_estimated_state = x_estimated_state\n self.cov_matrix = cov_matrix_update\n # print(\"------\")\n # print(cov_matrix_predict)\n return x_estimated_state","def K(self, X, Xstar):\n r = l2norm_(X, Xstar)\n bessel = kv(self.v, np.sqrt(2 * self.v) * r / self.l)\n f = 2 ** (1 - self.v) / gamma(self.v) * (np.sqrt(2 * self.v) * r / self.l) ** self.v\n res = f * bessel\n res[np.isnan(res)] = 1\n res = self.sigmaf * res + self.sigman * kronDelta(X, Xstar)\n return (res)","def test_klauder(self):\n ideal = np.array([0.14899879, -0.16633309, -0.42806931, 0.16605633,\n 0.70769336, 0.16605633, -0.42806931, -0.16633309])\n actual = misc.klauder(8)\n np.testing.assert_allclose(ideal, actual, atol=1e-8, rtol=1e-8)","def get_old_solution(self, x, k=None, get_ctrl_traj=False):\n if self.n_fail > self.n_safe:\n warnings.warn(\n \"There are no previous solution to be applied. Returning None\")\n return None\n if k is None:\n k = self.n_fail\n\n if k < 1:\n warnings.warn(\"Have to shift at least one timestep back\")\n return None\n\n k_fb_old = self.k_fb_safe_all[k - 1]\n k_ff = self.k_ff_safe[k - 1, :, None]\n p_safe = self.p_safe[k - 1, :, None]\n\n u_apply = feedback_ctrl(x, k_ff, k_fb_old, p_safe)\n if get_ctrl_traj:\n k_fb_safe_traj = None\n k_ff_safe_traj = u_apply\n p_ctrl_safe_traj = None\n\n if k < self.n_safe:\n k_fb_safe_traj = self.k_fb_safe_all[k:, :]\n # in accordance to the structure current ctrl u_apply is part of the k_ff ctrl trajectory\n k_ff_safe_traj = np.vstack((u_apply, self.k_ff_safe[k + 1:, :]))\n p_ctrl_safe_traj = self.p_safe[k:, :]\n\n return u_apply, k_fb_safe_traj, \\\n k_ff_safe_traj, p_ctrl_safe_traj\n\n return u_apply","def diff_k_p1(p1, p2, t=0.):\n return p1","def _calc_k_gain(self, cov_m, h_tilde, R_cov):\n B = np.matmul(cov_m, np.transpose(h_tilde))\n G = np.matmul(h_tilde, np.matmul(cov_m,\n np.transpose(h_tilde)))\n T = np.linalg.inv(np.add(G, R_cov))\n\n return np.matmul(B, T)","def calc_ST_operation(m_exhaust_GT_kgpers, T_exhaust_GT_K, T_sup_K, fuel_type):\n\n # calaulate High Pressure (HP) and Low Pressure (LP) mass flow of a double pressure steam turbine\n temp_i_K = (0.9 * ((6 / 48.2) ** (0.4 / 1.4) - 1) + 1) * (T_exhaust_GT_K - ST_DELTA_T)\n if fuel_type == 'NG':\n Mexh = 103.7 * 44E-3 + 196.2 * 18E-3 + 761.4 * 28E-3 + 200.5 * (CC_AIRRATIO - 1) * 32E-3 \\\n + 200.5 * (CC_AIRRATIO - 1) * 3.773 * 28E-3\n ncp_exh = 103.7 * 44 * 0.846 + 196.2 * 18 * 1.8723 + 761.4 * 28 * 1.039 \\\n + 200.5 * (CC_AIRRATIO - 1) * 32 * 0.918 + 200.5 * (CC_AIRRATIO - 1) * 3.773 * 28 * 1.039\n cp_exh = ncp_exh / Mexh # J/kgK\n else:\n Mexh = 98.5 * 44E-3 + 116 * 18E-3 + 436.8 * 28E-3 + 115.5 * (CC_AIRRATIO - 1) * 32E-3 \\\n + 115.5 * (CC_AIRRATIO - 1) * 3.773 * 28E-3\n ncp_exh = 98.5 * 44 * 0.846 + 116 * 18 * 1.8723 + 436.8 * 28 * 1.039 \\\n + 115.5 * (CC_AIRRATIO - 1) * 32 * 0.918 + 115.5 * (CC_AIRRATIO - 1) * 3.773 * 28 * 1.039\n cp_exh = ncp_exh / Mexh # J/kgK\n\n a = np.array([[1653E3 + HEAT_CAPACITY_OF_WATER_JPERKGK * (T_exhaust_GT_K - ST_DELTA_T - 534.5), \\\n HEAT_CAPACITY_OF_WATER_JPERKGK * (temp_i_K - 534.5)], \\\n [HEAT_CAPACITY_OF_WATER_JPERKGK * (534.5 - 431.8), \\\n 2085.8E3 + HEAT_CAPACITY_OF_WATER_JPERKGK * (534.5 - 431.8)]])\n b = np.array([m_exhaust_GT_kgpers * cp_exh * (T_exhaust_GT_K - (534.5 + ST_DELTA_T)), \\\n m_exhaust_GT_kgpers * cp_exh * (534.5 - 431.8)])\n [mdotHP_kgpers, mdotLP_kgpers] = np.linalg.solve(a, b)\n\n # calculate thermal output\n T_cond_0_K = T_sup_K + CC_DELTA_T_DH # condensation temperature constrained by the DH network temperature\n pres0 = (0.0261 * (T_cond_0_K - 273) ** 2 - 2.1394 * (T_cond_0_K - 273) + 52.893) * 1E3\n\n delta_h_evap_Jperkg = (-2.4967 * (T_cond_0_K - 273) + 2507) * 1E3\n q_output_ST_W = (mdotHP_kgpers + mdotLP_kgpers) * delta_h_evap_Jperkg # thermal output of ST\n\n # calculate electricity output\n h_HP_Jperkg = (2.5081 * (T_exhaust_GT_K - ST_DELTA_T - 273) + 2122.7) * 1E3 # J/kg\n h_LP_Jperkg = (2.3153 * (temp_i_K - 273) + 2314.7) * 1E3 # J/kg\n h_cond_Jperkg = (1.6979 * (T_cond_0_K - 273) + 2506.6) * 1E3 # J/kg\n\n el_produced_ST_W = mdotHP_kgpers * (h_HP_Jperkg - h_LP_Jperkg) + \\\n (mdotHP_kgpers + mdotLP_kgpers) * (h_LP_Jperkg - h_cond_Jperkg) # turbine electricity output\n\n el_input_compressor_W = SPEC_VOLUME_STEAM * (\n mdotLP_kgpers * (6E5 - pres0) + (mdotHP_kgpers + mdotLP_kgpers) * (48.2E5 - 6E5)) # compressor electricity use\n\n el_output_ST_W = ST_GEN_ETA * (el_produced_ST_W - el_input_compressor_W) # gross electricity production of turbine\n\n return q_output_ST_W, el_output_ST_W","def k_Wa92(wind_second_moment, temp_C):\n\n U2 = wind_second_moment\n\n Sc = schmidt_number(temp_C)\n k = (0.31 * U2) * (660 / Sc) ** 0.5\n\n return k","def kl_sym(self, old_dist_info_vars, new_dist_info_vars):\n old_prob_var = old_dist_info_vars[\"prob\"]\n new_prob_var = new_dist_info_vars[\"prob\"]\n # Assume layout is N * T * A\n return tf.reduce_sum(\n old_prob_var * (tf.log(old_prob_var + TINY) - tf.log(new_prob_var + TINY)),\n axis=2\n )","def temperature(k, kmax):\n return 1.0 / 500 * (1.0 / k - 1.0 / kmax)","def __kappa_mle(self, k, R):\n return (iv(1, k) / iv(0, k)) - R","def quasi_optimalityTV(f, lam_init = 2.0, q = 0.9):\n \n lam = lam_init\n max_iter = 50\n error = np.zeros(max_iter)\n #alt_error = np.zeros(max_iter)\n u_old = ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\n for i in range(1, max_iter):\n lam = lam_init * (q ** i)\n u_new = ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\n error[i] = np.linalg.norm(u_old - u_new)\n #alt_error[i] = np.linalg.norm(u_old - u_new) /abs(lam_init*(q ** i - q ** (i-1)))\n u_old = np.copy(u_new)\n\n #plt.plot(error)\n #plt.plot(alt_error)\n #plt.show()\n opt_idx = np.argmin(error[error != 0.0])\n t = 1.0 / (1.0 + lam_init * (q ** opt_idx))\n lam = lam_init * (q ** opt_idx)\n u= ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\n \n return u, t","def initial_estimator(f, x, step,k):\n\n fx = f(x)\n\n if decide(fx > 0):\n sign1 = 1\n else:\n sign1 = -1\n k_step = k\n h = fx / derivative(f, x)\n\n for k1 in range(1, 50000):\n step = step + 1\n x_new = x - k_step * h\n k_step = k_step * 2 # make the k double in each iteration\n fx_new = f(x_new)\n if decide(fx_new > 0):\n sign2 = 1\n else:\n sign2 = -1\n\n if not (sign1 == sign2):\n return x_new, step\n\n print(\"limit need to Increase\")","def elo(old, exp, score, k=10):\n return old + k * (score - exp)","def ekf_algorithm(self, u, y):\n x_est_before = self.x_estimated_state\n cov_matrix_before = self.cov_matrix\n # 1. Prediction\n # predict the state by integrate the time continuous system numerically\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\n x_est_predict = np.resize(sim_state_predict, (8, 1))\n # predict the new covariance by linearizing and discretizing the model\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\n # 2. Update\n # compute kalman gain\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\n # update state\n y_est = x_est_predict[0:3]\n x_est_update = x_est_predict + Kl @ (y - y_est)\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\n\n # check if the update step state needs to be changed because of limit crossing\n # if that is the case, correct the state and set the state of the simulation accordingly\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 8))[0],\n ModelType.GYROMOMENT)\n x_est_update = np.resize(corrected_state, (8, 1))\n\n self.x_estimated_state = x_est_update\n self.cov_matrix = cov_matrix_update\n # print(\"------\")\n # print(cov_matrix_predict)\n return x_est_update","def calc_q_gain(Tfl, Tabs, q_rad_Whperm2, DT, Tin, Tout, aperture_area_m2, c1, c2, Mfl, delts, Cp_waterglycol, C_eff, Te):\n\n xgain = 1\n xgainmax = 100\n exit = False\n while exit == False:\n qgain_Whperm2 = q_rad_Whperm2 - c1 * (DT[1]) - c2 * abs(DT[1]) * DT[1] # heat production from solar collector, eq.(5)\n\n if Mfl > 0:\n Tout = ((Mfl * Cp_waterglycol * Tin) / aperture_area_m2 - (C_eff * Tin) / (2 * delts) + qgain_Whperm2 + (\n C_eff * Tfl[1]) / delts) / (Mfl * Cp_waterglycol / aperture_area_m2 + C_eff / (2 * delts)) # eq.(6)\n Tfl[2] = (Tin + Tout) / 2\n DT[2] = Tfl[2] - Te\n qdiff = Mfl / aperture_area_m2 * Cp_waterglycol * 2 * (DT[2] - DT[1])\n else:\n Tout = Tfl[1] + (qgain_Whperm2 * delts) / C_eff # eq.(8)\n Tfl[2] = Tout\n DT[2] = Tfl[2] - Te\n qdiff = 5 * (DT[2] - DT[1])\n\n if abs(qdiff < 0.1):\n DT[1] = DT[2]\n exit = True\n else:\n if xgain > 40:\n DT[1] = (DT[1] + DT[2]) / 2\n if xgain == xgainmax:\n exit = True\n else:\n DT[1] = DT[2]\n xgain += 1\n\n # FIXME: redundant...\n # qout = Mfl * Cp_waterglycol * (Tout - Tin) / aperture_area\n # qmtherm = (Tfl[2] - Tfl[1]) * C_eff / delts\n # qbal = qgain - qout - qmtherm\n # if abs(qbal) > 1:\n # qbal = qbal\n return qgain_Whperm2","def test_thermal_relaxation_error_kraus(self):\n t1, t2, time, p1 = (1, 2, 1, 0.3)\n error = thermal_relaxation_error(t1, t2, time, p1)\n circ, p = error.error_term(0)\n self.assertEqual(p, 1)\n self.assertEqual(circ[0]['name'], 'kraus')\n self.assertEqual(circ[0]['qubits'], [0])","def obrien_fleming_test(z, K, current_k, alpha):\n c = obrien_fleming_cutoff(K, current_k, alpha)\n return c < abs(z)","def calculate_kl(self, old_policy, new_policy, obs):\n # _, logp0 = old_policy(obs, act)\n # logp0 = logp0.detach()\n # _, logp1 = new_policy(obs, act)\n\n p0 = old_policy._distribution(obs).probs.detach() + 1e-8\n p1 = new_policy._distribution(obs).probs\n # pi_new = Categorical(old_policy.logits_net(obs))\n # act_new = pi_new.sample()\n # logp0 = old_policy._log_prob_from_distribution(pi_old, act_old)\n # logp1 = new_policy._log_prob_from_distribution(pi_new, act_new)\n\n return torch.sum(p0 * torch.log(p0 / p1), 1).mean()\n # kl = torch.exp(logp1) * (logp1-logp0)\n # return kl.sum(-1, keepdim=True).mean()","def __init__(self, kp, ki, kd):\n self.kp = kp\n self.ki = ki\n self.kd = kd\n self.error_last = 0\n self.error_sum = 0\n self.delta_error = 0","def K(self):\n\n # Calculate and return the stiffness matrix in global coordinates\n return matmul(matmul(inv(self.T()), self.k()), self.T())","def _K_computations(self, X, X2):\r\n if self.ARD:\r\n pass\r\n else:\r\n if X2 is None:\r\n self._K_inner_prod = np.dot(X,X.T)\r\n self._K_numer = self._K_inner_prod*self.weight_variance+self.bias_variance\r\n vec = np.diag(self._K_numer) + 1.\r\n self._K_denom = np.sqrt(np.outer(vec,vec))\r\n self._K_asin_arg = self._K_numer/self._K_denom\r\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)\r\n else:\r\n self._K_inner_prod = np.dot(X,X2.T)\r\n self._K_numer = self._K_inner_prod*self.weight_variance + self.bias_variance\r\n vec1 = (X*X).sum(1)*self.weight_variance + self.bias_variance + 1.\r\n vec2 = (X2*X2).sum(1)*self.weight_variance + self.bias_variance + 1.\r\n self._K_denom = np.sqrt(np.outer(vec1,vec2))\r\n self._K_asin_arg = self._K_numer/self._K_denom\r\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)","def testEpsK1Changes(self):\n with self.test_context() as session:\n initial_eps = 1e-3\n num_classes = 5\n rm = gpflow.likelihoods.RobustMax(num_classes, initial_eps)\n\n expected_eps_k1 = initial_eps / (num_classes - 1.)\n actual_eps_k1 = session.run(rm._eps_K1)\n self.assertAlmostEqual(expected_eps_k1, actual_eps_k1)\n\n new_eps = 0.412\n rm.epsilon.assign(new_eps, session=session)\n expected_eps_k2 = new_eps / (num_classes - 1.)\n actual_eps_k2 = session.run(rm._eps_K1)\n self.assertAlmostEqual(expected_eps_k2, actual_eps_k2)","def fuel_cond(T):\n\n kc = 1.841e-19*math.pow(T,6) - 2.097e-15*math.pow(T,5) +\\\n 9.721e-12*math.pow(T,4) - 2.369e-8*math.pow(T,3) +\\\n 3.283e-5*math.pow(T,2) - 0.0267*T + 63.18\n \n return kc","def _K_computations(self, X, X2):\r\n # First extract times and indices.\r\n self._extract_t_indices(X, X2)\r\n\r\n self._K_compute_eq()\r\n self._K_compute_ode_eq()\r\n if X2 is None:\r\n self._K_eq_ode = self._K_ode_eq.T\r\n else:\r\n self._K_compute_ode_eq(transpose=True)\r\n self._K_compute_ode()\r\n\r\n if X2 is None:\r\n self._K_dvar = np.zeros((self._t.shape[0], self._t.shape[0]))\r\n else:\r\n self._K_dvar = np.zeros((self._t.shape[0], self._t2.shape[0]))\r\n\r\n # Reorder values of blocks for placing back into _K_dvar.\r\n self._K_dvar = np.vstack((np.hstack((self._K_eq, self._K_eq_ode)),\r\n np.hstack((self._K_ode_eq, self._K_ode))))\r\n self._K_dvar = self._K_dvar[self._rorder, :]\r\n self._K_dvar = self._K_dvar[:, self._rorder2]\r\n \r\n \r\n if X2 is None:\r\n # Matrix giving scales of each output\r\n self._scale = np.zeros((self._t.size, self._t.size))\r\n code=\"\"\"\r\n for(int i=0;i<N; i++){\r\n scale_mat[i+i*N] = B[index[i]+output_dim*(index[i])];\r\n for(int j=0; j<i; j++){\r\n scale_mat[j+i*N] = B[index[i]+output_dim*index[j]];\r\n scale_mat[i+j*N] = scale_mat[j+i*N];\r\n }\r\n }\r\n \"\"\"\r\n scale_mat, B, index = self._scale, self.B, self._index\r\n N, output_dim = self._t.size, self.output_dim\r\n weave.inline(code,['index',\r\n 'scale_mat', 'B',\r\n 'N', 'output_dim'])\r\n else:\r\n self._scale = np.zeros((self._t.size, self._t2.size))\r\n code = \"\"\"\r\n for(int i=0; i<N; i++){\r\n for(int j=0; j<N2; j++){\r\n scale_mat[i+j*N] = B[index[i]+output_dim*index2[j]];\r\n }\r\n }\r\n \"\"\"\r\n scale_mat, B, index, index2 = self._scale, self.B, self._index, self._index2\r\n N, N2, output_dim = self._t.size, self._t2.size, self.output_dim\r\n weave.inline(code, ['index', 'index2',\r\n 'scale_mat', 'B',\r\n 'N', 'N2', 'output_dim'])","def P(self, energy, newEnergy, temperature):\n \"\"\" This is the decision-rule, adapted from Nascimento, et al., 2009 (See references) \"\"\"\n \n delta = self.calcDelta(newEnergy, energy)\n\n minTemp = 0.00001 # use minimum to avoid div/0 and buffer overflow\n if temperature == 0:\n return minTemp\n elif temperature > minTemp:\n try:\n return math.exp(-1 * round(delta, 4) / round(temperature, 4))\n except OverflowError as detail:\n return minTemp\n else:\n return 1","def dK_dtheta(self,dL_dK,X,X2,target):\r\n if X2 is None: X2 = X\r\n FX = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X)\r\n FX2 = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X2)\r\n\r\n La = np.column_stack((self.a[0]*np.ones((self.n_basis,1)), self.a[1]*self.basis_omega, self.a[2]*self.basis_omega**2, self.a[3]*self.basis_omega**3))\r\n Lo = np.column_stack((self.basis_omega, self.basis_omega, self.basis_omega, self.basis_omega))\r\n Lp = np.column_stack((self.basis_phi, self.basis_phi+np.pi/2, self.basis_phi+np.pi, self.basis_phi+np.pi*3/2))\r\n r,omega,phi = self._cos_factorization(La,Lo,Lp)\r\n Gint = self._int_computation( r,omega,phi, r,omega,phi)\r\n\r\n Flower = np.array(self._cos(self.basis_alpha,self.basis_omega,self.basis_phi)(self.lower))[:,None]\r\n F1lower = np.array(self._cos(self.basis_alpha*self.basis_omega,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\r\n F2lower = np.array(self._cos(self.basis_alpha*self.basis_omega**2,self.basis_omega,self.basis_phi+np.pi)(self.lower))[:,None]\r\n\r\n #dK_dvar\r\n dK_dvar = 1./self.variance*mdot(FX,self.Gi,FX2.T)\r\n\r\n #dK_dlen\r\n da_dlen = [-3*self.a[0]/self.lengthscale, -2*self.a[1]/self.lengthscale, -self.a[2]/self.lengthscale, 0.]\r\n db_dlen = [0., 4*self.b[1]/self.lengthscale, 2*self.b[2]/self.lengthscale, 2*self.b[3]/self.lengthscale, 2*self.b[4]/self.lengthscale]\r\n dLa_dlen = np.column_stack((da_dlen[0]*np.ones((self.n_basis,1)), da_dlen[1]*self.basis_omega, da_dlen[2]*self.basis_omega**2, da_dlen[3]*self.basis_omega**3))\r\n r1,omega1,phi1 = self._cos_factorization(dLa_dlen,Lo,Lp)\r\n dGint_dlen = self._int_computation(r1,omega1,phi1, r,omega,phi)\r\n dGint_dlen = dGint_dlen + dGint_dlen.T\r\n dlower_terms_dlen = db_dlen[0]*np.dot(Flower,Flower.T) + db_dlen[1]*np.dot(F2lower,F2lower.T) + db_dlen[2]*np.dot(F1lower,F1lower.T) + db_dlen[3]*np.dot(F2lower,Flower.T) + db_dlen[4]*np.dot(Flower,F2lower.T)\r\n dG_dlen = 15*self.lengthscale**4/(400*np.sqrt(5))*Gint + 3*self.lengthscale**5/(400*np.sqrt(5))*dGint_dlen + dlower_terms_dlen\r\n dK_dlen = -mdot(FX,self.Gi,dG_dlen/self.variance,self.Gi,FX2.T)\r\n\r\n #dK_dper\r\n dFX_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X ,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X)\r\n dFX2_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X2,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X2)\r\n\r\n dLa_dper = np.column_stack((-self.a[0]*self.basis_omega/self.period, -self.a[1]*self.basis_omega**2/self.period, -self.a[2]*self.basis_omega**3/self.period, -self.a[3]*self.basis_omega**4/self.period))\r\n dLp_dper = np.column_stack((self.basis_phi+np.pi/2,self.basis_phi+np.pi,self.basis_phi+np.pi*3/2,self.basis_phi))\r\n r1,omega1,phi1 = self._cos_factorization(dLa_dper,Lo,dLp_dper)\r\n\r\n IPPprim1 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi/2))\r\n IPPprim1 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi/2))\r\n IPPprim2 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + self.upper*np.cos(phi-phi1.T))\r\n IPPprim2 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + self.lower*np.cos(phi-phi1.T))\r\n #IPPprim2[0,0] = 2*(self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\r\n IPPprim = np.where(np.isnan(IPPprim1),IPPprim2,IPPprim1)\r\n\r\n IPPint1 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi)\r\n IPPint1 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi)\r\n IPPint2 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./2*self.upper**2*np.cos(phi-phi1.T)\r\n IPPint2 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./2*self.lower**2*np.cos(phi-phi1.T)\r\n #IPPint2[0,0] = (self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\r\n IPPint = np.where(np.isnan(IPPint1),IPPint2,IPPint1)\r\n\r\n dLa_dper2 = np.column_stack((-self.a[1]*self.basis_omega/self.period, -2*self.a[2]*self.basis_omega**2/self.period, -3*self.a[3]*self.basis_omega**3/self.period))\r\n dLp_dper2 = np.column_stack((self.basis_phi+np.pi/2, self.basis_phi+np.pi, self.basis_phi+np.pi*3/2))\r\n r2,omega2,phi2 = self._cos_factorization(dLa_dper2,Lo[:,0:2],dLp_dper2)\r\n\r\n dGint_dper = np.dot(r,r1.T)/2 * (IPPprim - IPPint) + self._int_computation(r2,omega2,phi2, r,omega,phi)\r\n dGint_dper = dGint_dper + dGint_dper.T\r\n\r\n dFlower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\r\n dF1lower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega**2/self.period,self.basis_omega,self.basis_phi+np.pi)(self.lower)+self._cos(-self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\r\n dF2lower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega**3/self.period,self.basis_omega,self.basis_phi+np.pi*3/2)(self.lower) + self._cos(-2*self.basis_alpha*self.basis_omega**2/self.period,self.basis_omega,self.basis_phi+np.pi)(self.lower))[:,None]\r\n\r\n dlower_terms_dper = self.b[0] * (np.dot(dFlower_dper,Flower.T) + np.dot(Flower.T,dFlower_dper))\r\n dlower_terms_dper += self.b[1] * (np.dot(dF2lower_dper,F2lower.T) + np.dot(F2lower,dF2lower_dper.T)) - 4*self.b[1]/self.period*np.dot(F2lower,F2lower.T)\r\n dlower_terms_dper += self.b[2] * (np.dot(dF1lower_dper,F1lower.T) + np.dot(F1lower,dF1lower_dper.T)) - 2*self.b[2]/self.period*np.dot(F1lower,F1lower.T)\r\n dlower_terms_dper += self.b[3] * (np.dot(dF2lower_dper,Flower.T) + np.dot(F2lower,dFlower_dper.T)) - 2*self.b[3]/self.period*np.dot(F2lower,Flower.T)\r\n dlower_terms_dper += self.b[4] * (np.dot(dFlower_dper,F2lower.T) + np.dot(Flower,dF2lower_dper.T)) - 2*self.b[4]/self.period*np.dot(Flower,F2lower.T)\r\n\r\n dG_dper = 1./self.variance*(3*self.lengthscale**5/(400*np.sqrt(5))*dGint_dper + 0.5*dlower_terms_dper)\r\n dK_dper = mdot(dFX_dper,self.Gi,FX2.T) - mdot(FX,self.Gi,dG_dper,self.Gi,FX2.T) + mdot(FX,self.Gi,dFX2_dper.T)\r\n\r\n # np.add(target[:,:,0],dK_dvar, target[:,:,0])\r\n target[0] += np.sum(dK_dvar*dL_dK)\r\n #np.add(target[:,:,1],dK_dlen, target[:,:,1])\r\n target[1] += np.sum(dK_dlen*dL_dK)\r\n #np.add(target[:,:,2],dK_dper, target[:,:,2])\r\n target[2] += np.sum(dK_dper*dL_dK)","def E2K(E):\n return sqrt(E/2.0723)","def jarrow_rudd(s, k, t, v, rf, cp, am=False, n=100):\n\n\t# Basic Calculations\n\th = t / n \n\tu = math.exp((rf - 0.5 * math.pow(v, 2)) * h + v * math.sqrt(h))\n\td = math.exp((rf - 0.5 * math.pow(v, 2)) * h - v * math.sqrt(h))\n\tdrift = math.exp(rf * h)\n\tq = (drift - d) / (u - d)\n\n\t#Process the terminal stock price\n\tstkval = np.zeros((n+1, n+1))\n\toptval = np.zeros((n+1, n+1))\n\tstkval[0, 0] = s\n\n\tfor i in range(1, n+1):\n\t\tstkval[i, 0] = stkval[i - 1, 0] * u\n\t\tfor j in range(1, i + 1):\n\t\t\tstkval[i, j] = stkval[i - 1, j - 1] * d\n\n\t# Backwards recursion for option price\n\tfor j in range(n + 1):\n\t\toptval[n, j] = max(0, cp * (stkval[n, j] - k))\n\tfor i in range(n - 1, -1, -1):\n\t\tfor j in range(i + 1):\n\t\t\toptval[i, j] = (q * optval[i + 1, j] + (1 - q) * optval[i + 1, j + 1]) / drift\n\t\t\tif am:\n\t\t\t\toptval[i, j] = max(optval[i, j], cp * (stkval[i, j] - k))\n\treturn optval[0, 0]","def _find_k_offsets(self, k, d):\n olderr = sp.seterr(invalid= 'ignore') # turn off 'invalid multiplication' error;\n # it's just the 'inf' boundaries\n delta = k * d\n sp.seterr(**olderr) # turn the error back on\n return delta","def ekf_algorithm(self, u, y):\n x_est_before = self.x_estimated_state\n cov_matrix_before = self.cov_matrix\n # 1. Prediction\n # predict the state by integrate the time continuous system numerically\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\n x_est_predict = np.resize(sim_state_predict, (6, 1))\n # predict the new covariance by linearizing and discretizing the model\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\n # 2. Update\n # compute kalman gain\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\n # update state\n y_est = x_est_predict[0:3, ]\n x_est_update = x_est_predict + Kl @ (y - y_est)\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\n\n # check if the update step state needs to be changed because of limit crossing\n # if that is the case, correct the state and set the state of the simulation accordingly\n # heliSim_state = np.resize(x_est_update, (1, 6))[0]\n # heliSim_state = np.pad(heliSim_state, (0, 2), \"constant\")\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 6))[0],\n ModelType.EASY)\n x_est_update = np.resize(corrected_state, (6, 1))\n\n self.x_estimated_state = x_est_update\n self.cov_matrix = cov_matrix_update\n return x_est_update","def err_k(self, X, Y):\n\t\tY_hat = self.predict(X)\n\t\treturn np.mean(Y_hat != from_1_of_k(Y))","def verhulst(nb_init, t0, tf, eps, methode, gamma, K) :\n f=lambda y,t : gamma*y*(1-y/K)\n Y=meth_epsilon(nb_init, t0, tf, eps, f, methode)\n return Y","def _K_computations(self, X, X2=None):\r\n self._lengthscales=self.mapping.f(X)\r\n self._lengthscales2=np.square(self._lengthscales)\r\n if X2==None:\r\n self._lengthscales_two = self._lengthscales\r\n self._lengthscales_two2 = self._lengthscales2\r\n Xsquare = np.square(X).sum(1)\r\n self._K_dist2 = -2.*tdot(X) + Xsquare[:, None] + Xsquare[None, :]\r\n else:\r\n self._lengthscales_two = self.mapping.f(X2)\r\n self._lengthscales_two2 = np.square(self._lengthscales_two)\r\n self._K_dist2 = -2.*np.dot(X, X2.T) + np.square(X).sum(1)[:, None] + np.square(X2).sum(1)[None, :]\r\n self._w2 = self._lengthscales2 + self._lengthscales_two2.T\r\n prod_length = self._lengthscales*self._lengthscales_two.T\r\n self._K_exponential = np.exp(-self._K_dist2/self._w2)\r\n self._K_dvar = np.sign(prod_length)*(2*np.abs(prod_length)/self._w2)**(self.input_dim/2.)*np.exp(-self._K_dist2/self._w2)","def find_best_k(X_train, y_train, X_test, y_test, min_k=1, max_k=25):\n best_k = 0\n best_score = 0.0\n for k in range(min_k, max_k+1, 2):\n knn = KNeighborsClassifier(n_neighbors=k)\n knn.fit(X_train, y_train)\n preds = knn.predict(X_test)\n f1 = f1_score(y_test, preds)\n if f1 > best_score:\n best_k = k\n best_score = f1\n print(\"Best Value for k: {}\".format(best_k))\n print(\"F1-Score: {}\".format(best_score))","def calc_K_tilda(kernel: Type[Kern], X_train: np.array, X_m: np.array):\n Knn = kernel.K(X_train, X_train)\n Knm = kernel.K(X_train, X_m)\n Kmn = kernel.K(X_m, X_train)\n Kmm = kernel.K(X_m, X_m)\n temp = np.dot(np.dot(Knm, np.linalg.inv(Kmm)), Kmn)\n K_tilda = np.subtract(Knn, temp)\n return K_tilda","def updated_rating(old: int, expected: int, actual: int) -> int:\n return round(old + ELO_K_FACTOR * (actual - expected))","def diff_k_p2(p1, p2, t=0.):\n return p2","def k_Ni00(wind_ms, temp_C):\n\n U = wind_ms\n\n Sc = schmidt_number(temp_C)\n k = (0.333 * U + 0.222 * U ** 2) * (600 / Sc) ** 0.5\n\n return k","def test_estimate_jackknife():\n X = 100\n T = 300.00\n delta_beta = 1.0\n jk_f = np.ones(X)\n jk_sym1 = np.ones(X)\n jk_sym2 = np.ones(X) + 1\n\n kBT = boltzman * pow(T, 2.)\n input_dict = {\"E\": -1.0, \"Cv\": 1.0 / kBT}\n\n ret = jk.estimate_jackknife(X, T, delta_beta, input_dict, jk_f, jk_sym1, jk_sym2)\n\n assert ret[\"E\"] == -1.0\n assert ret[\"E error\"] == 0.0\n assert math.isclose(ret[\"Cv\"], 1.0 / kBT)\n assert math.isclose(ret[\"Cv error\"], 2.7755575615628914e-16)\n return","def ekf_algorithm(self, u, y):\n x_est_before = self.x_estimated_state\n cov_matrix_before = self.cov_matrix\n # 1. Prediction\n # predict the state by integrate the time continuous system numerically\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\n x_est_predict = np.resize(sim_state_predict, (8, 1))\n # predict the new covariance by linearizing and discretizing the model\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\n # 2. Update\n # compute kalman gain\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\n # update state\n y_est = np.concatenate((x_est_predict[0:3], x_est_predict[6:8]))\n x_est_update = x_est_predict + Kl @ (y - y_est)\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\n\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 8))[0],\n ModelType.GYROMOMENT)\n # corrected_state = x_est_update\n x_est_update = np.resize(corrected_state, (8, 1))\n\n self.x_estimated_state = x_est_update\n self.cov_matrix = cov_matrix_update\n # print(\"------\")\n # print(cov_matrix_predict)\n return x_est_update","def optimization_rel_disp_K(self, step_size, dof1, dof2, controlDOF):\n \"\"\"First, the initial variance of the system is computed for the matrices given by the user\"\"\"\n Variance = []\n \"\"\"The sign variable keeps track of the direction the algorithm is stepping\"\"\"\n sign = [0]\n Variance.append(self.VarianceOfResponse())\n\n \"\"\"The matrix K is incremented by one step with size = step_size. for the spring that connects dof1 and dof2\"\"\"\n sign.append(1)\n self.incrementK(step_size, dof1, dof2)\n Variance.append(self.VarianceOfResponse())\n\n \"\"\"Loop that iteratively steps down the optimal direction of increasing or reducing K\"\"\"\n i = 0\n while len(sign) < 4 or np.sum(sign[-4:]) != 0 or i < 100:\n i += 1\n print(abs(Variance[-2][int(controlDOF[0] - 1)] - Variance[-2][int(controlDOF[1] - 1)]))\n \"\"\"First condition demands a minimum of 4 steps. Second condition sums up the direction of the last 4 steps\n if the sum equals 0, the minimum value for the variance has been found.\"\"\"\n if abs(Variance[-2][int(controlDOF[0] - 1)] - Variance[-2][int(controlDOF[1] - 1)]) \\\n > abs(Variance[-1][int(controlDOF[0] - 1)] - Variance[-1][int(controlDOF[1] - 1)]):\n \"\"\"If the last variance is smaller than the variance before, keep going in that direction.\"\"\"\n self.incrementK(step_size * sign[-1], dof1, dof2)\n Variance.append(self.VarianceOfResponse())\n sign.append(sign[-1])\n elif abs(Variance[-2][int(controlDOF[0] - 1)] - Variance[-2][int(controlDOF[1] - 1)]) \\\n < abs(Variance[-1][int(controlDOF[0] - 1)] - Variance[-1][int(controlDOF[1] - 1)]):\n \"\"\"If the last variance is bigger than the one before, turn around and go the other way.\"\"\"\n self.incrementK(step_size * sign[-1] * -1, dof1, dof2)\n Variance.append(self.VarianceOfResponse())\n sign.append(sign[-1] * -1)\n return Variance","def sensitivity(gas, surf, old_data, temp, dk, thermo=False):\n rxns = []\n sens1 = []\n sens2 = []\n sens3 = []\n sens4 = []\n sens5 = []\n sens6 = []\n sens7 = []\n sens8 = []\n sens9 = []\n sens10 = []\n sens11 = []\n sens12 = []\n\n gas_out_data, gas_names_data, dist_array_data, T_array_data = old_data\n\n reference = []\n for a in range(len(gas_names_data)):\n reference.append([gas_names_data[a], [gas_out_data[:, a]]])\n\n # getting the ratio\n for x in reference:\n if x[0] == 'CH4(2)':\n ch4_in = x[1][0][0]\n if x[0] == 'O2(3)':\n o2_in = x[1][0][0]\n if x[0] == 'Ar':\n ar_in = x[1][0][0]\n ratio = ch4_in / (2 * o2_in)\n moles_in = [ch4_in, o2_in, ar_in]\n\n for x in reference:\n if x[0] == 'CH4(2)':\n ch4_in = x[1][0][0]\n ch4_out = x[1][0][-1]\n if ch4_out < 0:\n ch4_out = 0.\n ch4_depletion = ch4_in - ch4_out\n if ch4_depletion <= 1.0e-8:\n ch4_depletion = 1.0e-8\n reference_ch4_conv = 1.0e-8\n else:\n reference_ch4_conv = ch4_depletion / ch4_in # Sensitivity definition 7: CH4 conversion\n if x[0] == 'Ar':\n ar = x[1][0][-1]\n if x[0] == 'O2(3)':\n o2_out = x[1][0][-1]\n if o2_out < 0:\n o2_out = 1.0e-15 # O2 can't be negative\n elif o2_out > o2_in:\n o2_out = o2_in # O2 can't be created, to make it equal to O2 in\n if x[0] == 'CO(7)':\n co_out = x[1][0][-1]\n if x[0] == 'H2(6)':\n h2_out = x[1][0][-1]\n if x[0] == 'H2O(5)':\n h2o_out = x[1][0][-1]\n if x[0] == 'CO2(4)':\n co2_out = x[1][0][-1]\n\n if reference_ch4_conv <= 1.0e-8:\n reference_h2_sel = 1.0e-8\n reference_co_sel = 1.0e-8\n reference_syngas_selectivity = 1.0e-8\n reference_syngas_yield = 1.0e-8\n reference_co_yield = 1.0e-8\n reference_h2_yield = 1.0e-8\n reference_full_oxidation_selectivity = 1.0e-8\n reference_full_oxidation_yield = 1.0e-8\n else:\n # negative sensitivity is higher selectivity\n reference_h2_sel = h2_out / (ch4_depletion * 2) # Sensitivity definition 5: H2 selectivity\n if reference_h2_sel <= 0:\n reference_h2_sel = 1.0e-15 # selectivity can't be 0\n\n reference_co_sel = co_out / ch4_depletion # Sensitivity definition 3: CO selectivity\n if reference_co_sel <= 0:\n reference_co_sel = 1.0e-15 # selectivity can't be 0\n\n reference_syngas_selectivity = reference_co_sel + reference_h2_sel # Sensitivity definition 1: SYNGAS selectivity\n\n reference_syngas_yield = reference_syngas_selectivity * reference_ch4_conv # Sensitivity definition 2: SYNGAS yield\n if reference_syngas_yield <= 0:\n reference_syngas_yield = 1.0e-15 # yield can't be 0\n\n reference_co_yield = co_out / ch4_in # Sensitivity definition 4: CO % yield\n # reference_co_yield = reference_co_sel * reference_ch4_conv\n\n reference_h2_yield = h2_out / (2 * ch4_in) # Sensitivity definition 6: H2 % yield\n # reference_h2_yield = reference_h2_sel * reference_ch4_conv\n\n # Sensitivity definition 8: H2O + CO2 selectivity\n reference_h2o_sel = h2o_out / (ch4_depletion * 2)\n reference_co2_sel = co2_out / ch4_depletion\n if reference_h2o_sel <= 0:\n reference_h2o_sel = 1.0e-15 # H2O selectivity can't be 0\n if reference_co2_sel <= 0:\n reference_co2_sel = 1.0e-15 # CO2 selectivity can't be 0\n reference_full_oxidation_selectivity = reference_h2o_sel + reference_co2_sel\n\n # Sensitivity definition 9: H2O + CO2 yield\n reference_full_oxidation_yield = reference_full_oxidation_selectivity * reference_ch4_conv\n\n # Sensitivity definition 10: exit temperature\n reference_exit_temp = T_array_data[-1]\n\n # Sensitivity definition 11: peak temperature\n reference_peak_temp = max(T_array_data)\n\n # Sensitivity definition 12: distance to peak temperautre\n reference_peak_temp_dist = dist_array_data[T_array_data.index(max(T_array_data))]\n\n # run the simulations\n if thermo is True:\n for m in range(surf.n_species):\n s = surf.species(m)\n original_coeffs = s.thermo.coeffs\n perturbed_coeffs = np.ones_like(original_coeffs)\n perturbed_coeffs[0] = original_coeffs[0]\n perturbed_coeffs[1:6] = original_coeffs[1:6]\n perturbed_coeffs[7:13] = original_coeffs[7:13]\n perturbed_coeffs[14] = original_coeffs[14]\n # perturbed_coeffs[6] = original_coeffs[6] + original_coeffs[6]*dk\n # perturbed_coeffs[13] = original_coeffs[13] + original_coeffs[13]*dk\n perturbed_coeffs[6] = original_coeffs[6] + dk\n perturbed_coeffs[13] = original_coeffs[13] + dk\n s.thermo = ct.NasaPoly2(100.000, 5000.000, ct.one_atm, perturbed_coeffs)\n surf.modify_species(m, s)\n c = monolithFull(gas, surf, temp, moles_in)\n\n gas_out, surf_out, gas_names, surf_names, dist_array, T_array = c\n\n new_amts = []\n for a in range(len(gas_names)):\n new_amts.append([gas_names[a], [gas_out[:, a]]])\n\n for x in new_amts:\n if x[0] == 'CH4(2)':\n new_ch4_in = x[1][0][0]\n new_ch4_out = x[1][0][-1]\n if new_ch4_out < 0:\n new_ch4_out = 0.\n new_ch4_depletion = new_ch4_in - new_ch4_out\n if new_ch4_depletion <= 1e-8:\n new_ch4_depletion = 1e-8\n new_ch4_conv = 1e-8\n else:\n new_ch4_conv = new_ch4_depletion / new_ch4_in # Sensitivity definition 7: CH4 conversion\n if x[0] == 'Ar':\n ar = x[1][0][-1]\n if x[0] == 'O2(3)':\n new_o2_in = x[1][0][0]\n new_o2_out = x[1][0][-1]\n if new_o2_out < 0:\n new_o2_out = 1.0e-15\n elif new_o2_out > new_o2_in:\n new_o2_out = new_o2_in\n if x[0] == 'CO(7)':\n new_co_out = x[1][0][-1]\n if x[0] == 'H2(6)':\n new_h2_out = x[1][0][-1]\n if x[0] == 'H2O(5)':\n new_h2o_out = x[1][0][-1]\n if x[0] == 'CO2(4)':\n new_co2_out = x[1][0][-1]\n\n if new_ch4_conv <= 1e-8:\n new_h2_sel = 1.0e-8\n new_co_sel = 1.0e-8\n new_syngas_selectivity = 1.0e-8\n new_syngas_yield = 1.0e-8\n new_co_yield = 1.0e-8\n new_h2_yield = 1.0e-8\n new_full_oxidation_selectivity = 1.0e-8\n new_full_oxidation_yield = 1.0e-8\n else:\n new_h2_sel = new_h2_out / (new_ch4_depletion * 2) # Sensitivity definition 5: H2 selectivity\n new_co_sel = new_co_out / new_ch4_depletion # Sensitivity definition 3: CO selectivity\n new_syngas_selectivity = new_co_sel + new_h2_sel # Sensitivity definition 1: SYNGAS selectivity\n new_syngas_yield = new_syngas_selectivity * new_ch4_conv # Sensitivity definition 2: SYNGAS yield\n new_co_yield = new_co_out / new_ch4_in # Sensitivity definition 4: CO % yield\n new_h2_yield = new_h2_out / (2 * new_ch4_in) # Sensitivity definition 6: H2 % yield\n new_h2o_sel = new_h2o_out / (new_ch4_depletion * 2) # Sensitivity definition 8: H2O + CO2 selectivity\n new_co2_sel = new_co2_out / new_ch4_depletion\n new_full_oxidation_selectivity = new_h2o_sel + new_co2_sel\n new_full_oxidation_yield = new_full_oxidation_selectivity * new_ch4_conv # Sensitivity definition 9: C2O + CO2 yield\n\n Sens5 = (new_h2_sel - reference_h2_sel) / (reference_h2_sel * dk)\n sens5.append(Sens5)\n\n Sens3 = (new_co_sel - reference_co_sel) / (reference_co_sel * dk)\n sens3.append(Sens3)\n\n Sens1 = (new_syngas_selectivity - reference_syngas_selectivity) / (reference_syngas_selectivity * dk)\n sens1.append(Sens1)\n\n Sens2 = (new_syngas_yield - reference_syngas_yield) / (reference_syngas_yield * dk)\n sens2.append(Sens2)\n\n Sens4 = (new_co_yield - reference_co_yield) / (reference_co_yield * dk)\n sens4.append(Sens4)\n\n Sens6 = (new_h2_yield - reference_h2_yield) / (reference_h2_yield * dk)\n sens6.append(Sens6)\n\n Sens7 = (new_ch4_conv - reference_ch4_conv) / (\n reference_ch4_conv * dk)\n sens7.append(Sens7)\n\n Sens8 = (new_full_oxidation_selectivity - reference_full_oxidation_selectivity) / (\n reference_full_oxidation_selectivity * dk)\n sens8.append(Sens8)\n\n Sens9 = (new_full_oxidation_yield - reference_full_oxidation_yield) / (reference_full_oxidation_yield * dk)\n sens9.append(Sens9)\n\n new_exit_temp = T_array[-1] # Sensitivity definition 10: exit temperature\n Sens10 = (new_exit_temp - reference_exit_temp) / (reference_exit_temp * dk)\n sens10.append(Sens10)\n\n new_peak_temp = max(T_array) # Sensitivity definition 11: peak temperature\n Sens11 = (new_peak_temp - reference_peak_temp) / (reference_peak_temp * dk)\n sens11.append(Sens11)\n\n new_peak_temp_dist = dist_array[\n T_array.index(max(T_array))] # Sensitivity definition 12: dist to peak temperature\n Sens12 = (new_peak_temp_dist - reference_peak_temp_dist) / (reference_peak_temp_dist * dk)\n sens12.append(Sens12)\n\n print \"%d %s %.3F %.3F\" % (m, surf.species_name(m), Sens1, Sens2)\n rxns.append(surf.species_name(m))\n\n # this step is essential, otherwise mechanism will have been altered\n s.thermo = ct.NasaPoly2(100.000, 5000.000, ct.one_atm, original_coeffs)\n surf.modify_species(m, s)\n else:\n for rxn in range(surf.n_reactions):\n c = monolithFull(gas, surf, temp, moles_in, sens=[dk, rxn])\n gas_out, surf_out, gas_names, surf_names, dist_array, T_array = c\n\n new_amts = []\n for a in range(len(gas_names)):\n new_amts.append([gas_names[a], [gas_out[:, a]]])\n\n for x in new_amts:\n if x[0] == 'CH4(2)':\n new_ch4_in = x[1][0][0]\n new_ch4_out = x[1][0][-1]\n if new_ch4_out < 0:\n new_ch4_out = 0.\n new_ch4_depletion = new_ch4_in - new_ch4_out\n if new_ch4_depletion <= 1e-8:\n new_ch4_depletion = 1e-8\n new_ch4_conv = 1e-8\n else:\n new_ch4_conv = new_ch4_depletion / new_ch4_in # Sensitivity definition 7: CH4 conversion\n if x[0] == 'Ar':\n ar = x[1][0][-1]\n if x[0] == 'O2(3)':\n new_o2_in = x[1][0][0]\n new_o2_out = x[1][0][-1]\n if new_o2_out < 0:\n new_o2_out = 1.0e-15\n elif new_o2_out > new_o2_in:\n new_o2_out = new_o2_in\n if x[0] == 'CO(7)':\n new_co_out = x[1][0][-1]\n if x[0] == 'H2(6)':\n new_h2_out = x[1][0][-1]\n if x[0] == 'H2O(5)':\n new_h2o_out = x[1][0][-1]\n if x[0] == 'CO2(4)':\n new_co2_out = x[1][0][-1]\n\n if new_ch4_conv <= 1e-8:\n new_h2_sel = 1.0e-8\n new_co_sel = 1.0e-8\n new_syngas_selectivity = 1.0e-8\n new_syngas_yield = 1.0e-8\n new_co_yield = 1.0e-8\n new_h2_yield = 1.0e-8\n new_full_oxidation_selectivity = 1.0e-8\n new_full_oxidation_yield = 1.0e-8\n else:\n new_h2_sel = new_h2_out / (new_ch4_depletion * 2) # Sensitivity definition 5: H2 selectivity\n new_co_sel = new_co_out / new_ch4_depletion # Sensitivity definition 3: CO selectivity\n new_syngas_selectivity = new_co_sel + new_h2_sel # Sensitivity definition 1: SYNGAS selectivity\n new_syngas_yield = new_syngas_selectivity * new_ch4_conv # Sensitivity definition 2: SYNGAS yield\n new_co_yield = new_co_out / new_ch4_in # Sensitivity definition 4: CO % yield\n new_h2_yield = new_h2_out / (2 * new_ch4_in) # Sensitivity definition 6: H2 % yield\n new_h2o_sel = new_h2o_out / (new_ch4_depletion * 2) # Sensitivity definition 8: H2O + CO2 selectivity\n new_co2_sel = new_co2_out / new_ch4_depletion\n new_full_oxidation_selectivity = new_h2o_sel + new_co2_sel\n new_full_oxidation_yield = new_full_oxidation_selectivity * new_ch4_conv # Sensitivity definition 9: C2O + CO2 yield\n\n Sens5 = (new_h2_sel - reference_h2_sel) / (reference_h2_sel * dk)\n sens5.append(Sens5)\n\n Sens3 = (new_co_sel - reference_co_sel) / (reference_co_sel * dk)\n sens3.append(Sens3)\n\n Sens1 = (new_syngas_selectivity - reference_syngas_selectivity) / (reference_syngas_selectivity * dk)\n sens1.append(Sens1)\n\n Sens2 = (new_syngas_yield - reference_syngas_yield) / (reference_syngas_yield * dk)\n sens2.append(Sens2)\n\n Sens4 = (new_co_yield - reference_co_yield) / (reference_co_yield * dk)\n sens4.append(Sens4)\n\n Sens6 = (new_h2_yield - reference_h2_yield) / (reference_h2_yield * dk)\n sens6.append(Sens6)\n\n Sens7 = (new_ch4_conv - reference_ch4_conv) / (\n reference_ch4_conv * dk)\n sens7.append(Sens7)\n\n Sens8 = (new_full_oxidation_selectivity - reference_full_oxidation_selectivity) / (\n reference_full_oxidation_selectivity * dk)\n sens8.append(Sens8)\n\n Sens9 = (new_full_oxidation_yield - reference_full_oxidation_yield) / (reference_full_oxidation_yield * dk)\n sens9.append(Sens9)\n\n new_exit_temp = T_array[-1] # Sensitivity definition 10: exit temperature\n Sens10 = (new_exit_temp - reference_exit_temp) / (reference_exit_temp * dk)\n sens10.append(Sens10)\n\n new_peak_temp = max(T_array) # Sensitivity definition 11: peak temperature\n Sens11 = (new_peak_temp - reference_peak_temp) / (reference_peak_temp * dk)\n sens11.append(Sens11)\n\n new_peak_temp_dist = dist_array[T_array.index(max(T_array))] # Sensitivity definition 12: dist to peak temperature\n Sens12 = (new_peak_temp_dist - reference_peak_temp_dist) / (reference_peak_temp_dist * dk)\n sens12.append(Sens12)\n\n print \"%d %s %.3F %.3F\" % (rxn, surf.reaction_equations()[rxn], Sens1, Sens2)\n rxns.append(surf.reaction_equations()[rxn])\n\n return rxns, sens1, sens2, sens3, sens4, sens5, sens6, sens7, sens8, sens9, sens10, sens11, sens12","def test_calc_kappa(test_coords):\n assert_almost_equal(calc_kappa(53.05187), 5762.687, decimal=3)","def KS(self, using, dx=0.0001):\n pits = np.array(self.PIT(using=using,dx=dx))\n ks_result = skgof.ks_test(pits, stats.uniform())\n return ks_result.statistic, ks_result.pvalue","def _Kgradients(self):\r\n dL_dfhat, I_KW_i = self._shared_gradients_components()\r\n dlp = self.noise_model.dlogpdf_df(self.f_hat, self.data, extra_data=self.extra_data)\r\n\r\n #Explicit\r\n #expl_a = np.dot(self.Ki_f, self.Ki_f.T)\r\n #expl_b = self.Wi_K_i\r\n #expl = 0.5*expl_a - 0.5*expl_b\r\n #dL_dthetaK_exp = dK_dthetaK(expl, X)\r\n\r\n #Implicit\r\n impl = mdot(dlp, dL_dfhat, I_KW_i)\r\n\r\n #No longer required as we are computing these in the gp already\r\n #otherwise we would take them away and add them back\r\n #dL_dthetaK_imp = dK_dthetaK(impl, X)\r\n #dL_dthetaK = dL_dthetaK_exp + dL_dthetaK_imp\r\n #dL_dK = expl + impl\r\n\r\n #No need to compute explicit as we are computing dZ_dK to account\r\n #for the difference between the K gradients of a normal GP,\r\n #and the K gradients including the implicit part\r\n dL_dK = impl\r\n return dL_dK","def KroDelta(a,b):\n \n if (a==b):\n return 1\n else:\n return 0","def kilometres_available(self):\n return self.fuel / self.litres_per_kilometre","def rk4(self, t, h,G) :\r\n k1 = h*self.calc_diff_eqn(t, self.quant_vec,G,self.mass_vec)\r\n k2 = h*self.calc_diff_eqn(t + 0.5*h , self.quant_vec + 0.5*k1 ,G, self.mass_vec)\r\n k3 = h*self.calc_diff_eqn(t + 0.5*h , self.quant_vec + 0.5*k2 ,G, self.mass_vec)\r\n k4 = h*self.calc_diff_eqn(t + h , self.quant_vec + k3 ,G, self.mass_vec)\r\n y_new = self.quant_vec + ((k1 + 2*k2 + 2*k3 + k4)/6)\r\n return y_new","def old():\n therm = [[300.], [300.], [300.], [300.], [300.], [300.], [300.], [300.], [300.], [300.]]\n ts = np.linspace(0, 50, 1000)\n\n #odvod temperature bo vsota gradientov (diferencialov) z desne in z leve glede x\n #dT/dt[i] = K/x^2 * (temperature[i-1]- 2*temperature[i] + temperature[i+1])\n #razen ce je robna tocka\n #potem je treba nekaj scarat - robna bo funkcija\n def odvod(indeks, arr, K, time):\n odvodt = K * (arr[indeks-1][time] - 2*arr[indeks][time] + arr[indeks+1][time])\n return odvodt\n\n def robna(time):\n return 5*m.cos(0.05*time)\n\n\n K = 0.02\n x = 0.003\n\n def main_old():\n t = 0\n dt = 50. / 1000.\n for time in ts:\n for i in range(0,9):\n therm[i].append(therm[i][t] + (robna(time) if i==0 else odvod(i, therm, K, t)*dt/(x**2)))\n therm[9].append(300.)\n t+=1\n\n import matplotlib.pyplot as plt\n\n plt.plot(ts[:], therm[4][:-1], label = 'T(t)')\n plt.show()\n \n main_old()","def kramers_kronig_hs(deltaE, I_EELS,\n N_ZLP=None,\n iterations=1,\n n=None,\n t=None,\n delta=0.5,\n full_output=True, prints = np.array([]), correct_S_s = False):\n output = {}\n # Constants and units\n me = 511.06\n\n e0 = 200 # keV\n beta =30 #mrad\n\n eaxis = deltaE[deltaE>0] #axis.axis.copy()\n ddeltaE = (np.max(deltaE) - np.min(deltaE))/(len(deltaE - 1))\n S_E = I_EELS[deltaE>0]\n y = I_EELS[deltaE>0]\n l = len(eaxis)\n i0 = N_ZLP\n \n # Kinetic definitions\n ke = e0 * (1 + e0 / 2. / me) / (1 + e0 / me) ** 2\n tgt = e0 * (2 * me + e0) / (me + e0)\n rk0 = 2590 * (1 + e0 / me) * np.sqrt(2 * ke / me)\n\n for io in range(iterations):\n # Calculation of the ELF by normalization of the SSD\n # We start by the \"angular corrections\"\n Im = y / (np.log(1 + (beta * tgt / eaxis) ** 2)) / ddeltaE#axis.scale\n if n is None and t is None:\n raise ValueError(\"The thickness and the refractive index are \"\n \"not defined. Please provide one of them.\")\n elif n is not None and t is not None:\n raise ValueError(\"Please provide the refractive index OR the \"\n \"thickness information, not both\")\n elif n is not None:\n # normalize using the refractive index.\n K = np.sum(Im/eaxis)*ddeltaE \n K = (K / (np.pi / 2) / (1 - 1. / n ** 2))\n te = (332.5 * K * ke / i0)\n if full_output is True:\n output['thickness'] = te\n elif t is not None:\n if N_ZLP is None:\n raise ValueError(\"The ZLP must be provided when the \"\n \"thickness is used for normalization.\")\n # normalize using the thickness\n K = t * i0 / (332.5 * ke)\n te = t\n Im = Im / K\n\n # Kramers Kronig Transform:\n # We calculate KKT(Im(-1/epsilon))=1+Re(1/epsilon) with FFT\n # Follows: D W Johnson 1975 J. Phys. A: Math. Gen. 8 490\n # Use an optimal FFT size to speed up the calculation, and\n # make it double the closest upper value to workaround the\n # wrap-around problem.\n esize = next_fast_len(2*l) #2**math.floor(math.log2(l)+1)*4\n q = -2 * np.fft.fft(Im, esize).imag / esize\n\n q[:l] *= -1\n q = np.fft.fft(q)\n # Final touch, we have Re(1/eps)\n Re = q[:l].real + 1\n # Egerton does this to correct the wrap-around problem, but in our\n # case this is not necessary because we compute the fft on an\n # extended and padded spectrum to avoid this problem.\n # Re=real(q)\n # Tail correction\n # vm=Re[axis.size-1]\n # Re[:(axis.size-1)]=Re[:(axis.size-1)]+1-(0.5*vm*((axis.size-1) /\n # (axis.size*2-arange(0,axis.size-1)))**2)\n # Re[axis.size:]=1+(0.5*vm*((axis.size-1) /\n # (axis.size+arange(0,axis.size)))**2)\n\n # Epsilon appears:\n # We calculate the real and imaginary parts of the CDF\n e1 = Re / (Re ** 2 + Im ** 2)\n e2 = Im / (Re ** 2 + Im ** 2)\n\n if iterations > 0 and N_ZLP is not None:\n # Surface losses correction:\n # Calculates the surface ELF from a vaccumm border effect\n # A simulated surface plasmon is subtracted from the ELF\n Srfelf = 4 * e2 / ((e1 + 1) ** 2 + e2 ** 2) - Im\n adep = (tgt / (eaxis + delta) *\n np.arctan(beta * tgt / eaxis) -\n beta / 1000. /\n (beta ** 2 + eaxis ** 2. / tgt ** 2))\n Srfint = 2000 * K * adep * Srfelf / rk0 / te * ddeltaE #axis.scale\n if correct_S_s == True:\n print(\"correcting S_s\")\n Srfint[Srfint<0] = 0\n Srfint[Srfint>S_E] = S_E[Srfint>S_E]\n y = S_E - Srfint\n _logger.debug('Iteration number: %d / %d', io + 1, iterations)\n if iterations == io + 1 and full_output is True:\n output['S_s'] = Srfint\n del Srfint\n\n eps = (e1 + e2 * 1j)\n del y\n del I_EELS\n if 'thickness' in output:\n # As above,prevent errors if the signal is a single spectrum\n output['thickness'] = te\n if full_output is False:\n return eps\n else:\n return eps, output","def solve_gamma(t, old, total):\n\n old, total = np.mean(old), np.mean(total)\n gamma = -1 / t * np.log(old / total)\n\n return gamma","def rk_adaptive(accel,m,r,h,v,recur,emin=10**-12,emax=10**-8,hmax=.1,hmin=.01,recurmax=100):\n k1v = accel(m,r)\n k1r = v\n k2v = accel(m,r + 0.25*k1r*h)\n k2r = v + (0.25*k1v)*h\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\n\n # 4th order calculation\n new_v4 = v + h*(25/216.*k1v + 1408/2565.*k3v + 2197/4104.*k4v - 1/5.*k5v)\n new_r4 = r + h*(25/216.*k1r + 1408/2565.*k3r + 2197/4104.*k4r - 1/5.*k5r)\n \n # 5th order calculation\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \n\n # Calculate truncation error between 5th and 4th order\n eps = np.abs( (np.max(np.abs(new_r5)) - np.max(np.abs(new_r4))) / np.max(np.abs(new_r4)))\n \n # Compare eps to emin and emax and update h accordingly\n if np.max(eps) < emin:\n if h*2.0 < hmax:\n h *= 2.0\n new_v = new_v5\n new_r = new_r5 \n \n if np.max(eps) > emax:\n if h/2.0 > hmin:\n h /= 2.0\n print h\n # Error too large, call rk_adaptive again with smaller h\n if recur < recurmax:\n recur += 1\n rk_adaptive(accel,m,r,h,v,recur)\n new_v = new_v5\n new_r = new_r5\n \n else:\n new_v = new_v5\n new_r = new_r5\n \n return new_v, new_r, h","def internal_heat_gain(dwelling):\n losses_gain = -40 * dwelling.Nocc\n water_heating_gains = (1000. / 24.) * dwelling.heat_gains_from_hw / DAYS_PER_MONTH\n\n mean_appliance_energy = 207.8 * (dwelling.GFA * dwelling.Nocc) ** 0.4714\n appliance_consumption_per_day = (mean_appliance_energy / 365.) * (\n 1 + 0.157 * numpy.cos((2. * math.pi / 12.) * (numpy.arange(12) - .78)))\n\n appliance_consumption = appliance_consumption_per_day * DAYS_PER_MONTH\n\n if dwelling.reduced_gains:\n met_gain = 50 * dwelling.Nocc\n cooking_gain = 23 + 5 * dwelling.Nocc\n appliance_gain = (0.67 * 1000. / 24) * appliance_consumption_per_day\n light_gain = 0.4 * dwelling.full_light_gain\n else:\n met_gain = 60 * dwelling.Nocc\n cooking_gain = 35 + 7 * dwelling.Nocc\n appliance_gain = (1000. / 24) * appliance_consumption_per_day\n light_gain = dwelling.full_light_gain\n\n total_internal_gains = (met_gain\n + light_gain\n + appliance_gain\n + cooking_gain\n + water_heating_gains\n + dwelling.pump_gain\n + losses_gain)\n\n if dwelling.reduced_gains:\n summer_met_gain = 60 * dwelling.Nocc\n summer_cooking_gain = 35 + 7 * dwelling.Nocc\n summer_appliance_gain = (1000. / 24) * appliance_consumption_per_day\n summer_light_gain = dwelling.full_light_gain\n total_internal_gains_summer = (summer_met_gain +\n water_heating_gains +\n summer_light_gain +\n summer_appliance_gain +\n summer_cooking_gain +\n dwelling.pump_gain +\n losses_gain\n - dwelling.heating_system_pump_gain)\n else:\n total_internal_gains_summer = total_internal_gains - dwelling.heating_system_pump_gain\n\n # Apply results to dwelling\n return dict(appliance_consumption=appliance_consumption,\n met_gain=met_gain,\n cooking_gain=cooking_gain,\n appliance_gain=appliance_gain,\n light_gain=light_gain,\n water_heating_gains=water_heating_gains,\n losses_gain=losses_gain,\n total_internal_gains=total_internal_gains,\n total_internal_gains_summer=total_internal_gains_summer)","def dK_dtheta(self,dL_dK,X,X2,target):\r\n if X2 is None: X2 = X\r\n FX = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X)\r\n FX2 = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X2)\r\n\r\n La = np.column_stack((self.a[0]*np.ones((self.n_basis,1)),self.a[1]*self.basis_omega))\r\n Lo = np.column_stack((self.basis_omega,self.basis_omega))\r\n Lp = np.column_stack((self.basis_phi,self.basis_phi+np.pi/2))\r\n r,omega,phi = self._cos_factorization(La,Lo,Lp)\r\n Gint = self._int_computation( r,omega,phi, r,omega,phi)\r\n\r\n Flower = np.array(self._cos(self.basis_alpha,self.basis_omega,self.basis_phi)(self.lower))[:,None]\r\n\r\n #dK_dvar\r\n dK_dvar = 1./self.variance*mdot(FX,self.Gi,FX2.T)\r\n\r\n #dK_dlen\r\n da_dlen = [-1./self.lengthscale**2,0.]\r\n dLa_dlen = np.column_stack((da_dlen[0]*np.ones((self.n_basis,1)),da_dlen[1]*self.basis_omega))\r\n r1,omega1,phi1 = self._cos_factorization(dLa_dlen,Lo,Lp)\r\n dGint_dlen = self._int_computation(r1,omega1,phi1, r,omega,phi)\r\n dGint_dlen = dGint_dlen + dGint_dlen.T\r\n dG_dlen = 1./2*Gint + self.lengthscale/2*dGint_dlen\r\n dK_dlen = -mdot(FX,self.Gi,dG_dlen/self.variance,self.Gi,FX2.T)\r\n\r\n #dK_dper\r\n dFX_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X ,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X)\r\n dFX2_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X2,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X2)\r\n\r\n dLa_dper = np.column_stack((-self.a[0]*self.basis_omega/self.period, -self.a[1]*self.basis_omega**2/self.period))\r\n dLp_dper = np.column_stack((self.basis_phi+np.pi/2,self.basis_phi+np.pi))\r\n r1,omega1,phi1 = self._cos_factorization(dLa_dper,Lo,dLp_dper)\r\n\r\n IPPprim1 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi/2))\r\n IPPprim1 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi/2))\r\n IPPprim2 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + self.upper*np.cos(phi-phi1.T))\r\n IPPprim2 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + self.lower*np.cos(phi-phi1.T))\r\n #IPPprim2[0,0] = 2*(self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\r\n IPPprim = np.where(np.isnan(IPPprim1),IPPprim2,IPPprim1)\r\n\r\n IPPint1 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi)\r\n IPPint1 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi)\r\n IPPint2 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./2*self.upper**2*np.cos(phi-phi1.T)\r\n IPPint2 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./2*self.lower**2*np.cos(phi-phi1.T)\r\n #IPPint2[0,0] = (self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\r\n IPPint = np.where(np.isnan(IPPint1),IPPint2,IPPint1)\r\n\r\n dLa_dper2 = np.column_stack((-self.a[1]*self.basis_omega/self.period))\r\n dLp_dper2 = np.column_stack((self.basis_phi+np.pi/2))\r\n r2,omega2,phi2 = dLa_dper2.T,Lo[:,0:1],dLp_dper2.T\r\n\r\n dGint_dper = np.dot(r,r1.T)/2 * (IPPprim - IPPint) + self._int_computation(r2,omega2,phi2, r,omega,phi)\r\n dGint_dper = dGint_dper + dGint_dper.T\r\n\r\n dFlower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\r\n\r\n dG_dper = 1./self.variance*(self.lengthscale/2*dGint_dper + self.b[0]*(np.dot(dFlower_dper,Flower.T)+np.dot(Flower,dFlower_dper.T)))\r\n\r\n dK_dper = mdot(dFX_dper,self.Gi,FX2.T) - mdot(FX,self.Gi,dG_dper,self.Gi,FX2.T) + mdot(FX,self.Gi,dFX2_dper.T)\r\n\r\n target[0] += np.sum(dK_dvar*dL_dK)\r\n target[1] += np.sum(dK_dlen*dL_dK)\r\n target[2] += np.sum(dK_dper*dL_dK)","def K(self, u, v):\n return (self.L(u, v) * self.N(u, v) - np.square(self.M(u, v))) / \\\n (self.E(u, v) * self.G(u, v) - np.square(self.F(u, v)))","def price_heston_mc(kappa_,theta_,sigma_,rho_,r_,T_,L_,V0_,S0_,K0_,N_):\r\n esp_ = monte_carlo(kappa_,theta_,sigma_,rho_,r_,T_,L_,V0_,S0_,K0_,N_)\r\n return exp(-r_*T_)*esp_"],"string":"[\n \"def calc_k(self):\\n\\t\\n\\tself.k = -np.array([self.sth*self.cphi, self.sth*self.sphi, self.cth])\\n\\n\\treturn\",\n \"def obrien_fleming_cutoff(K, current_k, alpha):\\n\\n if not isinstance(K, int) or K < 1 or K > 10:\\n raise ValueError('K must be an integer between 1 and 10.')\\n\\n if not isinstance(current_k, int) or current_k < 1 or current_k > 10:\\n raise ValueError('current_k must be an integer between 1 and 10.')\\n if current_k > K:\\n raise ValueError('current_k must be less than k.')\\n\\n if alpha not in [0.01, 0.05, 0.1]:\\n raise ValueError('alpha must be 0.01, 0.05, or 0.1.')\\n\\n cutoffs = {\\n \\\"0.01\\\": [2.576, 2.580, 2.595, 2.939, 2.986, 3.023, 3.053, 3.078, 3.099, 3.117],\\n \\\"0.05\\\": [1.960, 2.178, 2.289, 2.361, 2.413, 2.453, 2.485, 2.512, 2.535, 2.555],\\n \\\"0.1\\\": [1.645, 1.875, 1.992, 2.067, 2.122, 2.164, 2.197, 2.225, 2.249, 2.270],\\n }\\n return cutoffs[str(alpha)][K - 1] * math.sqrt(K / current_k)\",\n \"def update_kkrimp_params(self):\\n\\n decrease_mixing_fac = False\\n switch_agressive_mixing = False\\n switch_higher_accuracy = False\\n initial_settings = False\\n\\n # only do something other than simple mixing after first kkr run\\n if self.ctx.loop_count != 1:\\n # first determine if previous step was successful (otherwise try to find some rms value and decrease mixing to try again)\\n if not self.ctx.kkr_step_success:\\n decrease_mixing_fac = True\\n message = 'INFO: last KKR calculation failed. Trying decreasing mixfac'\\n self.report(message)\\n\\n convergence_on_track = self.convergence_on_track()\\n\\n # check if calculation was on its way to converge\\n if not convergence_on_track:\\n decrease_mixing_fac = True\\n message = 'INFO: Last KKR did not converge. Trying decreasing mixfac'\\n self.report(message)\\n # reset last_remote to last successful calculation\\n last_calcs_list = list(range(len(self.ctx.calcs))) # needs to be list to support slicing\\n if len(last_calcs_list) > 1:\\n last_calcs_list = array(last_calcs_list)[::-1] # make sure to go from latest calculation backwards\\n for icalc in last_calcs_list:\\n message = f\\\"INFO: last calc success? {icalc} {self.ctx.KKR_steps_stats['success'][icalc]}\\\"\\n self.report(message)\\n if self.ctx.KKR_steps_stats['success'][icalc]:\\n if self.ctx.KKR_steps_stats['last_rms'][icalc] < self.ctx.KKR_steps_stats['first_rms'][icalc]:\\n self.ctx.last_remote = self.ctx.calcs[icalc].outputs.remote_folder\\n break # exit loop if last_remote was found successfully\\n else:\\n self.ctx.last_remote = None\\n else:\\n self.ctx.last_remote = None\\n # now cover case when last_remote needs to be set to initial remote folder (from input)\\n if self.ctx.last_remote is None:\\n if 'kkrimp_remote' in self.inputs:\\n messager = 'INFO: no successful and converging calculation to take RemoteData from. Reuse RemoteData from input instead.'\\n self.report(message)\\n self.ctx.last_remote = self.inputs.kkrimp_remote\\n elif 'impurity_info' in self.inputs or 'remote_data' in self.inputs:\\n self.ctx.last_remote = None\\n # check if last_remote has finally been set and abort if this is not the case\\n if self.ctx.last_remote is None:\\n messager = 'ERROR: last remote not found'\\n self.report(message)\\n return self.exit_codes.ERROR_SETTING_LAST_REMOTE # pylint: disable=no-member\\n\\n # check if mixing strategy should be changed\\n last_mixing_scheme = self.ctx.last_params.get_dict()['IMIX']\\n if last_mixing_scheme is None:\\n last_mixing_scheme = 0\\n\\n if convergence_on_track:\\n last_rms = self.ctx.last_rms_all[-1]\\n if last_rms < self.ctx.threshold_aggressive_mixing and last_mixing_scheme == 0:\\n switch_agressive_mixing = True\\n message = 'INFO: rms low enough, switch to agressive mixing'\\n self.report(message)\\n\\n # check if switch to higher accuracy should be done\\n if not self.ctx.kkr_higher_accuracy:\\n if self.ctx.kkr_converged: # or last_rms < self.ctx.threshold_switch_high_accuracy:\\n switch_higher_accuracy = True\\n\\n\\n# self.report(\\\"INFO: rms low enough, switch to higher accuracy settings\\\")\\n else:\\n initial_settings = True\\n self.ctx.kkr_step_success = True\\n\\n if self.ctx.loop_count > 1:\\n last_rms = self.ctx.last_rms_all[-1]\\n\\n # extract values from host calculation\\n host_GF_calc = self.inputs.remote_data.get_incoming(node_class=CalcJobNode).first().node\\n host_GF_outparams = host_GF_calc.outputs.output_parameters.get_dict()\\n host_GF_inparams = host_GF_calc.inputs.parameters.get_dict()\\n nspin = host_GF_outparams.get('nspin')\\n non_spherical = host_GF_inparams.get('INS')\\n if non_spherical is None:\\n non_spherical = kkrparams.get_KKRcalc_parameter_defaults()[0].get('INS')\\n self.ctx.spinorbit = host_GF_outparams.get('use_newsosol')\\n\\n # if needed update parameters\\n if decrease_mixing_fac or switch_agressive_mixing or switch_higher_accuracy or initial_settings or self.ctx.mag_init:\\n if initial_settings:\\n label = 'initial KKR scf parameters'\\n description = 'initial parameter set for scf calculation'\\n else:\\n label = ''\\n description = ''\\n\\n # step 1: extract info from last input parameters and check consistency\\n para_check = kkrparams(params_type='kkrimp')\\n para_check.get_all_mandatory()\\n message = 'INFO: get kkrimp keywords'\\n self.report(message)\\n\\n # init new_params dict where updated params are collected\\n new_params = {}\\n\\n # step 1.2: check if all mandatory keys are there and add defaults if missing\\n missing_list = para_check.get_missing_keys(use_aiida=True)\\n if missing_list != []:\\n kkrdefaults = kkrparams.get_KKRcalc_parameter_defaults()[0]\\n kkrdefaults_updated = []\\n for key_default, val_default in list(kkrdefaults.items()):\\n if key_default in missing_list:\\n new_params[key_default] = kkrdefaults.get(key_default)\\n kkrdefaults_updated.append(key_default)\\n if len(kkrdefaults_updated) > 0:\\n self.report('ERROR: no default param found')\\n return self.exit_codes.ERROR_MISSING_PARAMS # pylint: disable=no-member\\n else:\\n message = f'updated KKR parameter node with default values: {kkrdefaults_updated}'\\n self.report(message)\\n\\n # step 2: change parameter (contained in new_params dictionary)\\n last_mixing_scheme = para_check.get_value('IMIX')\\n if last_mixing_scheme is None:\\n last_mixing_scheme = 0\\n\\n strmixfac = self.ctx.strmix\\n aggrmixfac = self.ctx.aggrmix\\n nsteps = self.ctx.nsteps\\n\\n # TODO: maybe add decrease mixing factor option as in kkr_scf wc\\n # step 2.1 fill new_params dict with values to be updated\\n if decrease_mixing_fac:\\n if last_mixing_scheme == 0:\\n self.report(f'(strmixfax, mixreduce)= ({strmixfac}, {self.ctx.mixreduce})')\\n self.report(f'type(strmixfax, mixreduce)= {type(strmixfac)} {type(self.ctx.mixreduce)}')\\n strmixfac = strmixfac * self.ctx.mixreduce\\n self.ctx.strmix = strmixfac\\n label += f'decreased_mix_fac_str (step {self.ctx.loop_count})'\\n description += f'decreased STRMIX factor by {self.ctx.mixreduce}'\\n else:\\n self.report(f'(aggrmixfax, mixreduce)= ({aggrmixfac}, {self.ctx.mixreduce})')\\n self.report(f'type(aggrmixfax, mixreduce)= {type(aggrmixfac)} {type(self.ctx.mixreduce)}')\\n aggrmixfac = aggrmixfac * self.ctx.mixreduce\\n self.ctx.aggrmix = aggrmixfac\\n label += 'decreased_mix_fac_bry'\\n description += f'decreased AGGRMIX factor by {self.ctx.mixreduce}'\\n\\n if switch_agressive_mixing:\\n last_mixing_scheme = self.ctx.type_aggressive_mixing\\n label += ' switched_to_agressive_mixing'\\n description += f' switched to agressive mixing scheme (IMIX={last_mixing_scheme})'\\n\\n # add number of scf steps, spin\\n new_params['SCFSTEPS'] = nsteps\\n new_params['NSPIN'] = nspin\\n new_params['INS'] = non_spherical\\n\\n # add ldos runoption if dos_run = True\\n if self.ctx.dos_run:\\n if self.ctx.lmdos:\\n runflags = new_params.get('RUNFLAG', []) + ['lmdos']\\n else:\\n runflags = new_params.get('RUNFLAG', []) + ['ldos']\\n new_params['RUNFLAG'] = runflags\\n new_params['SCFSTEPS'] = 1\\n\\n # turn on Jij calculation if jij_run == True\\n if self.ctx.jij_run:\\n new_params['CALCJIJMAT'] = 1\\n\\n # add newsosol\\n if self.ctx.spinorbit:\\n testflags = new_params.get('TESTFLAG', []) + ['tmatnew']\\n new_params['TESTFLAG'] = testflags\\n new_params['SPINORBIT'] = 1\\n new_params['NCOLL'] = 1\\n # TODO add deprecation warning and remove these lines (can be set with params_overwrite instead)\\n if self.ctx.mesh_params.get('RADIUS_LOGPANELS', None) is not None:\\n new_params['RADIUS_LOGPANELS'] = self.ctx.mesh_params['RADIUS_LOGPANELS']\\n if self.ctx.mesh_params.get('NCHEB', None) is not None:\\n new_params['NCHEB'] = self.ctx.mesh_params['NCHEB']\\n if self.ctx.mesh_params.get('NPAN_LOG', None) is not None:\\n new_params['NPAN_LOG'] = self.ctx.mesh_params['NPAN_LOG']\\n if self.ctx.mesh_params.get('NPAN_EQ', None) is not None:\\n new_params['NPAN_EQ'] = self.ctx.mesh_params['NPAN_EQ']\\n new_params['CALCORBITALMOMENT'] = 1\\n else:\\n new_params['SPINORBIT'] = 0\\n new_params['NCOLL'] = 0\\n new_params['CALCORBITALMOMENT'] = 0\\n new_params['TESTFLAG'] = []\\n\\n # set mixing schemes and factors\\n if last_mixing_scheme > 2:\\n new_params['ITDBRY'] = self.ctx.broyden_num\\n new_params['IMIX'] = last_mixing_scheme\\n new_params['MIXFAC'] = aggrmixfac\\n new_params['NSIMPLEMIXFIRST'] = self.ctx.nsimplemixfirst\\n elif last_mixing_scheme == 0:\\n new_params['IMIX'] = last_mixing_scheme\\n new_params['MIXFAC'] = strmixfac\\n\\n # add mixing scheme to context\\n self.ctx.last_mixing_scheme = last_mixing_scheme\\n\\n if switch_higher_accuracy:\\n self.ctx.kkr_higher_accuracy = True\\n\\n # add convergence settings\\n if self.ctx.loop_count == 1 or self.ctx.last_mixing_scheme == 0:\\n new_params['QBOUND'] = self.ctx.threshold_aggressive_mixing\\n else:\\n new_params['QBOUND'] = self.ctx.convergence_criterion\\n\\n # initial magnetization\\n if initial_settings and self.ctx.mag_init:\\n if self.ctx.hfield[0] <= 0.0 or self.ctx.hfield[1] == 0:\\n self.report(\\n '\\\\nWARNING: magnetization initialization chosen but hfield is zero. Automatically change back to default value (hfield={})\\\\n'\\n .format(self._wf_default['hfield'])\\n )\\n self.ctx.hfield = self._wf_default['hfield']\\n new_params['HFIELD'] = self.ctx.hfield\\n elif self.ctx.mag_init and self.ctx.mag_init_step_success: # turn off initialization after first (successful) iteration\\n new_params['HFIELD'] = [0.0, 0]\\n elif not self.ctx.mag_init:\\n self.report(\\\"INFO: mag_init is False. Overwrite 'HFIELD' to '0.0' and 'LINIPOL' to 'False'.\\\")\\n # reset mag init to avoid resinitializing\\n new_params['HFIELD'] = [0.0, 0]\\n\\n # set nspin to 2 if mag_init is used\\n if self.ctx.mag_init:\\n nspin_in = nspin\\n if nspin_in is None:\\n nspin_in = 1\\n if nspin_in < 2:\\n self.report('WARNING: found NSPIN=1 but for maginit needs NPIN=2. Overwrite this automatically')\\n new_params['NSPIN'] = 2\\n message = f'new_params: {new_params}'\\n self.report(message)\\n\\n # overwrite values from additional input node\\n if 'params_overwrite' in self.inputs:\\n print('use params_overwrite', self.inputs.params_overwrite.get_dict())\\n self._overwrite_parameters_from_input(new_params)\\n\\n # step 2.2 update values\\n try:\\n for key, val in new_params.items():\\n para_check.set_value(key, val, silent=True)\\n except:\\n message = 'ERROR: failed to set some parameters'\\n self.report(message)\\n return self.exit_codes.ERROR_PARAMETER_UPDATE # pylint: disable=no-member\\n\\n # step 3:\\n message = f'INFO: update parameters to: {para_check.get_set_values()}'\\n self.report(message)\\n updatenode = Dict(para_check.get_dict())\\n updatenode.label = label\\n updatenode.description = description\\n paranode_new = updatenode #update_params_wf(self.ctx.last_params, updatenode)\\n self.ctx.last_params = paranode_new\\n else:\\n message = 'INFO: reuse old settings'\\n self.report(message)\\n\\n message = 'INFO: done updating kkr param step'\\n self.report(message)\",\n \"def check_solution(self, potential_solution):\\n\\n old_k = self.K\\n new_k = potential_solution.set_K(self.len_connections)\\n\\n # accept the new state when K is higher\\n if new_k > old_k:\\n self.state = potential_solution\\n self.K = new_k\",\n \"def ekf(z_k_observation_vector, state_estimate_k_minus_1, control_vector_k_minus_1, P_k_minus_1, dk):\\n ######################### Predict #############################\\n # Predict the state estimate at time k based on the state\\n # estimate at time k-1 and the control input applied at time k-1.\\n state_estimate_k = A_k_minus_1 @ (state_estimate_k_minus_1) + (getB(state_estimate_k_minus_1[2],dk)) @ (control_vector_k_minus_1) + (process_noise_v_k_minus_1)\\n print(f'State Estimate Before EKF={state_estimate_k}\\\\r\\\\n')\\n \\n # Predict the state covariance estimate based on the previous\\n # covariance and some noise\\n P_k = A_k_minus_1 @ P_k_minus_1 @ A_k_minus_1.T + (Q_k)\\n \\n ################### Update (Correct) ##########################\\n # Calculate the difference between the actual sensor measurements\\n # at time k minus what the measurement model predicted \\n # the sensor measurements would be for the current timestep k.\\n measurement_residual_y_k = z_k_observation_vector - (\\n (H_k @ state_estimate_k) + (\\n sensor_noise_w_k))\\n \\n print(f'Observation={z_k_observation_vector}\\\\r\\\\n')\\n \\n # Calculate the measurement residual covariance\\n S_k = H_k @ P_k @ H_k.T + R_k\\n \\n # Calculate the near-optimal Kalman gain\\n # We use pseudoinverse since some of the matrices might be\\n # non-square or singular.\\n K_k = P_k @ H_k.T @ np.linalg.pinv(S_k)\\n \\n # Calculate an updated state estimate for time k\\n state_estimate_k = state_estimate_k + (K_k @ measurement_residual_y_k)\\n \\n # Update the state covariance estimate for time k\\n P_k = P_k - (K_k @ H_k @ P_k)\\n \\n # Print the best (near-optimal) estimate of the current state of the robot\\n print(f'State Estimate After EKF={state_estimate_k}\\\\r\\\\n')\\n \\n # Return the updated state and covariance estimates\\n return state_estimate_k, P_k\",\n \"def delta_kpoints(self):\\n self.get_kpoints('no')\\n ori_kp = self.kps\\n omk = min(ori_kp)\\n nmk = omk+self.diff\\n self.kps = [v*nmk/omk for v in ori_kp]\\n self.write_output()\",\n \"def adjust_k(self, ):\\n self.iteration += 1\\n\\n if self.max_violation:\\n self.k = 1\\n return 1.\\n\\n self.k = (1.-self.beta**np.float(self.iteration))\\n return self.k\",\n \"def adjust_k(self, ):\\n self.iteration += 1\\n\\n if self.max_violation:\\n self.k = 1\\n return 1.\\n\\n self.k = (1.-self.beta**np.float(self.iteration))\\n return self.k\",\n \"def find_k(model, data, tol = 1e-3):\\n\\n # Store the quantities that never change\\n pow_mod = 10 ** model\\n\\n # Make the array x_k 10 times finer than the tolerance\\n step = tol * 0.1\\n k_arr = np.arange(0, 1 + step, step)\\n\\n # Get the x_k array\\n x_k = np.array([(1 - k_arr) + k_arr * p for p in pow_mod]).T\\n\\n # And now the really useful arrays\\n coef = (pow_mod - 1)/x_k * 2/np.log(10)\\n log_x_k = np.log10(x_k)\\n\\n # Start with the extremes\\n k0 = k_arr[0:1]\\n k1 = k_arr[-1:]\\n km = (k0 + k1) * 0.5\\n\\n first = True\\n while True:\\n\\n # Each of the gradients\\n gradm = get_one_gradient(k_arr, coef, log_x_k, data, km)\\n if first:\\n # If first time, we have to calculate everything\\n grad0 = get_one_gradient(k_arr, coef, log_x_k, data, k0)\\n grad1 = get_one_gradient(k_arr, coef, log_x_k, data, k1)\\n\\n first = False\\n else:\\n # Otherwise we can use the previous calculation\\n grad0 = (sum0 * gradm + dif0 * grad0) * 0.5\\n grad1 = (sum1 * gradm + dif1 * grad1) * 0.5\\n\\n # Get signs\\n sign0 = np.sign(grad0)\\n signm = np.sign(gradm)\\n sign1 = np.sign(grad1)\\n\\n # Get differences\\n sum0 = np.abs(signm + sign0)\\n dif0 = np.abs(signm - sign0)\\n sum1 = np.abs(signm + sign1)\\n dif1 = np.abs(signm - sign1)\\n\\n # Vectorized change\\n k0 = (sum0 * km + dif0 * k0) * 0.5\\n k1 = (sum1 * km + dif1 * k1) * 0.5\\n\\n # Get the middle point\\n new_km = (k0 + k1) * 0.5\\n\\n # Check if converged\\n dif = np.abs(new_km[0] - km[0])\\n if dif < tol:\\n return new_km\\n\\n # Update\\n km = new_km\",\n \"def KL_calc(self, Rs, q_mu):\\n k_inv_mu = kron_mvp(self.K_invs, self.mu - q_mu)\\n mu_penalty = np.sum(np.multiply(self.mu - q_mu, k_inv_mu))\\n det_S = self.log_det_S(Rs)\\n trace_term = self.calc_trace_term(Rs)[0]\\n kl = 0.5 * (self.det_K - self.n - det_S +\\n trace_term + mu_penalty)\\n return max(0, kl)\",\n \"def rk8(accel,m,r,h,v): \\n k1v = accel(m,r)\\n k1r = v\\n k2v = accel(m,r + 0.25*k1r*h)\\n k2r = v + (0.25*k1v)*h\\n k3v = accel(m,r + (5/72.*k1r + 1/72.*k2r)*h)\\n k3r = v + (5/72.*k1v + 1/72.*k2v)*h\\n k4v = accel(m,r + (1/32.*k1r +3/32.*k3r)*h)\\n k4r = v + (1/32.*k1v +3/32.*k3v)*h\\n k5v = accel(m,r + (106/125.*k1r- 408/125.*k3r + 352/125.*k4r)*h)\\n k5r = v + (106/125.*k1v- 408/125.*k3v + 352/125.*k4v)*h\\n k6v = accel(m,r + (1/48.*k1r+ 8/33.*k4r - 125/528.*k5r)*h)\\n k6r = v + (1/48.*k1v+ 8/33.*k4v - 125/528.*k5v)*h\\n k7v = accel(m,r + (-13893*k1r+ 39936*k4r -64125*k5r+ 60720*k6r)*h/26411.)\\n k7r = v +(-13893*k1v+ 39936*k4v -64125*k5v+ 60720*k6v)*h/26411.\\n k8v = accel(m,r + (37/392.*k1r+ 1625/9408.*k5r -2/15.*k6r+ 61/6720*k7r)*h)\\n k8r = v + (37/392.*k1v+ 1625/9408.*k5v -2/15.*k6v+ 61/6720*k7v)*h\\n k9v = accel(m,r +(17176/25515.*k1r - 47104/25515.*k4r + 1325/504.*k5r - 41792/25515.*k6r + 20237/145800.*k7r + 4312/6075.*k8r)*h)\\n k9r = v + (17176/25515.*k1v - 47104/25515.*k4v + 1325/504.*k5v - 41792/25515.*k6v + 20237/145800.*k7v + 4312/6075.*k8v)*h\\n k10v = accel(m,r + ( -23834/180075.*k1r - 77824/1980825.*k4r- 636635/633864.*k5r + 254048/300125.*k6r - 183/7000.*k7r + 8/11.*k8r - 324/3773.*k9r)*h)\\n k10r = v + ( -23834/180075.*k1v - 77824/1980825.*k4v- 636635/633864.*k5v + 254048/300125.*k6v - 183/7000.*k7v + 8/11.*k8v - 324/3773.*k9v)*h\\n k11v= accel(m,r + (12733/7600.*k1r - 20032/5225.*k4r + 456485/80256.*k5r - 42599/7125.*k6r + 339227/912000.*k7r - 1029/4108.*k8r + 1701/1408.*k9r + 5145/2432.*k10r)*h)\\n k11r = v + (12733/7600.*k1v - 20032/5225.*k4v + 456485/80256.*k5v - 42599/7125.*k6v + 339227/912000.*k7v - 1029/4108.*k8v + 1701/1408.*k9v + 5145/2432.*k10v)*h\\n k12v = accel(m,r + h*(-27061/204120.*k1r + 40448/280665.*k4r -1353775/1197504.*k5r + 17662/25515.*k6r - 71687/1166400.*k7r + 98/225.*k8r + 1/16.*k9r + 3773/11664.*k10r))\\n k12r = v + h*(-27061/204120.*k1v + 40448/280665.*k4v -1353775/1197504.*k5v + 17662/25515.*k6v - 71687/1166400.*k7v + 98/225.*k8v + 1/16.*k9v + 3773/11664.*k10v)\\n k13v = accel(m,r + h*(11203/8680.*k1r - 38144/11935.*k4r + 2354425/458304.*k5r - 84046/16275.*k6r + 673309/1636800.*k7r + 4704/8525.*k8r + 9477/10912.*k9r - 1029/992.*k10r + 19/341.*k12r))\\n k13r = v + h*(11203/8680.*k1v - 38144/11935.*k4v + 2354425/458304.*k5v - 84046/16275.*k6v + 673309/1636800.*k7v + 4704/8525.*k8v + 9477/10912.*k9v - 1029/992.*k10v + 19/341.*k12v)\\n\\n\\n new_v8 = v + h*(13/288.*k1v +32/125.*k6v + 31213/144000.*k7v + 2401/12375.*k8v + 1701/14080.*k9v + 2401/19200.*k10v + 19/450.*k11v) \\n new_r8 = r + h*(13/288.*k1r +32/125.*k6r + 31213/144000.*k7r + 2401/12375.*k8r + 1701/14080.*k9r + 2401/19200.*k10r + 19/450.*k11r) \\n \\n return new_v8,new_r8\",\n \"def energyK(k):\\r\\n C1 = 9.7846113e-07\\r\\n C2 = 12.263868e0 \\r\\n E = (-1.0 + np.sqrt(1.0 + 4.0 * C1 * C2**2 * k**2))/(2.0 * C1)\\r\\n return E\",\n \"def _k(self, T):\\n RT = Rgas * T\\n return (self.parameters.A1 / np.exp(self.parameters.E1 / RT),\\n self.parameters.A2 / np.exp(self.parameters.E2 / RT))\",\n \"def _K_compute_eq(self):\\r\\n t_eq = self._t[self._index==0]\\r\\n if self._t2 is None:\\r\\n if t_eq.size==0:\\r\\n self._K_eq = np.zeros((0, 0))\\r\\n return\\r\\n self._dist2 = np.square(t_eq[:, None] - t_eq[None, :])\\r\\n else:\\r\\n t2_eq = self._t2[self._index2==0]\\r\\n if t_eq.size==0 or t2_eq.size==0:\\r\\n self._K_eq = np.zeros((t_eq.size, t2_eq.size))\\r\\n return\\r\\n self._dist2 = np.square(t_eq[:, None] - t2_eq[None, :])\\r\\n \\r\\n self._K_eq = np.exp(-self._dist2/(2*self.lengthscale*self.lengthscale))\\r\\n if self.is_normalized:\\r\\n self._K_eq/=(np.sqrt(2*np.pi)*self.lengthscale)\",\n \"def get_best_k_cv(air_quality_model):\\n\\n locations = air_quality_model.air_quality_locations\\n time_series = air_quality_model.air_quality_time_series\\n\\n for each_location in locations:\\n\\n other_locations = [i for i in locations if i != each_location]\\n training_time_series = time_series[other_locations]\\n scaled_training_time_series = air_quality_model.scaler.transform(training_time_series)\\n training_time_series_dropna = scaled_training_time_series.dropna().T\\n\\n # k means determine k\\n distortions = []\\n K = range(1, len(other_locations) + 1, 1)\\n for k in K:\\n kmeans = KMeans(n_clusters=k, max_iter=300).fit(training_time_series_dropna)\\n # err = sum(np.min(cdist(training_time_series_dropna, kmeans.cluster_centers_, 'euclidean'), axis=1)) \\\\\\n # / training_time_series_dropna.shape[0]\\n\\n # Sum of squared distances of samples to their closest cluster center\\n err = kmeans.inertia_\\n distortions.append(err)\\n print(k, dict(zip(other_locations, kmeans.labels_)))\\n print(each_location, k, 'err=', err)\\n\\n # Plot the elbow\\n plt.figure(figsize=(15, 20))\\n plt.plot(K, distortions, 'bx-')\\n plt.xlabel('k')\\n plt.ylabel('Distortion')\\n plt.title(str(each_location) + ' The Elbow Method showing the optimal k')\\n plt.show()\",\n \"def get_keff(self, take_final=False):\\n \\n # find max in rec (or final value, don't force as default)\\n if take_final:\\n _rec_max = self.rec_curve[-1, 1]\\n else:\\n _rec_max = numpy.max(self.rec_curve[:, 1])\\n \\n _rec_min = self.rec_curve[0, 1] \\n #Bit of a cheat - take the first point. Will be wrong in the case of \\n #very fast recovery compared to 1st interval. But in this case, _rec_min and _rec_max \\n #should be similar and caught below\\n \\n if _rec_min > 0.95 * _rec_max:\\n print (\\\"No recovery because too little desensitization (fast limit)\\\")\\n print (\\\"Setting k_eff = 1000\\\")\\n self.k_eff = 1000 #We could certainly not measure a rate this fast\\n \\n else:\\n _half_rec_amp = _rec_max - 0.5 * (_rec_max - _rec_min)\\n _near_idx = (numpy.abs(self.rec_curve[:, 1] - _half_rec_amp)).argmin()\\n _near_value = self.rec_curve [_near_idx, 1]\\n\\n #interpolate\\n #must be a smarter way to combine the two possibilities?\\n if _near_value > _half_rec_amp:\\n #true half time was before our nearest neighbor\\n _left = self.rec_curve[_near_idx - 1, 1]\\n _right = self.rec_curve[_near_idx, 1]\\n _tl = self.rec_curve[_near_idx - 1, 0]\\n _tr = self.rec_curve[_near_idx, 0]\\n #inverse of time difference scaled by normalized (point-threshold distance)\\n self.k_eff = 1 / (_tr - (_tr - _tl) * float(_right - _half_rec_amp)/(_right - _left))\\n\\n elif _near_value < _half_rec_amp:\\n #true half time was after our nearest neighbor\\n _left = self.rec_curve[_near_idx, 1]\\n _right = self.rec_curve[_near_idx + 1, 1]\\n _tl = self.rec_curve[_near_idx, 0]\\n _tr = self.rec_curve[_near_idx + 1, 0]\\n #as above rearranged to approach from below.\\n self.k_eff = 1 / (_tl + (_tr - _tl) * float(_half_rec_amp - _left)/(_right - _left))\\n\\n elif _near_value == _half_rec_amp:\\n\\n self.k_eff = 1 / self.rec_curve[near_hi_idx, 0]\",\n \"def k_Li86(wind_ms, temp_C):\\n from numpy import zeros_like\\n\\n U = wind_ms\\n T = temp_C\\n\\n Sc = schmidt_number(T)\\n k = zeros_like(temp_C)\\n\\n i1 = U <= 3.6\\n i2 = (U > 3.6) & (U < 13.0)\\n i3 = U >= 13.0\\n\\n k[i1] = (0.17 * U[i1]) * (Sc[i1] / 600) ** (-2.0 / 3.0)\\n k[i2] = ((U[i2] - 3.4) * 2.8) * (600 / Sc[i2]) ** 0.5\\n k[i3] = ((U[i3] - 8.4) * 5.9) * (600 / Sc[i3]) ** 0.5\\n\\n return k\",\n \"def get_k_gain(self, A, B, Q, R, output = 0):\\n\\n # solve the Ricatti equation\\n X = matrix(scipy.linalg.solve_continuous_are(A, B, Q, R))\\n\\n # compute the LQR gain\\n K = matrix((R)*(B.T*X))\\n\\n if output:\\n print(\\\"X-axis K Matrix Gains: \\\")\\n print(K[0])\\n print(\\\"Y-axis K Matrix Gains: \\\")\\n print(K[1])\\n\\n return K\",\n \"def gather_krec(self):\\n \\n #getting Qlo and Qhi the wrong way round here gives perfect flat s.s. recovery\\n rec1 = Recovery_Qmade(self.m1.param, self.m1.N_states, \\n self.m1.open_states, self.m1.Qlo, self.m1.Qhi, self.m1.P_init_hi, t_range=1e4)\\n\\n rec1.build_curve()\\n rec1.get_keff()\\n \\n rec2 = Recovery_Qmade(self.m2.param, self.m2.N_states, \\n self.m2.open_states, self.m2.Qlo, self.m2.Qhi, self.m2.P_init_hi, t_range=1e4)\\n\\n rec2.build_curve()\\n rec2.get_keff()\\n \\n self.k_eff1 = rec1.k_eff\\n self.k_eff2 = rec2.k_eff\\n \\n self.mean_keff = (rec1.k_eff + rec2.k_eff ) / 2\",\n \"def test_ks2x(self):\\n D, Pval = ks_test(self.x1, self.x2)\\n self.assertFloatEqual((D, Pval), (0.46, 3.801e-05), eps=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, exact=False)\\n self.assertFloatEqual((D, Pval), (0.46, 5.084e-05), eps=1e-4)\\n D, Pval = ks_test(self.x1, self.x2[:20])\\n self.assertFloatEqual((D,Pval), (0.53, 0.0003576), eps=1e-4)\\n D, Pval = ks_test(self.x2[:20], self.x1)\\n self.assertFloatEqual((D,Pval), (0.53, 0.0003576), eps=1e-4)\\n D, Pval = ks_test(self.x1[:20], self.x2)\\n self.assertFloatEqual((D,Pval), (0.48, 0.001772), eps=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, alt=\\\"greater\\\")\\n self.assertFloatEqual((D,Pval), (0.46, 2.542e-05), eps=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, alt=\\\"g\\\")\\n self.assertFloatEqual((D,Pval), (0.46, 2.542e-05), eps=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, alt=\\\"less\\\")\\n self.assertFloatEqual((D,Pval), (6.9388939039072284e-18, 1.), eps=1e-4)\\n D, Pval = ks_test(self.x2, self.x1, alt=\\\"l\\\")\\n self.assertFloatEqual((D,Pval), (0.46, 2.542e-05), eps=1e-4)\",\n \"def kge(self, return_all=False):\\n cc = np.corrcoef(self.true, self.predicted)[0, 1]\\n alpha = np.std(self.predicted) / np.std(self.true)\\n beta = np.sum(self.predicted) / np.sum(self.true)\\n return post_process_kge(cc, alpha, beta, return_all)\",\n \"def calc_K(tau, delta_t, var_n):\\n var_f = 1. - var_n\\n rval = var_f * np.exp(-(delta_t)**2 / (2. * tau**2))\\n if delta_t == 0:\\n rval += var_n\\n return rval\",\n \"def improved_initialization(X, k):\\n new_values = X.copy()\\n best_like = float('-inf')\\n MU, SIGMA, PI = None, None, None\\n for _ in range(10):\\n initial_means = get_initial_means(new_values, k)\\n pi = np.full(k, 1 / k)\\n while True:\\n mu, clusters = k_means_step(new_values, k, initial_means)\\n diff = np.sum(mu - initial_means)\\n if not diff:\\n sigma = compute_sigma(X, mu)\\n break\\n initial_means = mu\\n mu, sigma, pi, res = train_model(X, k, default_convergence, (mu, sigma, pi))\\n lk = likelihood(X, pi, mu, sigma, k)\\n if lk > best_like:\\n best_like = lk\\n MU = mu\\n SIGMA = sigma\\n PI = pi\\n return MU, SIGMA, PI\",\n \"def compute_kalman_gain(jacobian, oldCovariance, measurementCovariance):\\n\\n return None\",\n \"def calibration(N,kb,T,Ekinv,V):\\n lamb = np.sqrt((N-1)*3*kb*T/(Ekinv*2))\\n \\n if lamb < 0.9999:\\n V = lamb*V\\n elif lamb>1.0001:\\n V = lamb*V\\n \\n return V\",\n \"def kappas(self):\\n a, c, d, b = self.to_ccw()\\n p1, q1 = a + b, c + d\\n p2, q2 = a + c, b + d\\n n = a + b + c + d\\n\\n if a == n or d == n:\\n k0, k1 = np.nan, np.nan\\n elif b == n:\\n k0, k1 = np.NINF, -0.0\\n elif c == n:\\n k0, k1 = -0.0, np.NINF\\n elif p1 == n or q2 == n:\\n k0, k1 = np.nan, 0.0\\n elif p2 == n or q1 == n:\\n k0, k1 = 0.0, np.nan\\n else:\\n cov = self.covar()\\n p2_q1, p1_q2 = p2 * q1, p1 * q2\\n k0, k1 = _div(cov, p2_q1), _div(cov, p1_q2)\\n\\n return k0, k1, self.kappa()\",\n \"def metropolis_accept(self, old_protein, new_protein, T):\\n delta_E = self.compute_energy(new_protein) - self.compute_energy(old_protein)\\n \\n if delta_E <= 0: \\n p = 1\\n else: \\n p = math.e**(-delta_E/T)\\n return(p)\",\n \"def KPMO(XVal,YVal_State_1,YVal_State_2,YVal_State_3,XVal_Mean_Trans_1,XVal_Mean_Trans_2,XVal_Sig_Trans_1,XVal_Sig_Trans_2,iOpt):\\n#\\t1. Computations:\\n\\tTiny=1E-20\\n\\tP_Trans_1 = fCPD(XVal,XVal_Mean_Trans_1, XVal_Sig_Trans_1) # Transition of kerogen from State #1 to State #2\\n\\tP_Trans_2 = fCPD(XVal,XVal_Mean_Trans_2, XVal_Sig_Trans_2) # Transition of kerogen from State #2 to State #3\\n\\tFunVal=0\\n\\tif(iOpt==0):\\n\\t\\tP_State_1=(1-P_Trans_1)*(1-P_Trans_2)\\n\\t\\tP_State_2=P_Trans_1*(1 - P_Trans_2)\\n\\t\\tP_State_3=1-P_State_1-P_State_2\\n\\t\\tFunVal=(YVal_State_1*P_State_1)+(YVal_State_2*P_State_2)+(YVal_State_3*P_State_3)\\n\\tif(iOpt==1):\\n\\t\\tFunVal=YVal_State_1+P_Trans_1*YVal_State_2+P_Trans_2*YVal_State_3\\n\\tif(FunVal==0):\\n\\t\\tFunVal=Tiny\\n\\treturn FunVal\",\n \"def EstimateKFTimeStep(u1,y1,z0,Xxd,Xud,Yx,Yu,P0,Q,R):\\n \\n # estimate next step\\n z1m = Xxd.dot(z0) + Xud.dot(u1)\\n y1hat = Yx.dot(z1m) + Yu.dot(u1)\\n P1m = (Xxd.dot(P0)).dot(Xxd.T) + Q\\n \\n # Calculate Kalman gain\\n # same as Lk from [1] - And their Rtilde_k is G*P1m*G'+R\\n Kk = np.dot(P1m,Yx.T).dot( np.linalg.inv(((Yx.dot(P1m)).dot(Yx.T) + R))) \\n # update estimate with measurement\\n z1 = z1m + Kk.dot(y1 - y1hat)\\n \\n P1 = (np.eye(Xxd.shape[0]) - Kk.dot(Yx) ).dot(P1m)\\n return z1,P1,Kk\",\n \"def epsilon_fit_Chang(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_l1,f_l2,f_t1,f_t2,epsinf1,epsinf2):\\n # Chang PRB38 12369\\n v = 1e4/l_onde\\n \\n epsx = (epsinf1+epsinf2)/2 - (f_t1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_t2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\\n epsz = 1/(((1/2)*(1/epsinf1 + 1/epsinf2)) + (f_l1*(vl1**2 - vt1**2))/(-vl1**2 + v**2 + 1j*v*gl1) + (f_l2*(vl2**2 - vt2**2))/(-vl2**2 + v**2 + 1j*v*gl2))\\n \\n# eps1 = epsinf1*(1 - (f_t1*(vl1**2 - vt1**2))/(vt1**2 - v**2 - 1j*v*gt1))\\n# eps2 = epsinf2*(1 - (f_t2*(vl2**2 - vt2**2))/(vt2**2 - v**2 - 1j*v*gt2))\\n# epsx = (1/2)*(eps1+eps2)\\n# epsz = 1/((1/2)*(1/eps1 + 1/eps2))\\n \\n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))\",\n \"def epsilon_fit_Chang_homemade(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_t1,f_t2,f_l1,f_l2,epsinf1,epsinf2):\\n # Chang PRB38 12369\\n v = 1e4/l_onde\\n \\n epsx = (epsinf1+epsinf2)/2 - (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\\n epsz = 1/(1/((epsinf1+epsinf2)/2) + (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) + (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2))\\n #epsx = (1/2)*(eps1+eps2)\\n #epsz = 1/((1/2)*(1/eps1 + 1/eps2))\\n \\n #epsx = (1/2)*epsinf1*(1-(f_t1*(v**2 - vl1**2 + 1j*v*gl1)/(v**2 - vt1**2 + 1j*v*gt1))-\\\\\\n # (f_t2*(v**2 - vl2**2 + 1j*v*gl2)/(v**2 - vt2**2 + 1j*v*gt2)))\\n #epsz = 1/((1/2)*(1/epsinf2)*(1+(f_l1*(v**2 - vt1**2 +1j*v*gl1)/(v**2 - vl1**2 +1j*v*gl1))+\\\\\\n # (f_l2*(v**2 - vt2**2 +1j*v*gl2)/(v**2 - vl2**2 +1j*v*gl2))))\\n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))\",\n \"def test_k_index():\\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\\n 400.]) * units.hPa\\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\\n -23.5]) * units.degC\\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\\n -57.5]) * units.degC\\n ki = k_index(pressure, temperature, dewpoint)\\n assert_almost_equal(ki, 33.5 * units.degC, 2)\",\n \"def converged(old, new):\\n # https://github.com/amirgholami/PyHessian/commit/0f7e0f63a0f132998608013351ba19955fc9d861#diff-ba06409ffbc677fe556485172e62649fe7a069631390f5a780766bff3289b06bR149-R150 # noqa: B950\\n return (old - new).abs() / (old.abs() + 1e-6) < tol\",\n \"def KRC(self, ik, ipd, ipl, t):\\n idx = ik - 1\\n\\n den1 = 1 - self.delta[idx] * self.coca.PK(ik, t)\\n num1 = self.delta[idx] * self.thetak[idx]\\n ins = num1 / den1\\n\\n for l in np.arange(0, self.L):\\n pl = self.coca.PL(l, t)\\n ins += ((self.thetal[l] * self.gamma[l][idx]) / (1 - pl))\\n\\n ans = ipd * np.exp(t * ipl) * ins\\n\\n return ans\",\n \"def jansky_to_kelvin(self):\\n this_unit = self.stokes.unit\\n if self.component_type == \\\"point\\\":\\n if this_unit.is_equivalent(\\\"K sr\\\"):\\n return\\n\\n else:\\n if this_unit.is_equivalent(\\\"K\\\"):\\n return\\n\\n if self.spectral_type == \\\"spectral_index\\\" or (\\n self.spectral_type == \\\"flat\\\" and self.reference_frequency is not None\\n ):\\n conv_factor = skyutils.jy_to_ksr(self.reference_frequency)\\n conv_factor = np.repeat(\\n np.repeat(conv_factor[np.newaxis, np.newaxis, :], 4, axis=0),\\n self.Nfreqs,\\n axis=1,\\n )\\n elif self.freq_array is not None:\\n conv_factor = skyutils.jy_to_ksr(self.freq_array)\\n conv_factor = np.repeat(\\n np.repeat(conv_factor[np.newaxis, :, np.newaxis], 4, axis=0),\\n self.Ncomponents,\\n axis=2,\\n )\\n else:\\n raise ValueError(\\n \\\"Either reference_frequency or freq_array must be set to convert to K.\\\"\\n )\\n\\n self.stokes = self.stokes * conv_factor\\n if self.stokes_error is not None:\\n self.stokes_error = self.stokes_error * conv_factor\\n\\n if self.frame_coherency is not None:\\n self.calc_frame_coherency()\",\n \"def test_calc_k_c():\\n\\n P_x0 = ufloat(1.75789868673e-12, 1.75789868673e-14) * u.nm**2/u.Hz # 1/100\\n f_c = ufloat(50000, 0.5) * u.Hz # 1/100000 relative\\n Q = ufloat(10000, 100) * u.dimensionless # 1/100\\n T = ufloat(300, 3) * u.K # 1/100\\n # ex_k_c is no longer a nice number because I switched from a rounded to\\n # more exact value for Boltzmann's constant\\n ex_k_c = ufloat(2.9999965233852217, 0.05196147267057527) * u.N/u.m\\n k_c = calc_k_c(f_c, Q, P_x0, T)\\n assert_almost_equal(k_c.magnitude.n, ex_k_c.magnitude.n)\\n assert_almost_equal(k_c.magnitude.s, ex_k_c.magnitude.s)\",\n \"def advance(self):\\n\\n f, n, rtol, atol, neq = \\\\\\n self.f, self.n, self.rtol, self.atol, self.neq\\n u_n, t_n, t_next = self.u[n], self.t[n], self.t[n+1]\\n dt = t_next - t_n\\n\\n first_step = dt # try one big step to next desired level\\n\\n def middle(x,y,z): # Auxilary function\\n return sorted([x,y,z])[1]\\n\\n # Extract coefficients from Butcher-tableau\\n table = self._butcher_tableau\\n k_len = table.shape[1] - 1 # number of internal stages\\n\\n # coefficients for internal stages\\n factors_u = np.asarray(table[:k_len, 1:])\\n # coefficients for t\\n factors_t = table[:k_len, 0]\\n # coefficients for u_new\\n factors_u_new = table[k_len, 1:]\\n\\n # coefficients for local error between 2 levels\\n factors_error = table[k_len+1, 1:] - factors_u_new\\n\\n u_intermediate = [u_n,]\\n t_intermediate = [t_n,]\\n u, t, h = u_n, t_n, first_step # initial values\\n k = np.zeros((k_len, self.neq), self.dtype) # intern stages\\n\\n if self.verbose > 0:\\n print 'advance solution in [%s, %s], h=%g' % (t_n, t_next, h)\\n\\n # Loop until next time point is reached\\n while (abs(t - t_n) < abs(t_next - t_n)):\\n u, t = u_intermediate[-1], t_intermediate[-1]\\n\\n # Internal steps\\n k[:, :] = 0. # initialization for next step\\n for m in range(k_len):\\n k_factors = (np.dot(factors_u, k))[m]\\n #print u, u+h*k_factors, f(u+h*k_factor, 0.5), self.dtype\\n k[m] = f(u+h*k_factors, t+h*factors_t[m])\\n u_new = u + h*(np.dot(factors_u_new, k))\\n\\n self.info['rejected'] += 1 # reduced below if accepted\\n if self.verbose > 0:\\n print ' u(t=%g)=%g: ' % (t+h, u_new),\\n\\n # local error between 2 levels\\n error = h*np.abs(np.dot(factors_error, k))\\n # Acceptable error tolerance\\n tol = rtol*np.abs(u_new) + atol\\n\\n accurate = (error <= tol).all()\\n\\n if accurate or h <= self.min_step or h >= self.max_step:\\n # Accurate enough,\\n # or the step size exceeds valid range,\\n # must accept this solution\\n u_intermediate.append(u_new)\\n t_intermediate.append(t+h)\\n if not self.disk_storage:\\n self.u_all.append(u_new)\\n self.t_all.append(t+h)\\n self.info['rejected'] -= 1\\n\\n if self.verbose > 0:\\n print 'accepted, ',\\n else:\\n if self.verbose > 0:\\n print 'rejected, ',\\n\\n if self.verbose > 0:\\n print 'err=%s, ' % str(error),\\n if hasattr(self, 'u_exact') and callable(self.u_exact):\\n print 'exact-err=%s, ' % \\\\\\n (np.asarray(self.u_exact(t+h))-u_new),\\n if h <= self.min_step:\\n print 'h=min_step!! ',\\n\\n\\n # Replace 0 values by 1e-16 since we will divide by error\\n error = np.asarray([(1e-16 if x == 0. else x) \\\\\\n for x in error])\\n\\n # Normarized error rate\\n rms = error/tol\\n rms_norm = np.sqrt(np.sum(rms*rms)/self.neq)\\n\\n order = float(self._method_order[0])\\n # factor to adjust the size of next step\\n # Formula is from <Numerical Methods for Engineers,\\n # Chappra & Cannle>\\n s = .8 *((1./rms_norm)**(1/order))\\n # scalar should be in range(0.1, 4.)\\n # for better accuracy and smoothness\\n s = middle(s, 0.1, 4.0)\\n h *= s\\n\\n # step size should be in range [min_step, max_step]\\n h = middle(h, self.min_step, self.max_step)\\n # adjust h to fit the last step\\n h = min(h, t_next - t_intermediate[-1])\\n\\n if self.verbose > 0:\\n print 'new h=%g' % h\\n\\n if h == 0:\\n break\\n\\n return u_new\",\n \"def k_Sw07(wind_second_moment, temp_C):\\n\\n U2 = wind_second_moment\\n\\n Sc = schmidt_number(temp_C)\\n k = (0.27 * U2) * (660 / Sc) ** 0.5\\n\\n return k\",\n \"def check_solution(self, new_protein):\\n new_score = new_protein.getscore()\\n old_value = self.best_value\\n\\n if new_score >= old_value:\\n self.best_solution = new_protein\\n self.best_value = new_score\",\n \"def _adjust_k(scheme, k, ef=EF):\\n scheme = rx.core._check_scheme(scheme) # noqa: SLF001\\n is_half_equilibrium = np.asarray(scheme.is_half_equilibrium)\\n k = np.asarray(k, dtype=np.float64).copy()\\n\\n if np.any(is_half_equilibrium):\\n # at least one equilibrium\\n if np.any(~is_half_equilibrium):\\n # at least one true reaction\\n\\n k_slowest_equil = k[is_half_equilibrium].min()\\n k_fastest_react = k[~is_half_equilibrium].max()\\n adjustment = ef * (k_fastest_react / k_slowest_equil)\\n\\n k[is_half_equilibrium] *= adjustment\\n logger.warning(f\\\"equilibria adjustment = {adjustment}\\\") # noqa: G004\\n\\n k_slowest_equil = k[is_half_equilibrium].min()\\n k_fastest_react = k[~is_half_equilibrium].max()\\n logger.warning(\\n f\\\"slow eq. / fast r. = {k_slowest_equil / k_fastest_react}\\\", # noqa: E501, G004\\n )\\n else:\\n # only equilibria\\n\\n # set the smallest one to be equal to one\\n k = k / k.min()\\n\\n return jnp.asarray(k)\",\n \"def SSt_theo_old(D, k):\\n\\ta1b = k[\\\"A1B1\\\"]\\n\\tba1 = k[\\\"B1A1\\\"]\\n\\tca1 = k[\\\"C1A1\\\"]\\n\\tcb = k[\\\"B1C1\\\"]\\n\\tnum = a1b*ba1*ca1*ca1 + ba1*ba1*ca1*ca1 + 3*a1b*ba1*ca1*cb + 2*ba1*ba1*ca1*cb + \\\\\\n\\t\\t\\ta1b*ca1*ca1*cb + 2*ba1*ca1*ca1*cb + 2*a1b*ba1*cb*cb + ba1*ba1*cb*cb + \\\\\\n\\t\\t\\t2*a1b*ca1*cb*cb + 2*ba1*ca1*cb*cb + ca1*ca1*cb*cb + \\\\\\n\\t\\t\\t\\\\\\n\\t\\t\\t(a1b*ba1*ba1*ca1 + ba1*ba1*ba1*ca1 + a1b*ba1*ca1*ca1 + a1b*ca1*ca1*ca1 + \\\\\\n\\t\\t\\t3*ba1*ca1*ca1*ca1 + 2*a1b*ba1*ba1*cb + ba1*ba1*ba1*cb + 2*a1b*ba1*ca1*cb + \\\\\\n\\t\\t\\t3*ba1*ba1*ca1*cb + 4*a1b*ca1*ca1*cb + 5*ba1*ca1*ca1*cb + 3*ca1*ca1*ca1*cb + \\\\\\n\\t\\t\\t2*a1b*ba1*cb*cb + 2*ba1*ba1*cb*cb + 2*a1b*ca1*cb*cb + 4*ba1*ca1*cb*cb + \\\\\\n\\t\\t\\t2*ca1*ca1*cb*cb) * D + \\\\\\n\\t\\t\\t\\\\\\n\\t\\t\\t(a1b*ba1*ba1*ca1 + a1b*ba1*ca1*ca1 + 4*ba1*ba1*ca1*ca1 + a1b*ca1*ca1*ca1 + \\\\\\n\\t\\t\\t2*ca1*ca1*ca1*ca1 + ba1*ba1*ba1*cb + 3*a1b*ba1*ca1*cb + 3*ba1*ba1*ca1*cb + \\\\\\n\\t\\t\\ta1b*ca1*ca1*cb + 5*ba1*ca1*ca1*cb + 3*ca1*ca1*ca1*cb + ba1*ba1*cb*cb + \\\\\\n\\t\\t\\t2*ba1*ca1*cb*cb + ca1*ca1*cb*cb) * D*D + \\\\\\n\\t\\t\\t\\\\\\n\\t\\t\\t(ba1*ba1*ba1*ca1 + a1b*ba1*ca1*ca1 + 3*ba1*ca1*ca1*ca1 + 2*ba1*ba1*ca1*cb + \\\\\\n\\t\\t\\t2*ba1*ca1*ca1*cb) * D*D*D + \\\\\\n\\t\\t\\t\\\\\\n\\t\\t\\tba1*ba1*ca1*ca1 * D*D*D*D\\n\\t##\\n\\tden = a1b*(ba1*ba1*ca1*ca1 + 2*ba1*ba1*ca1*cb + 2*ba1*ca1*ca1*cb + ba1*ba1*cb*cb + \\n\\t\\t\\t2*ba1*ca1*cb*cb + ca1*ca1*cb*cb) + \\\\\\n\\t\\t\\t\\\\\\n\\t\\t\\ta1b*(4*ba1*ca1*ca1*ca1 + 2*ba1*ba1*ca1*cb + 6*ba1*ca1*ca1*cb + 4*ca1*ca1*ca1*cb + \\n\\t\\t\\t2*ba1*ba1*cb*cb + 4*ba1*ca1*cb*cb + 2*ca1*ca1*cb*cb) * D + \\\\\\n\\t\\t\\t\\\\\\n\\t\\t\\ta1b*(2*ba1*ba1*ca1*ca1 + 4*ca1*ca1*ca1*ca1 + 2*ba1*ba1*ca1*cb + 6*ba1*ca1*ca1*cb + \\n\\t\\t\\t4*ca1*ca1*ca1*cb + ba1*ba1*cb*cb + 2*ba1*ca1*cb*cb + ca1*ca1*cb*cb) * D*D + \\\\\\n\\t\\t\\t\\\\\\n\\t\\t\\ta1b*(4*ba1*ca1*ca1*ca1 + 2*ba1*ba1*ca1*cb + 2*ba1*ca1*ca1*cb) * D*D*D + \\\\\\n\\t\\t\\t\\\\\\n\\t\\t\\ta1b*ba1*ba1*ca1*ca1 * D*D*D*D\\n\\t##\\n\\ttau = num/den\\n\\t##\\n\\treturn tau*np.log(20)\",\n \"def test_ks2x(self):\\n D, Pval = ks_test(self.x1, self.x2)\\n assert_allclose((D, Pval), (0.46, 3.801e-05), rtol=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, exact=False)\\n assert_allclose((D, Pval), (0.46, 5.084e-05), rtol=1e-4)\\n D, Pval = ks_test(self.x1, self.x2[:20])\\n assert_allclose((D, Pval), (0.53, 0.0003576), rtol=1e-4)\\n D, Pval = ks_test(self.x2[:20], self.x1)\\n assert_allclose((D, Pval), (0.53, 0.0003576), rtol=1e-4)\\n D, Pval = ks_test(self.x1[:20], self.x2)\\n assert_allclose((D, Pval), (0.48, 0.001772), rtol=1e-3)\\n D, Pval = ks_test(self.x1, self.x2, alt=\\\"greater\\\")\\n assert_allclose((D, Pval), (0.46, 2.542e-05), rtol=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, alt=\\\"g\\\")\\n assert_allclose((D, Pval), (0.46, 2.542e-05), rtol=1e-4)\\n D, Pval = ks_test(self.x1, self.x2, alt=\\\"less\\\")\\n assert_allclose((D, Pval), (6.9388939039072284e-18, 1.0), rtol=1e-4)\\n D, Pval = ks_test(self.x2, self.x1, alt=\\\"l\\\")\\n assert_allclose((D, Pval), (0.46, 2.542e-05), rtol=1e-4)\",\n \"def adjust_k(epoch, initial_k, increase_k, max_violation=False):\\n if max_violation:\\n return 1.\\n\\n return min(initial_k + (increase_k * epoch), 1.)\",\n \"def kl(self, old_dist_info, new_dist_info):\\n old_prob = old_dist_info[\\\"prob\\\"]\\n new_prob = new_dist_info[\\\"prob\\\"]\\n return np.sum(\\n old_prob * (np.log(old_prob + TINY) - np.log(new_prob + TINY)),\\n axis=2\\n )\",\n \"def kf_algorithm(self, u, y):\\n # For the linear filter, x_estimated_state is the difference to the operating point\\n cov_matrix_before = self.cov_matrix\\n # 0. Calculate difference to operating point\\n u = u - self.u_op\\n if self.model_type == ModelType.EASY:\\n x_est_before = self.x_estimated_state - self.operating_point[0:6].reshape((6, 1))\\n # x_est_before.reshape((6, 1))\\n else:\\n x_est_before = self.x_estimated_state - self.operating_point.reshape((8, 1))\\n # x_est_before.reshape((8, 1))\\n if self.nOutputs == 3:\\n y = y - self.operating_point[0:3].reshape(3, 1)\\n elif self.nOutputs == 5:\\n y = y - np.concatenate((self.operating_point[0:3], self.operating_point[6:8])).reshape(5, 1)\\n # x_est_before = self.x_estimated_state - self.operating_point\\n # 1. Prediction\\n # predict the state by using the linearized system at the fixed operating point\\n v_s = u[0][0] + u[1][0]\\n v_d = u[0][0] - u[1][0]\\n x_est_predict = self.Ak @ x_est_before + self.Bk @ u\\n # predict the new covariance\\n cov_matrix_predict = (self.Ak @ cov_matrix_before @ np.transpose(self.Ak)\\n + self.Bk @ self.N @ np.transpose(self.Bk))\\n # 2. Update\\n # compute kalman gain\\n Kl = (cov_matrix_predict @ np.transpose(self.Ck) @\\n np.linalg.inv(self.Ck @ cov_matrix_predict @ np.transpose(self.Ck) + self.W))\\n # update state\\n if self.nOutputs == 3:\\n y_est = x_est_predict[0:3,]\\n elif self.nOutputs == 5:\\n y_est = np.concatenate((x_est_predict[0:3], x_est_predict[6:8]))\\n x_est_update = x_est_predict + Kl @ (y - y_est)\\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ self.Ck) @ cov_matrix_predict\\n # add again the operating point\\n if self.model_type == ModelType.EASY:\\n x_estimated_state = x_est_update + self.operating_point[0:6].reshape((6, 1))\\n # self.x_estimated_state = x_estimated_state.reshape((1, 6))[0]\\n else:\\n x_estimated_state = x_est_update + self.operating_point.reshape((8, 1))\\n # self.x_estimated_state = x_estimated_state.reshape((1, 8))[0]\\n\\n if self.should_check_limits:\\n # check if the update step state needs to be changed because of limit crossing\\n # if that is the case, correct the state and set the state of the simulation accordingly\\n corrected_state = self.heliSim.get_limited_state_and_change_state_without_sim(np.transpose(x_estimated_state)[0],\\n self.model_type)\\n x_estimated_state = np.resize(corrected_state, (self.nStateVars, 1))\\n self.x_estimated_state = x_estimated_state\\n self.cov_matrix = cov_matrix_update\\n # print(\\\"------\\\")\\n # print(cov_matrix_predict)\\n return x_estimated_state\",\n \"def K(self, X, Xstar):\\n r = l2norm_(X, Xstar)\\n bessel = kv(self.v, np.sqrt(2 * self.v) * r / self.l)\\n f = 2 ** (1 - self.v) / gamma(self.v) * (np.sqrt(2 * self.v) * r / self.l) ** self.v\\n res = f * bessel\\n res[np.isnan(res)] = 1\\n res = self.sigmaf * res + self.sigman * kronDelta(X, Xstar)\\n return (res)\",\n \"def test_klauder(self):\\n ideal = np.array([0.14899879, -0.16633309, -0.42806931, 0.16605633,\\n 0.70769336, 0.16605633, -0.42806931, -0.16633309])\\n actual = misc.klauder(8)\\n np.testing.assert_allclose(ideal, actual, atol=1e-8, rtol=1e-8)\",\n \"def get_old_solution(self, x, k=None, get_ctrl_traj=False):\\n if self.n_fail > self.n_safe:\\n warnings.warn(\\n \\\"There are no previous solution to be applied. Returning None\\\")\\n return None\\n if k is None:\\n k = self.n_fail\\n\\n if k < 1:\\n warnings.warn(\\\"Have to shift at least one timestep back\\\")\\n return None\\n\\n k_fb_old = self.k_fb_safe_all[k - 1]\\n k_ff = self.k_ff_safe[k - 1, :, None]\\n p_safe = self.p_safe[k - 1, :, None]\\n\\n u_apply = feedback_ctrl(x, k_ff, k_fb_old, p_safe)\\n if get_ctrl_traj:\\n k_fb_safe_traj = None\\n k_ff_safe_traj = u_apply\\n p_ctrl_safe_traj = None\\n\\n if k < self.n_safe:\\n k_fb_safe_traj = self.k_fb_safe_all[k:, :]\\n # in accordance to the structure current ctrl u_apply is part of the k_ff ctrl trajectory\\n k_ff_safe_traj = np.vstack((u_apply, self.k_ff_safe[k + 1:, :]))\\n p_ctrl_safe_traj = self.p_safe[k:, :]\\n\\n return u_apply, k_fb_safe_traj, \\\\\\n k_ff_safe_traj, p_ctrl_safe_traj\\n\\n return u_apply\",\n \"def diff_k_p1(p1, p2, t=0.):\\n return p1\",\n \"def _calc_k_gain(self, cov_m, h_tilde, R_cov):\\n B = np.matmul(cov_m, np.transpose(h_tilde))\\n G = np.matmul(h_tilde, np.matmul(cov_m,\\n np.transpose(h_tilde)))\\n T = np.linalg.inv(np.add(G, R_cov))\\n\\n return np.matmul(B, T)\",\n \"def calc_ST_operation(m_exhaust_GT_kgpers, T_exhaust_GT_K, T_sup_K, fuel_type):\\n\\n # calaulate High Pressure (HP) and Low Pressure (LP) mass flow of a double pressure steam turbine\\n temp_i_K = (0.9 * ((6 / 48.2) ** (0.4 / 1.4) - 1) + 1) * (T_exhaust_GT_K - ST_DELTA_T)\\n if fuel_type == 'NG':\\n Mexh = 103.7 * 44E-3 + 196.2 * 18E-3 + 761.4 * 28E-3 + 200.5 * (CC_AIRRATIO - 1) * 32E-3 \\\\\\n + 200.5 * (CC_AIRRATIO - 1) * 3.773 * 28E-3\\n ncp_exh = 103.7 * 44 * 0.846 + 196.2 * 18 * 1.8723 + 761.4 * 28 * 1.039 \\\\\\n + 200.5 * (CC_AIRRATIO - 1) * 32 * 0.918 + 200.5 * (CC_AIRRATIO - 1) * 3.773 * 28 * 1.039\\n cp_exh = ncp_exh / Mexh # J/kgK\\n else:\\n Mexh = 98.5 * 44E-3 + 116 * 18E-3 + 436.8 * 28E-3 + 115.5 * (CC_AIRRATIO - 1) * 32E-3 \\\\\\n + 115.5 * (CC_AIRRATIO - 1) * 3.773 * 28E-3\\n ncp_exh = 98.5 * 44 * 0.846 + 116 * 18 * 1.8723 + 436.8 * 28 * 1.039 \\\\\\n + 115.5 * (CC_AIRRATIO - 1) * 32 * 0.918 + 115.5 * (CC_AIRRATIO - 1) * 3.773 * 28 * 1.039\\n cp_exh = ncp_exh / Mexh # J/kgK\\n\\n a = np.array([[1653E3 + HEAT_CAPACITY_OF_WATER_JPERKGK * (T_exhaust_GT_K - ST_DELTA_T - 534.5), \\\\\\n HEAT_CAPACITY_OF_WATER_JPERKGK * (temp_i_K - 534.5)], \\\\\\n [HEAT_CAPACITY_OF_WATER_JPERKGK * (534.5 - 431.8), \\\\\\n 2085.8E3 + HEAT_CAPACITY_OF_WATER_JPERKGK * (534.5 - 431.8)]])\\n b = np.array([m_exhaust_GT_kgpers * cp_exh * (T_exhaust_GT_K - (534.5 + ST_DELTA_T)), \\\\\\n m_exhaust_GT_kgpers * cp_exh * (534.5 - 431.8)])\\n [mdotHP_kgpers, mdotLP_kgpers] = np.linalg.solve(a, b)\\n\\n # calculate thermal output\\n T_cond_0_K = T_sup_K + CC_DELTA_T_DH # condensation temperature constrained by the DH network temperature\\n pres0 = (0.0261 * (T_cond_0_K - 273) ** 2 - 2.1394 * (T_cond_0_K - 273) + 52.893) * 1E3\\n\\n delta_h_evap_Jperkg = (-2.4967 * (T_cond_0_K - 273) + 2507) * 1E3\\n q_output_ST_W = (mdotHP_kgpers + mdotLP_kgpers) * delta_h_evap_Jperkg # thermal output of ST\\n\\n # calculate electricity output\\n h_HP_Jperkg = (2.5081 * (T_exhaust_GT_K - ST_DELTA_T - 273) + 2122.7) * 1E3 # J/kg\\n h_LP_Jperkg = (2.3153 * (temp_i_K - 273) + 2314.7) * 1E3 # J/kg\\n h_cond_Jperkg = (1.6979 * (T_cond_0_K - 273) + 2506.6) * 1E3 # J/kg\\n\\n el_produced_ST_W = mdotHP_kgpers * (h_HP_Jperkg - h_LP_Jperkg) + \\\\\\n (mdotHP_kgpers + mdotLP_kgpers) * (h_LP_Jperkg - h_cond_Jperkg) # turbine electricity output\\n\\n el_input_compressor_W = SPEC_VOLUME_STEAM * (\\n mdotLP_kgpers * (6E5 - pres0) + (mdotHP_kgpers + mdotLP_kgpers) * (48.2E5 - 6E5)) # compressor electricity use\\n\\n el_output_ST_W = ST_GEN_ETA * (el_produced_ST_W - el_input_compressor_W) # gross electricity production of turbine\\n\\n return q_output_ST_W, el_output_ST_W\",\n \"def k_Wa92(wind_second_moment, temp_C):\\n\\n U2 = wind_second_moment\\n\\n Sc = schmidt_number(temp_C)\\n k = (0.31 * U2) * (660 / Sc) ** 0.5\\n\\n return k\",\n \"def kl_sym(self, old_dist_info_vars, new_dist_info_vars):\\n old_prob_var = old_dist_info_vars[\\\"prob\\\"]\\n new_prob_var = new_dist_info_vars[\\\"prob\\\"]\\n # Assume layout is N * T * A\\n return tf.reduce_sum(\\n old_prob_var * (tf.log(old_prob_var + TINY) - tf.log(new_prob_var + TINY)),\\n axis=2\\n )\",\n \"def temperature(k, kmax):\\n return 1.0 / 500 * (1.0 / k - 1.0 / kmax)\",\n \"def __kappa_mle(self, k, R):\\n return (iv(1, k) / iv(0, k)) - R\",\n \"def quasi_optimalityTV(f, lam_init = 2.0, q = 0.9):\\n \\n lam = lam_init\\n max_iter = 50\\n error = np.zeros(max_iter)\\n #alt_error = np.zeros(max_iter)\\n u_old = ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\\n for i in range(1, max_iter):\\n lam = lam_init * (q ** i)\\n u_new = ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\\n error[i] = np.linalg.norm(u_old - u_new)\\n #alt_error[i] = np.linalg.norm(u_old - u_new) /abs(lam_init*(q ** i - q ** (i-1)))\\n u_old = np.copy(u_new)\\n\\n #plt.plot(error)\\n #plt.plot(alt_error)\\n #plt.show()\\n opt_idx = np.argmin(error[error != 0.0])\\n t = 1.0 / (1.0 + lam_init * (q ** opt_idx))\\n lam = lam_init * (q ** opt_idx)\\n u= ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\\n \\n return u, t\",\n \"def initial_estimator(f, x, step,k):\\n\\n fx = f(x)\\n\\n if decide(fx > 0):\\n sign1 = 1\\n else:\\n sign1 = -1\\n k_step = k\\n h = fx / derivative(f, x)\\n\\n for k1 in range(1, 50000):\\n step = step + 1\\n x_new = x - k_step * h\\n k_step = k_step * 2 # make the k double in each iteration\\n fx_new = f(x_new)\\n if decide(fx_new > 0):\\n sign2 = 1\\n else:\\n sign2 = -1\\n\\n if not (sign1 == sign2):\\n return x_new, step\\n\\n print(\\\"limit need to Increase\\\")\",\n \"def elo(old, exp, score, k=10):\\n return old + k * (score - exp)\",\n \"def ekf_algorithm(self, u, y):\\n x_est_before = self.x_estimated_state\\n cov_matrix_before = self.cov_matrix\\n # 1. Prediction\\n # predict the state by integrate the time continuous system numerically\\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\\n x_est_predict = np.resize(sim_state_predict, (8, 1))\\n # predict the new covariance by linearizing and discretizing the model\\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\\n # 2. Update\\n # compute kalman gain\\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\\n # update state\\n y_est = x_est_predict[0:3]\\n x_est_update = x_est_predict + Kl @ (y - y_est)\\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\\n\\n # check if the update step state needs to be changed because of limit crossing\\n # if that is the case, correct the state and set the state of the simulation accordingly\\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 8))[0],\\n ModelType.GYROMOMENT)\\n x_est_update = np.resize(corrected_state, (8, 1))\\n\\n self.x_estimated_state = x_est_update\\n self.cov_matrix = cov_matrix_update\\n # print(\\\"------\\\")\\n # print(cov_matrix_predict)\\n return x_est_update\",\n \"def calc_q_gain(Tfl, Tabs, q_rad_Whperm2, DT, Tin, Tout, aperture_area_m2, c1, c2, Mfl, delts, Cp_waterglycol, C_eff, Te):\\n\\n xgain = 1\\n xgainmax = 100\\n exit = False\\n while exit == False:\\n qgain_Whperm2 = q_rad_Whperm2 - c1 * (DT[1]) - c2 * abs(DT[1]) * DT[1] # heat production from solar collector, eq.(5)\\n\\n if Mfl > 0:\\n Tout = ((Mfl * Cp_waterglycol * Tin) / aperture_area_m2 - (C_eff * Tin) / (2 * delts) + qgain_Whperm2 + (\\n C_eff * Tfl[1]) / delts) / (Mfl * Cp_waterglycol / aperture_area_m2 + C_eff / (2 * delts)) # eq.(6)\\n Tfl[2] = (Tin + Tout) / 2\\n DT[2] = Tfl[2] - Te\\n qdiff = Mfl / aperture_area_m2 * Cp_waterglycol * 2 * (DT[2] - DT[1])\\n else:\\n Tout = Tfl[1] + (qgain_Whperm2 * delts) / C_eff # eq.(8)\\n Tfl[2] = Tout\\n DT[2] = Tfl[2] - Te\\n qdiff = 5 * (DT[2] - DT[1])\\n\\n if abs(qdiff < 0.1):\\n DT[1] = DT[2]\\n exit = True\\n else:\\n if xgain > 40:\\n DT[1] = (DT[1] + DT[2]) / 2\\n if xgain == xgainmax:\\n exit = True\\n else:\\n DT[1] = DT[2]\\n xgain += 1\\n\\n # FIXME: redundant...\\n # qout = Mfl * Cp_waterglycol * (Tout - Tin) / aperture_area\\n # qmtherm = (Tfl[2] - Tfl[1]) * C_eff / delts\\n # qbal = qgain - qout - qmtherm\\n # if abs(qbal) > 1:\\n # qbal = qbal\\n return qgain_Whperm2\",\n \"def test_thermal_relaxation_error_kraus(self):\\n t1, t2, time, p1 = (1, 2, 1, 0.3)\\n error = thermal_relaxation_error(t1, t2, time, p1)\\n circ, p = error.error_term(0)\\n self.assertEqual(p, 1)\\n self.assertEqual(circ[0]['name'], 'kraus')\\n self.assertEqual(circ[0]['qubits'], [0])\",\n \"def obrien_fleming_test(z, K, current_k, alpha):\\n c = obrien_fleming_cutoff(K, current_k, alpha)\\n return c < abs(z)\",\n \"def calculate_kl(self, old_policy, new_policy, obs):\\n # _, logp0 = old_policy(obs, act)\\n # logp0 = logp0.detach()\\n # _, logp1 = new_policy(obs, act)\\n\\n p0 = old_policy._distribution(obs).probs.detach() + 1e-8\\n p1 = new_policy._distribution(obs).probs\\n # pi_new = Categorical(old_policy.logits_net(obs))\\n # act_new = pi_new.sample()\\n # logp0 = old_policy._log_prob_from_distribution(pi_old, act_old)\\n # logp1 = new_policy._log_prob_from_distribution(pi_new, act_new)\\n\\n return torch.sum(p0 * torch.log(p0 / p1), 1).mean()\\n # kl = torch.exp(logp1) * (logp1-logp0)\\n # return kl.sum(-1, keepdim=True).mean()\",\n \"def __init__(self, kp, ki, kd):\\n self.kp = kp\\n self.ki = ki\\n self.kd = kd\\n self.error_last = 0\\n self.error_sum = 0\\n self.delta_error = 0\",\n \"def K(self):\\n\\n # Calculate and return the stiffness matrix in global coordinates\\n return matmul(matmul(inv(self.T()), self.k()), self.T())\",\n \"def _K_computations(self, X, X2):\\r\\n if self.ARD:\\r\\n pass\\r\\n else:\\r\\n if X2 is None:\\r\\n self._K_inner_prod = np.dot(X,X.T)\\r\\n self._K_numer = self._K_inner_prod*self.weight_variance+self.bias_variance\\r\\n vec = np.diag(self._K_numer) + 1.\\r\\n self._K_denom = np.sqrt(np.outer(vec,vec))\\r\\n self._K_asin_arg = self._K_numer/self._K_denom\\r\\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)\\r\\n else:\\r\\n self._K_inner_prod = np.dot(X,X2.T)\\r\\n self._K_numer = self._K_inner_prod*self.weight_variance + self.bias_variance\\r\\n vec1 = (X*X).sum(1)*self.weight_variance + self.bias_variance + 1.\\r\\n vec2 = (X2*X2).sum(1)*self.weight_variance + self.bias_variance + 1.\\r\\n self._K_denom = np.sqrt(np.outer(vec1,vec2))\\r\\n self._K_asin_arg = self._K_numer/self._K_denom\\r\\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)\",\n \"def testEpsK1Changes(self):\\n with self.test_context() as session:\\n initial_eps = 1e-3\\n num_classes = 5\\n rm = gpflow.likelihoods.RobustMax(num_classes, initial_eps)\\n\\n expected_eps_k1 = initial_eps / (num_classes - 1.)\\n actual_eps_k1 = session.run(rm._eps_K1)\\n self.assertAlmostEqual(expected_eps_k1, actual_eps_k1)\\n\\n new_eps = 0.412\\n rm.epsilon.assign(new_eps, session=session)\\n expected_eps_k2 = new_eps / (num_classes - 1.)\\n actual_eps_k2 = session.run(rm._eps_K1)\\n self.assertAlmostEqual(expected_eps_k2, actual_eps_k2)\",\n \"def fuel_cond(T):\\n\\n kc = 1.841e-19*math.pow(T,6) - 2.097e-15*math.pow(T,5) +\\\\\\n 9.721e-12*math.pow(T,4) - 2.369e-8*math.pow(T,3) +\\\\\\n 3.283e-5*math.pow(T,2) - 0.0267*T + 63.18\\n \\n return kc\",\n \"def _K_computations(self, X, X2):\\r\\n # First extract times and indices.\\r\\n self._extract_t_indices(X, X2)\\r\\n\\r\\n self._K_compute_eq()\\r\\n self._K_compute_ode_eq()\\r\\n if X2 is None:\\r\\n self._K_eq_ode = self._K_ode_eq.T\\r\\n else:\\r\\n self._K_compute_ode_eq(transpose=True)\\r\\n self._K_compute_ode()\\r\\n\\r\\n if X2 is None:\\r\\n self._K_dvar = np.zeros((self._t.shape[0], self._t.shape[0]))\\r\\n else:\\r\\n self._K_dvar = np.zeros((self._t.shape[0], self._t2.shape[0]))\\r\\n\\r\\n # Reorder values of blocks for placing back into _K_dvar.\\r\\n self._K_dvar = np.vstack((np.hstack((self._K_eq, self._K_eq_ode)),\\r\\n np.hstack((self._K_ode_eq, self._K_ode))))\\r\\n self._K_dvar = self._K_dvar[self._rorder, :]\\r\\n self._K_dvar = self._K_dvar[:, self._rorder2]\\r\\n \\r\\n \\r\\n if X2 is None:\\r\\n # Matrix giving scales of each output\\r\\n self._scale = np.zeros((self._t.size, self._t.size))\\r\\n code=\\\"\\\"\\\"\\r\\n for(int i=0;i<N; i++){\\r\\n scale_mat[i+i*N] = B[index[i]+output_dim*(index[i])];\\r\\n for(int j=0; j<i; j++){\\r\\n scale_mat[j+i*N] = B[index[i]+output_dim*index[j]];\\r\\n scale_mat[i+j*N] = scale_mat[j+i*N];\\r\\n }\\r\\n }\\r\\n \\\"\\\"\\\"\\r\\n scale_mat, B, index = self._scale, self.B, self._index\\r\\n N, output_dim = self._t.size, self.output_dim\\r\\n weave.inline(code,['index',\\r\\n 'scale_mat', 'B',\\r\\n 'N', 'output_dim'])\\r\\n else:\\r\\n self._scale = np.zeros((self._t.size, self._t2.size))\\r\\n code = \\\"\\\"\\\"\\r\\n for(int i=0; i<N; i++){\\r\\n for(int j=0; j<N2; j++){\\r\\n scale_mat[i+j*N] = B[index[i]+output_dim*index2[j]];\\r\\n }\\r\\n }\\r\\n \\\"\\\"\\\"\\r\\n scale_mat, B, index, index2 = self._scale, self.B, self._index, self._index2\\r\\n N, N2, output_dim = self._t.size, self._t2.size, self.output_dim\\r\\n weave.inline(code, ['index', 'index2',\\r\\n 'scale_mat', 'B',\\r\\n 'N', 'N2', 'output_dim'])\",\n \"def P(self, energy, newEnergy, temperature):\\n \\\"\\\"\\\" This is the decision-rule, adapted from Nascimento, et al., 2009 (See references) \\\"\\\"\\\"\\n \\n delta = self.calcDelta(newEnergy, energy)\\n\\n minTemp = 0.00001 # use minimum to avoid div/0 and buffer overflow\\n if temperature == 0:\\n return minTemp\\n elif temperature > minTemp:\\n try:\\n return math.exp(-1 * round(delta, 4) / round(temperature, 4))\\n except OverflowError as detail:\\n return minTemp\\n else:\\n return 1\",\n \"def dK_dtheta(self,dL_dK,X,X2,target):\\r\\n if X2 is None: X2 = X\\r\\n FX = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X)\\r\\n FX2 = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X2)\\r\\n\\r\\n La = np.column_stack((self.a[0]*np.ones((self.n_basis,1)), self.a[1]*self.basis_omega, self.a[2]*self.basis_omega**2, self.a[3]*self.basis_omega**3))\\r\\n Lo = np.column_stack((self.basis_omega, self.basis_omega, self.basis_omega, self.basis_omega))\\r\\n Lp = np.column_stack((self.basis_phi, self.basis_phi+np.pi/2, self.basis_phi+np.pi, self.basis_phi+np.pi*3/2))\\r\\n r,omega,phi = self._cos_factorization(La,Lo,Lp)\\r\\n Gint = self._int_computation( r,omega,phi, r,omega,phi)\\r\\n\\r\\n Flower = np.array(self._cos(self.basis_alpha,self.basis_omega,self.basis_phi)(self.lower))[:,None]\\r\\n F1lower = np.array(self._cos(self.basis_alpha*self.basis_omega,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\\r\\n F2lower = np.array(self._cos(self.basis_alpha*self.basis_omega**2,self.basis_omega,self.basis_phi+np.pi)(self.lower))[:,None]\\r\\n\\r\\n #dK_dvar\\r\\n dK_dvar = 1./self.variance*mdot(FX,self.Gi,FX2.T)\\r\\n\\r\\n #dK_dlen\\r\\n da_dlen = [-3*self.a[0]/self.lengthscale, -2*self.a[1]/self.lengthscale, -self.a[2]/self.lengthscale, 0.]\\r\\n db_dlen = [0., 4*self.b[1]/self.lengthscale, 2*self.b[2]/self.lengthscale, 2*self.b[3]/self.lengthscale, 2*self.b[4]/self.lengthscale]\\r\\n dLa_dlen = np.column_stack((da_dlen[0]*np.ones((self.n_basis,1)), da_dlen[1]*self.basis_omega, da_dlen[2]*self.basis_omega**2, da_dlen[3]*self.basis_omega**3))\\r\\n r1,omega1,phi1 = self._cos_factorization(dLa_dlen,Lo,Lp)\\r\\n dGint_dlen = self._int_computation(r1,omega1,phi1, r,omega,phi)\\r\\n dGint_dlen = dGint_dlen + dGint_dlen.T\\r\\n dlower_terms_dlen = db_dlen[0]*np.dot(Flower,Flower.T) + db_dlen[1]*np.dot(F2lower,F2lower.T) + db_dlen[2]*np.dot(F1lower,F1lower.T) + db_dlen[3]*np.dot(F2lower,Flower.T) + db_dlen[4]*np.dot(Flower,F2lower.T)\\r\\n dG_dlen = 15*self.lengthscale**4/(400*np.sqrt(5))*Gint + 3*self.lengthscale**5/(400*np.sqrt(5))*dGint_dlen + dlower_terms_dlen\\r\\n dK_dlen = -mdot(FX,self.Gi,dG_dlen/self.variance,self.Gi,FX2.T)\\r\\n\\r\\n #dK_dper\\r\\n dFX_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X ,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X)\\r\\n dFX2_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X2,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X2)\\r\\n\\r\\n dLa_dper = np.column_stack((-self.a[0]*self.basis_omega/self.period, -self.a[1]*self.basis_omega**2/self.period, -self.a[2]*self.basis_omega**3/self.period, -self.a[3]*self.basis_omega**4/self.period))\\r\\n dLp_dper = np.column_stack((self.basis_phi+np.pi/2,self.basis_phi+np.pi,self.basis_phi+np.pi*3/2,self.basis_phi))\\r\\n r1,omega1,phi1 = self._cos_factorization(dLa_dper,Lo,dLp_dper)\\r\\n\\r\\n IPPprim1 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi/2))\\r\\n IPPprim1 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi/2))\\r\\n IPPprim2 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + self.upper*np.cos(phi-phi1.T))\\r\\n IPPprim2 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + self.lower*np.cos(phi-phi1.T))\\r\\n #IPPprim2[0,0] = 2*(self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\\r\\n IPPprim = np.where(np.isnan(IPPprim1),IPPprim2,IPPprim1)\\r\\n\\r\\n IPPint1 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi)\\r\\n IPPint1 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi)\\r\\n IPPint2 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./2*self.upper**2*np.cos(phi-phi1.T)\\r\\n IPPint2 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./2*self.lower**2*np.cos(phi-phi1.T)\\r\\n #IPPint2[0,0] = (self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\\r\\n IPPint = np.where(np.isnan(IPPint1),IPPint2,IPPint1)\\r\\n\\r\\n dLa_dper2 = np.column_stack((-self.a[1]*self.basis_omega/self.period, -2*self.a[2]*self.basis_omega**2/self.period, -3*self.a[3]*self.basis_omega**3/self.period))\\r\\n dLp_dper2 = np.column_stack((self.basis_phi+np.pi/2, self.basis_phi+np.pi, self.basis_phi+np.pi*3/2))\\r\\n r2,omega2,phi2 = self._cos_factorization(dLa_dper2,Lo[:,0:2],dLp_dper2)\\r\\n\\r\\n dGint_dper = np.dot(r,r1.T)/2 * (IPPprim - IPPint) + self._int_computation(r2,omega2,phi2, r,omega,phi)\\r\\n dGint_dper = dGint_dper + dGint_dper.T\\r\\n\\r\\n dFlower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\\r\\n dF1lower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega**2/self.period,self.basis_omega,self.basis_phi+np.pi)(self.lower)+self._cos(-self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\\r\\n dF2lower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega**3/self.period,self.basis_omega,self.basis_phi+np.pi*3/2)(self.lower) + self._cos(-2*self.basis_alpha*self.basis_omega**2/self.period,self.basis_omega,self.basis_phi+np.pi)(self.lower))[:,None]\\r\\n\\r\\n dlower_terms_dper = self.b[0] * (np.dot(dFlower_dper,Flower.T) + np.dot(Flower.T,dFlower_dper))\\r\\n dlower_terms_dper += self.b[1] * (np.dot(dF2lower_dper,F2lower.T) + np.dot(F2lower,dF2lower_dper.T)) - 4*self.b[1]/self.period*np.dot(F2lower,F2lower.T)\\r\\n dlower_terms_dper += self.b[2] * (np.dot(dF1lower_dper,F1lower.T) + np.dot(F1lower,dF1lower_dper.T)) - 2*self.b[2]/self.period*np.dot(F1lower,F1lower.T)\\r\\n dlower_terms_dper += self.b[3] * (np.dot(dF2lower_dper,Flower.T) + np.dot(F2lower,dFlower_dper.T)) - 2*self.b[3]/self.period*np.dot(F2lower,Flower.T)\\r\\n dlower_terms_dper += self.b[4] * (np.dot(dFlower_dper,F2lower.T) + np.dot(Flower,dF2lower_dper.T)) - 2*self.b[4]/self.period*np.dot(Flower,F2lower.T)\\r\\n\\r\\n dG_dper = 1./self.variance*(3*self.lengthscale**5/(400*np.sqrt(5))*dGint_dper + 0.5*dlower_terms_dper)\\r\\n dK_dper = mdot(dFX_dper,self.Gi,FX2.T) - mdot(FX,self.Gi,dG_dper,self.Gi,FX2.T) + mdot(FX,self.Gi,dFX2_dper.T)\\r\\n\\r\\n # np.add(target[:,:,0],dK_dvar, target[:,:,0])\\r\\n target[0] += np.sum(dK_dvar*dL_dK)\\r\\n #np.add(target[:,:,1],dK_dlen, target[:,:,1])\\r\\n target[1] += np.sum(dK_dlen*dL_dK)\\r\\n #np.add(target[:,:,2],dK_dper, target[:,:,2])\\r\\n target[2] += np.sum(dK_dper*dL_dK)\",\n \"def E2K(E):\\n return sqrt(E/2.0723)\",\n \"def jarrow_rudd(s, k, t, v, rf, cp, am=False, n=100):\\n\\n\\t# Basic Calculations\\n\\th = t / n \\n\\tu = math.exp((rf - 0.5 * math.pow(v, 2)) * h + v * math.sqrt(h))\\n\\td = math.exp((rf - 0.5 * math.pow(v, 2)) * h - v * math.sqrt(h))\\n\\tdrift = math.exp(rf * h)\\n\\tq = (drift - d) / (u - d)\\n\\n\\t#Process the terminal stock price\\n\\tstkval = np.zeros((n+1, n+1))\\n\\toptval = np.zeros((n+1, n+1))\\n\\tstkval[0, 0] = s\\n\\n\\tfor i in range(1, n+1):\\n\\t\\tstkval[i, 0] = stkval[i - 1, 0] * u\\n\\t\\tfor j in range(1, i + 1):\\n\\t\\t\\tstkval[i, j] = stkval[i - 1, j - 1] * d\\n\\n\\t# Backwards recursion for option price\\n\\tfor j in range(n + 1):\\n\\t\\toptval[n, j] = max(0, cp * (stkval[n, j] - k))\\n\\tfor i in range(n - 1, -1, -1):\\n\\t\\tfor j in range(i + 1):\\n\\t\\t\\toptval[i, j] = (q * optval[i + 1, j] + (1 - q) * optval[i + 1, j + 1]) / drift\\n\\t\\t\\tif am:\\n\\t\\t\\t\\toptval[i, j] = max(optval[i, j], cp * (stkval[i, j] - k))\\n\\treturn optval[0, 0]\",\n \"def _find_k_offsets(self, k, d):\\n olderr = sp.seterr(invalid= 'ignore') # turn off 'invalid multiplication' error;\\n # it's just the 'inf' boundaries\\n delta = k * d\\n sp.seterr(**olderr) # turn the error back on\\n return delta\",\n \"def ekf_algorithm(self, u, y):\\n x_est_before = self.x_estimated_state\\n cov_matrix_before = self.cov_matrix\\n # 1. Prediction\\n # predict the state by integrate the time continuous system numerically\\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\\n x_est_predict = np.resize(sim_state_predict, (6, 1))\\n # predict the new covariance by linearizing and discretizing the model\\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\\n # 2. Update\\n # compute kalman gain\\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\\n # update state\\n y_est = x_est_predict[0:3, ]\\n x_est_update = x_est_predict + Kl @ (y - y_est)\\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\\n\\n # check if the update step state needs to be changed because of limit crossing\\n # if that is the case, correct the state and set the state of the simulation accordingly\\n # heliSim_state = np.resize(x_est_update, (1, 6))[0]\\n # heliSim_state = np.pad(heliSim_state, (0, 2), \\\"constant\\\")\\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 6))[0],\\n ModelType.EASY)\\n x_est_update = np.resize(corrected_state, (6, 1))\\n\\n self.x_estimated_state = x_est_update\\n self.cov_matrix = cov_matrix_update\\n return x_est_update\",\n \"def err_k(self, X, Y):\\n\\t\\tY_hat = self.predict(X)\\n\\t\\treturn np.mean(Y_hat != from_1_of_k(Y))\",\n \"def verhulst(nb_init, t0, tf, eps, methode, gamma, K) :\\n f=lambda y,t : gamma*y*(1-y/K)\\n Y=meth_epsilon(nb_init, t0, tf, eps, f, methode)\\n return Y\",\n \"def _K_computations(self, X, X2=None):\\r\\n self._lengthscales=self.mapping.f(X)\\r\\n self._lengthscales2=np.square(self._lengthscales)\\r\\n if X2==None:\\r\\n self._lengthscales_two = self._lengthscales\\r\\n self._lengthscales_two2 = self._lengthscales2\\r\\n Xsquare = np.square(X).sum(1)\\r\\n self._K_dist2 = -2.*tdot(X) + Xsquare[:, None] + Xsquare[None, :]\\r\\n else:\\r\\n self._lengthscales_two = self.mapping.f(X2)\\r\\n self._lengthscales_two2 = np.square(self._lengthscales_two)\\r\\n self._K_dist2 = -2.*np.dot(X, X2.T) + np.square(X).sum(1)[:, None] + np.square(X2).sum(1)[None, :]\\r\\n self._w2 = self._lengthscales2 + self._lengthscales_two2.T\\r\\n prod_length = self._lengthscales*self._lengthscales_two.T\\r\\n self._K_exponential = np.exp(-self._K_dist2/self._w2)\\r\\n self._K_dvar = np.sign(prod_length)*(2*np.abs(prod_length)/self._w2)**(self.input_dim/2.)*np.exp(-self._K_dist2/self._w2)\",\n \"def find_best_k(X_train, y_train, X_test, y_test, min_k=1, max_k=25):\\n best_k = 0\\n best_score = 0.0\\n for k in range(min_k, max_k+1, 2):\\n knn = KNeighborsClassifier(n_neighbors=k)\\n knn.fit(X_train, y_train)\\n preds = knn.predict(X_test)\\n f1 = f1_score(y_test, preds)\\n if f1 > best_score:\\n best_k = k\\n best_score = f1\\n print(\\\"Best Value for k: {}\\\".format(best_k))\\n print(\\\"F1-Score: {}\\\".format(best_score))\",\n \"def calc_K_tilda(kernel: Type[Kern], X_train: np.array, X_m: np.array):\\n Knn = kernel.K(X_train, X_train)\\n Knm = kernel.K(X_train, X_m)\\n Kmn = kernel.K(X_m, X_train)\\n Kmm = kernel.K(X_m, X_m)\\n temp = np.dot(np.dot(Knm, np.linalg.inv(Kmm)), Kmn)\\n K_tilda = np.subtract(Knn, temp)\\n return K_tilda\",\n \"def updated_rating(old: int, expected: int, actual: int) -> int:\\n return round(old + ELO_K_FACTOR * (actual - expected))\",\n \"def diff_k_p2(p1, p2, t=0.):\\n return p2\",\n \"def k_Ni00(wind_ms, temp_C):\\n\\n U = wind_ms\\n\\n Sc = schmidt_number(temp_C)\\n k = (0.333 * U + 0.222 * U ** 2) * (600 / Sc) ** 0.5\\n\\n return k\",\n \"def test_estimate_jackknife():\\n X = 100\\n T = 300.00\\n delta_beta = 1.0\\n jk_f = np.ones(X)\\n jk_sym1 = np.ones(X)\\n jk_sym2 = np.ones(X) + 1\\n\\n kBT = boltzman * pow(T, 2.)\\n input_dict = {\\\"E\\\": -1.0, \\\"Cv\\\": 1.0 / kBT}\\n\\n ret = jk.estimate_jackknife(X, T, delta_beta, input_dict, jk_f, jk_sym1, jk_sym2)\\n\\n assert ret[\\\"E\\\"] == -1.0\\n assert ret[\\\"E error\\\"] == 0.0\\n assert math.isclose(ret[\\\"Cv\\\"], 1.0 / kBT)\\n assert math.isclose(ret[\\\"Cv error\\\"], 2.7755575615628914e-16)\\n return\",\n \"def ekf_algorithm(self, u, y):\\n x_est_before = self.x_estimated_state\\n cov_matrix_before = self.cov_matrix\\n # 1. Prediction\\n # predict the state by integrate the time continuous system numerically\\n sim_state_predict = self.heliSim.calc_step(u[0][0], u[1][0], self.no_disturbance_eval)\\n x_est_predict = np.resize(sim_state_predict, (8, 1))\\n # predict the new covariance by linearizing and discretizing the model\\n Ak, Bk, Ck, Dk = self.get_linear_discrete_matrices(x_est_before, u[0][0], u[1][0])\\n cov_matrix_predict = Ak @ cov_matrix_before @ np.transpose(Ak) + Bk @ self.N @ np.transpose(Bk)\\n # 2. Update\\n # compute kalman gain\\n Kl = cov_matrix_predict @ np.transpose(Ck) @ np.linalg.inv(Ck @ cov_matrix_predict @ np.transpose(Ck) + self.W)\\n # update state\\n y_est = np.concatenate((x_est_predict[0:3], x_est_predict[6:8]))\\n x_est_update = x_est_predict + Kl @ (y - y_est)\\n # update covariance matrix (identity matrix must have as many lines as the Kalman gain\\n cov_matrix_update = (np.eye(np.size(Kl, 0)) - Kl @ Ck) @ cov_matrix_predict\\n\\n corrected_state = self.heliSim.get_limited_state_and_change_state(x_est_update.reshape((1, 8))[0],\\n ModelType.GYROMOMENT)\\n # corrected_state = x_est_update\\n x_est_update = np.resize(corrected_state, (8, 1))\\n\\n self.x_estimated_state = x_est_update\\n self.cov_matrix = cov_matrix_update\\n # print(\\\"------\\\")\\n # print(cov_matrix_predict)\\n return x_est_update\",\n \"def optimization_rel_disp_K(self, step_size, dof1, dof2, controlDOF):\\n \\\"\\\"\\\"First, the initial variance of the system is computed for the matrices given by the user\\\"\\\"\\\"\\n Variance = []\\n \\\"\\\"\\\"The sign variable keeps track of the direction the algorithm is stepping\\\"\\\"\\\"\\n sign = [0]\\n Variance.append(self.VarianceOfResponse())\\n\\n \\\"\\\"\\\"The matrix K is incremented by one step with size = step_size. for the spring that connects dof1 and dof2\\\"\\\"\\\"\\n sign.append(1)\\n self.incrementK(step_size, dof1, dof2)\\n Variance.append(self.VarianceOfResponse())\\n\\n \\\"\\\"\\\"Loop that iteratively steps down the optimal direction of increasing or reducing K\\\"\\\"\\\"\\n i = 0\\n while len(sign) < 4 or np.sum(sign[-4:]) != 0 or i < 100:\\n i += 1\\n print(abs(Variance[-2][int(controlDOF[0] - 1)] - Variance[-2][int(controlDOF[1] - 1)]))\\n \\\"\\\"\\\"First condition demands a minimum of 4 steps. Second condition sums up the direction of the last 4 steps\\n if the sum equals 0, the minimum value for the variance has been found.\\\"\\\"\\\"\\n if abs(Variance[-2][int(controlDOF[0] - 1)] - Variance[-2][int(controlDOF[1] - 1)]) \\\\\\n > abs(Variance[-1][int(controlDOF[0] - 1)] - Variance[-1][int(controlDOF[1] - 1)]):\\n \\\"\\\"\\\"If the last variance is smaller than the variance before, keep going in that direction.\\\"\\\"\\\"\\n self.incrementK(step_size * sign[-1], dof1, dof2)\\n Variance.append(self.VarianceOfResponse())\\n sign.append(sign[-1])\\n elif abs(Variance[-2][int(controlDOF[0] - 1)] - Variance[-2][int(controlDOF[1] - 1)]) \\\\\\n < abs(Variance[-1][int(controlDOF[0] - 1)] - Variance[-1][int(controlDOF[1] - 1)]):\\n \\\"\\\"\\\"If the last variance is bigger than the one before, turn around and go the other way.\\\"\\\"\\\"\\n self.incrementK(step_size * sign[-1] * -1, dof1, dof2)\\n Variance.append(self.VarianceOfResponse())\\n sign.append(sign[-1] * -1)\\n return Variance\",\n \"def sensitivity(gas, surf, old_data, temp, dk, thermo=False):\\n rxns = []\\n sens1 = []\\n sens2 = []\\n sens3 = []\\n sens4 = []\\n sens5 = []\\n sens6 = []\\n sens7 = []\\n sens8 = []\\n sens9 = []\\n sens10 = []\\n sens11 = []\\n sens12 = []\\n\\n gas_out_data, gas_names_data, dist_array_data, T_array_data = old_data\\n\\n reference = []\\n for a in range(len(gas_names_data)):\\n reference.append([gas_names_data[a], [gas_out_data[:, a]]])\\n\\n # getting the ratio\\n for x in reference:\\n if x[0] == 'CH4(2)':\\n ch4_in = x[1][0][0]\\n if x[0] == 'O2(3)':\\n o2_in = x[1][0][0]\\n if x[0] == 'Ar':\\n ar_in = x[1][0][0]\\n ratio = ch4_in / (2 * o2_in)\\n moles_in = [ch4_in, o2_in, ar_in]\\n\\n for x in reference:\\n if x[0] == 'CH4(2)':\\n ch4_in = x[1][0][0]\\n ch4_out = x[1][0][-1]\\n if ch4_out < 0:\\n ch4_out = 0.\\n ch4_depletion = ch4_in - ch4_out\\n if ch4_depletion <= 1.0e-8:\\n ch4_depletion = 1.0e-8\\n reference_ch4_conv = 1.0e-8\\n else:\\n reference_ch4_conv = ch4_depletion / ch4_in # Sensitivity definition 7: CH4 conversion\\n if x[0] == 'Ar':\\n ar = x[1][0][-1]\\n if x[0] == 'O2(3)':\\n o2_out = x[1][0][-1]\\n if o2_out < 0:\\n o2_out = 1.0e-15 # O2 can't be negative\\n elif o2_out > o2_in:\\n o2_out = o2_in # O2 can't be created, to make it equal to O2 in\\n if x[0] == 'CO(7)':\\n co_out = x[1][0][-1]\\n if x[0] == 'H2(6)':\\n h2_out = x[1][0][-1]\\n if x[0] == 'H2O(5)':\\n h2o_out = x[1][0][-1]\\n if x[0] == 'CO2(4)':\\n co2_out = x[1][0][-1]\\n\\n if reference_ch4_conv <= 1.0e-8:\\n reference_h2_sel = 1.0e-8\\n reference_co_sel = 1.0e-8\\n reference_syngas_selectivity = 1.0e-8\\n reference_syngas_yield = 1.0e-8\\n reference_co_yield = 1.0e-8\\n reference_h2_yield = 1.0e-8\\n reference_full_oxidation_selectivity = 1.0e-8\\n reference_full_oxidation_yield = 1.0e-8\\n else:\\n # negative sensitivity is higher selectivity\\n reference_h2_sel = h2_out / (ch4_depletion * 2) # Sensitivity definition 5: H2 selectivity\\n if reference_h2_sel <= 0:\\n reference_h2_sel = 1.0e-15 # selectivity can't be 0\\n\\n reference_co_sel = co_out / ch4_depletion # Sensitivity definition 3: CO selectivity\\n if reference_co_sel <= 0:\\n reference_co_sel = 1.0e-15 # selectivity can't be 0\\n\\n reference_syngas_selectivity = reference_co_sel + reference_h2_sel # Sensitivity definition 1: SYNGAS selectivity\\n\\n reference_syngas_yield = reference_syngas_selectivity * reference_ch4_conv # Sensitivity definition 2: SYNGAS yield\\n if reference_syngas_yield <= 0:\\n reference_syngas_yield = 1.0e-15 # yield can't be 0\\n\\n reference_co_yield = co_out / ch4_in # Sensitivity definition 4: CO % yield\\n # reference_co_yield = reference_co_sel * reference_ch4_conv\\n\\n reference_h2_yield = h2_out / (2 * ch4_in) # Sensitivity definition 6: H2 % yield\\n # reference_h2_yield = reference_h2_sel * reference_ch4_conv\\n\\n # Sensitivity definition 8: H2O + CO2 selectivity\\n reference_h2o_sel = h2o_out / (ch4_depletion * 2)\\n reference_co2_sel = co2_out / ch4_depletion\\n if reference_h2o_sel <= 0:\\n reference_h2o_sel = 1.0e-15 # H2O selectivity can't be 0\\n if reference_co2_sel <= 0:\\n reference_co2_sel = 1.0e-15 # CO2 selectivity can't be 0\\n reference_full_oxidation_selectivity = reference_h2o_sel + reference_co2_sel\\n\\n # Sensitivity definition 9: H2O + CO2 yield\\n reference_full_oxidation_yield = reference_full_oxidation_selectivity * reference_ch4_conv\\n\\n # Sensitivity definition 10: exit temperature\\n reference_exit_temp = T_array_data[-1]\\n\\n # Sensitivity definition 11: peak temperature\\n reference_peak_temp = max(T_array_data)\\n\\n # Sensitivity definition 12: distance to peak temperautre\\n reference_peak_temp_dist = dist_array_data[T_array_data.index(max(T_array_data))]\\n\\n # run the simulations\\n if thermo is True:\\n for m in range(surf.n_species):\\n s = surf.species(m)\\n original_coeffs = s.thermo.coeffs\\n perturbed_coeffs = np.ones_like(original_coeffs)\\n perturbed_coeffs[0] = original_coeffs[0]\\n perturbed_coeffs[1:6] = original_coeffs[1:6]\\n perturbed_coeffs[7:13] = original_coeffs[7:13]\\n perturbed_coeffs[14] = original_coeffs[14]\\n # perturbed_coeffs[6] = original_coeffs[6] + original_coeffs[6]*dk\\n # perturbed_coeffs[13] = original_coeffs[13] + original_coeffs[13]*dk\\n perturbed_coeffs[6] = original_coeffs[6] + dk\\n perturbed_coeffs[13] = original_coeffs[13] + dk\\n s.thermo = ct.NasaPoly2(100.000, 5000.000, ct.one_atm, perturbed_coeffs)\\n surf.modify_species(m, s)\\n c = monolithFull(gas, surf, temp, moles_in)\\n\\n gas_out, surf_out, gas_names, surf_names, dist_array, T_array = c\\n\\n new_amts = []\\n for a in range(len(gas_names)):\\n new_amts.append([gas_names[a], [gas_out[:, a]]])\\n\\n for x in new_amts:\\n if x[0] == 'CH4(2)':\\n new_ch4_in = x[1][0][0]\\n new_ch4_out = x[1][0][-1]\\n if new_ch4_out < 0:\\n new_ch4_out = 0.\\n new_ch4_depletion = new_ch4_in - new_ch4_out\\n if new_ch4_depletion <= 1e-8:\\n new_ch4_depletion = 1e-8\\n new_ch4_conv = 1e-8\\n else:\\n new_ch4_conv = new_ch4_depletion / new_ch4_in # Sensitivity definition 7: CH4 conversion\\n if x[0] == 'Ar':\\n ar = x[1][0][-1]\\n if x[0] == 'O2(3)':\\n new_o2_in = x[1][0][0]\\n new_o2_out = x[1][0][-1]\\n if new_o2_out < 0:\\n new_o2_out = 1.0e-15\\n elif new_o2_out > new_o2_in:\\n new_o2_out = new_o2_in\\n if x[0] == 'CO(7)':\\n new_co_out = x[1][0][-1]\\n if x[0] == 'H2(6)':\\n new_h2_out = x[1][0][-1]\\n if x[0] == 'H2O(5)':\\n new_h2o_out = x[1][0][-1]\\n if x[0] == 'CO2(4)':\\n new_co2_out = x[1][0][-1]\\n\\n if new_ch4_conv <= 1e-8:\\n new_h2_sel = 1.0e-8\\n new_co_sel = 1.0e-8\\n new_syngas_selectivity = 1.0e-8\\n new_syngas_yield = 1.0e-8\\n new_co_yield = 1.0e-8\\n new_h2_yield = 1.0e-8\\n new_full_oxidation_selectivity = 1.0e-8\\n new_full_oxidation_yield = 1.0e-8\\n else:\\n new_h2_sel = new_h2_out / (new_ch4_depletion * 2) # Sensitivity definition 5: H2 selectivity\\n new_co_sel = new_co_out / new_ch4_depletion # Sensitivity definition 3: CO selectivity\\n new_syngas_selectivity = new_co_sel + new_h2_sel # Sensitivity definition 1: SYNGAS selectivity\\n new_syngas_yield = new_syngas_selectivity * new_ch4_conv # Sensitivity definition 2: SYNGAS yield\\n new_co_yield = new_co_out / new_ch4_in # Sensitivity definition 4: CO % yield\\n new_h2_yield = new_h2_out / (2 * new_ch4_in) # Sensitivity definition 6: H2 % yield\\n new_h2o_sel = new_h2o_out / (new_ch4_depletion * 2) # Sensitivity definition 8: H2O + CO2 selectivity\\n new_co2_sel = new_co2_out / new_ch4_depletion\\n new_full_oxidation_selectivity = new_h2o_sel + new_co2_sel\\n new_full_oxidation_yield = new_full_oxidation_selectivity * new_ch4_conv # Sensitivity definition 9: C2O + CO2 yield\\n\\n Sens5 = (new_h2_sel - reference_h2_sel) / (reference_h2_sel * dk)\\n sens5.append(Sens5)\\n\\n Sens3 = (new_co_sel - reference_co_sel) / (reference_co_sel * dk)\\n sens3.append(Sens3)\\n\\n Sens1 = (new_syngas_selectivity - reference_syngas_selectivity) / (reference_syngas_selectivity * dk)\\n sens1.append(Sens1)\\n\\n Sens2 = (new_syngas_yield - reference_syngas_yield) / (reference_syngas_yield * dk)\\n sens2.append(Sens2)\\n\\n Sens4 = (new_co_yield - reference_co_yield) / (reference_co_yield * dk)\\n sens4.append(Sens4)\\n\\n Sens6 = (new_h2_yield - reference_h2_yield) / (reference_h2_yield * dk)\\n sens6.append(Sens6)\\n\\n Sens7 = (new_ch4_conv - reference_ch4_conv) / (\\n reference_ch4_conv * dk)\\n sens7.append(Sens7)\\n\\n Sens8 = (new_full_oxidation_selectivity - reference_full_oxidation_selectivity) / (\\n reference_full_oxidation_selectivity * dk)\\n sens8.append(Sens8)\\n\\n Sens9 = (new_full_oxidation_yield - reference_full_oxidation_yield) / (reference_full_oxidation_yield * dk)\\n sens9.append(Sens9)\\n\\n new_exit_temp = T_array[-1] # Sensitivity definition 10: exit temperature\\n Sens10 = (new_exit_temp - reference_exit_temp) / (reference_exit_temp * dk)\\n sens10.append(Sens10)\\n\\n new_peak_temp = max(T_array) # Sensitivity definition 11: peak temperature\\n Sens11 = (new_peak_temp - reference_peak_temp) / (reference_peak_temp * dk)\\n sens11.append(Sens11)\\n\\n new_peak_temp_dist = dist_array[\\n T_array.index(max(T_array))] # Sensitivity definition 12: dist to peak temperature\\n Sens12 = (new_peak_temp_dist - reference_peak_temp_dist) / (reference_peak_temp_dist * dk)\\n sens12.append(Sens12)\\n\\n print \\\"%d %s %.3F %.3F\\\" % (m, surf.species_name(m), Sens1, Sens2)\\n rxns.append(surf.species_name(m))\\n\\n # this step is essential, otherwise mechanism will have been altered\\n s.thermo = ct.NasaPoly2(100.000, 5000.000, ct.one_atm, original_coeffs)\\n surf.modify_species(m, s)\\n else:\\n for rxn in range(surf.n_reactions):\\n c = monolithFull(gas, surf, temp, moles_in, sens=[dk, rxn])\\n gas_out, surf_out, gas_names, surf_names, dist_array, T_array = c\\n\\n new_amts = []\\n for a in range(len(gas_names)):\\n new_amts.append([gas_names[a], [gas_out[:, a]]])\\n\\n for x in new_amts:\\n if x[0] == 'CH4(2)':\\n new_ch4_in = x[1][0][0]\\n new_ch4_out = x[1][0][-1]\\n if new_ch4_out < 0:\\n new_ch4_out = 0.\\n new_ch4_depletion = new_ch4_in - new_ch4_out\\n if new_ch4_depletion <= 1e-8:\\n new_ch4_depletion = 1e-8\\n new_ch4_conv = 1e-8\\n else:\\n new_ch4_conv = new_ch4_depletion / new_ch4_in # Sensitivity definition 7: CH4 conversion\\n if x[0] == 'Ar':\\n ar = x[1][0][-1]\\n if x[0] == 'O2(3)':\\n new_o2_in = x[1][0][0]\\n new_o2_out = x[1][0][-1]\\n if new_o2_out < 0:\\n new_o2_out = 1.0e-15\\n elif new_o2_out > new_o2_in:\\n new_o2_out = new_o2_in\\n if x[0] == 'CO(7)':\\n new_co_out = x[1][0][-1]\\n if x[0] == 'H2(6)':\\n new_h2_out = x[1][0][-1]\\n if x[0] == 'H2O(5)':\\n new_h2o_out = x[1][0][-1]\\n if x[0] == 'CO2(4)':\\n new_co2_out = x[1][0][-1]\\n\\n if new_ch4_conv <= 1e-8:\\n new_h2_sel = 1.0e-8\\n new_co_sel = 1.0e-8\\n new_syngas_selectivity = 1.0e-8\\n new_syngas_yield = 1.0e-8\\n new_co_yield = 1.0e-8\\n new_h2_yield = 1.0e-8\\n new_full_oxidation_selectivity = 1.0e-8\\n new_full_oxidation_yield = 1.0e-8\\n else:\\n new_h2_sel = new_h2_out / (new_ch4_depletion * 2) # Sensitivity definition 5: H2 selectivity\\n new_co_sel = new_co_out / new_ch4_depletion # Sensitivity definition 3: CO selectivity\\n new_syngas_selectivity = new_co_sel + new_h2_sel # Sensitivity definition 1: SYNGAS selectivity\\n new_syngas_yield = new_syngas_selectivity * new_ch4_conv # Sensitivity definition 2: SYNGAS yield\\n new_co_yield = new_co_out / new_ch4_in # Sensitivity definition 4: CO % yield\\n new_h2_yield = new_h2_out / (2 * new_ch4_in) # Sensitivity definition 6: H2 % yield\\n new_h2o_sel = new_h2o_out / (new_ch4_depletion * 2) # Sensitivity definition 8: H2O + CO2 selectivity\\n new_co2_sel = new_co2_out / new_ch4_depletion\\n new_full_oxidation_selectivity = new_h2o_sel + new_co2_sel\\n new_full_oxidation_yield = new_full_oxidation_selectivity * new_ch4_conv # Sensitivity definition 9: C2O + CO2 yield\\n\\n Sens5 = (new_h2_sel - reference_h2_sel) / (reference_h2_sel * dk)\\n sens5.append(Sens5)\\n\\n Sens3 = (new_co_sel - reference_co_sel) / (reference_co_sel * dk)\\n sens3.append(Sens3)\\n\\n Sens1 = (new_syngas_selectivity - reference_syngas_selectivity) / (reference_syngas_selectivity * dk)\\n sens1.append(Sens1)\\n\\n Sens2 = (new_syngas_yield - reference_syngas_yield) / (reference_syngas_yield * dk)\\n sens2.append(Sens2)\\n\\n Sens4 = (new_co_yield - reference_co_yield) / (reference_co_yield * dk)\\n sens4.append(Sens4)\\n\\n Sens6 = (new_h2_yield - reference_h2_yield) / (reference_h2_yield * dk)\\n sens6.append(Sens6)\\n\\n Sens7 = (new_ch4_conv - reference_ch4_conv) / (\\n reference_ch4_conv * dk)\\n sens7.append(Sens7)\\n\\n Sens8 = (new_full_oxidation_selectivity - reference_full_oxidation_selectivity) / (\\n reference_full_oxidation_selectivity * dk)\\n sens8.append(Sens8)\\n\\n Sens9 = (new_full_oxidation_yield - reference_full_oxidation_yield) / (reference_full_oxidation_yield * dk)\\n sens9.append(Sens9)\\n\\n new_exit_temp = T_array[-1] # Sensitivity definition 10: exit temperature\\n Sens10 = (new_exit_temp - reference_exit_temp) / (reference_exit_temp * dk)\\n sens10.append(Sens10)\\n\\n new_peak_temp = max(T_array) # Sensitivity definition 11: peak temperature\\n Sens11 = (new_peak_temp - reference_peak_temp) / (reference_peak_temp * dk)\\n sens11.append(Sens11)\\n\\n new_peak_temp_dist = dist_array[T_array.index(max(T_array))] # Sensitivity definition 12: dist to peak temperature\\n Sens12 = (new_peak_temp_dist - reference_peak_temp_dist) / (reference_peak_temp_dist * dk)\\n sens12.append(Sens12)\\n\\n print \\\"%d %s %.3F %.3F\\\" % (rxn, surf.reaction_equations()[rxn], Sens1, Sens2)\\n rxns.append(surf.reaction_equations()[rxn])\\n\\n return rxns, sens1, sens2, sens3, sens4, sens5, sens6, sens7, sens8, sens9, sens10, sens11, sens12\",\n \"def test_calc_kappa(test_coords):\\n assert_almost_equal(calc_kappa(53.05187), 5762.687, decimal=3)\",\n \"def KS(self, using, dx=0.0001):\\n pits = np.array(self.PIT(using=using,dx=dx))\\n ks_result = skgof.ks_test(pits, stats.uniform())\\n return ks_result.statistic, ks_result.pvalue\",\n \"def _Kgradients(self):\\r\\n dL_dfhat, I_KW_i = self._shared_gradients_components()\\r\\n dlp = self.noise_model.dlogpdf_df(self.f_hat, self.data, extra_data=self.extra_data)\\r\\n\\r\\n #Explicit\\r\\n #expl_a = np.dot(self.Ki_f, self.Ki_f.T)\\r\\n #expl_b = self.Wi_K_i\\r\\n #expl = 0.5*expl_a - 0.5*expl_b\\r\\n #dL_dthetaK_exp = dK_dthetaK(expl, X)\\r\\n\\r\\n #Implicit\\r\\n impl = mdot(dlp, dL_dfhat, I_KW_i)\\r\\n\\r\\n #No longer required as we are computing these in the gp already\\r\\n #otherwise we would take them away and add them back\\r\\n #dL_dthetaK_imp = dK_dthetaK(impl, X)\\r\\n #dL_dthetaK = dL_dthetaK_exp + dL_dthetaK_imp\\r\\n #dL_dK = expl + impl\\r\\n\\r\\n #No need to compute explicit as we are computing dZ_dK to account\\r\\n #for the difference between the K gradients of a normal GP,\\r\\n #and the K gradients including the implicit part\\r\\n dL_dK = impl\\r\\n return dL_dK\",\n \"def KroDelta(a,b):\\n \\n if (a==b):\\n return 1\\n else:\\n return 0\",\n \"def kilometres_available(self):\\n return self.fuel / self.litres_per_kilometre\",\n \"def rk4(self, t, h,G) :\\r\\n k1 = h*self.calc_diff_eqn(t, self.quant_vec,G,self.mass_vec)\\r\\n k2 = h*self.calc_diff_eqn(t + 0.5*h , self.quant_vec + 0.5*k1 ,G, self.mass_vec)\\r\\n k3 = h*self.calc_diff_eqn(t + 0.5*h , self.quant_vec + 0.5*k2 ,G, self.mass_vec)\\r\\n k4 = h*self.calc_diff_eqn(t + h , self.quant_vec + k3 ,G, self.mass_vec)\\r\\n y_new = self.quant_vec + ((k1 + 2*k2 + 2*k3 + k4)/6)\\r\\n return y_new\",\n \"def old():\\n therm = [[300.], [300.], [300.], [300.], [300.], [300.], [300.], [300.], [300.], [300.]]\\n ts = np.linspace(0, 50, 1000)\\n\\n #odvod temperature bo vsota gradientov (diferencialov) z desne in z leve glede x\\n #dT/dt[i] = K/x^2 * (temperature[i-1]- 2*temperature[i] + temperature[i+1])\\n #razen ce je robna tocka\\n #potem je treba nekaj scarat - robna bo funkcija\\n def odvod(indeks, arr, K, time):\\n odvodt = K * (arr[indeks-1][time] - 2*arr[indeks][time] + arr[indeks+1][time])\\n return odvodt\\n\\n def robna(time):\\n return 5*m.cos(0.05*time)\\n\\n\\n K = 0.02\\n x = 0.003\\n\\n def main_old():\\n t = 0\\n dt = 50. / 1000.\\n for time in ts:\\n for i in range(0,9):\\n therm[i].append(therm[i][t] + (robna(time) if i==0 else odvod(i, therm, K, t)*dt/(x**2)))\\n therm[9].append(300.)\\n t+=1\\n\\n import matplotlib.pyplot as plt\\n\\n plt.plot(ts[:], therm[4][:-1], label = 'T(t)')\\n plt.show()\\n \\n main_old()\",\n \"def kramers_kronig_hs(deltaE, I_EELS,\\n N_ZLP=None,\\n iterations=1,\\n n=None,\\n t=None,\\n delta=0.5,\\n full_output=True, prints = np.array([]), correct_S_s = False):\\n output = {}\\n # Constants and units\\n me = 511.06\\n\\n e0 = 200 # keV\\n beta =30 #mrad\\n\\n eaxis = deltaE[deltaE>0] #axis.axis.copy()\\n ddeltaE = (np.max(deltaE) - np.min(deltaE))/(len(deltaE - 1))\\n S_E = I_EELS[deltaE>0]\\n y = I_EELS[deltaE>0]\\n l = len(eaxis)\\n i0 = N_ZLP\\n \\n # Kinetic definitions\\n ke = e0 * (1 + e0 / 2. / me) / (1 + e0 / me) ** 2\\n tgt = e0 * (2 * me + e0) / (me + e0)\\n rk0 = 2590 * (1 + e0 / me) * np.sqrt(2 * ke / me)\\n\\n for io in range(iterations):\\n # Calculation of the ELF by normalization of the SSD\\n # We start by the \\\"angular corrections\\\"\\n Im = y / (np.log(1 + (beta * tgt / eaxis) ** 2)) / ddeltaE#axis.scale\\n if n is None and t is None:\\n raise ValueError(\\\"The thickness and the refractive index are \\\"\\n \\\"not defined. Please provide one of them.\\\")\\n elif n is not None and t is not None:\\n raise ValueError(\\\"Please provide the refractive index OR the \\\"\\n \\\"thickness information, not both\\\")\\n elif n is not None:\\n # normalize using the refractive index.\\n K = np.sum(Im/eaxis)*ddeltaE \\n K = (K / (np.pi / 2) / (1 - 1. / n ** 2))\\n te = (332.5 * K * ke / i0)\\n if full_output is True:\\n output['thickness'] = te\\n elif t is not None:\\n if N_ZLP is None:\\n raise ValueError(\\\"The ZLP must be provided when the \\\"\\n \\\"thickness is used for normalization.\\\")\\n # normalize using the thickness\\n K = t * i0 / (332.5 * ke)\\n te = t\\n Im = Im / K\\n\\n # Kramers Kronig Transform:\\n # We calculate KKT(Im(-1/epsilon))=1+Re(1/epsilon) with FFT\\n # Follows: D W Johnson 1975 J. Phys. A: Math. Gen. 8 490\\n # Use an optimal FFT size to speed up the calculation, and\\n # make it double the closest upper value to workaround the\\n # wrap-around problem.\\n esize = next_fast_len(2*l) #2**math.floor(math.log2(l)+1)*4\\n q = -2 * np.fft.fft(Im, esize).imag / esize\\n\\n q[:l] *= -1\\n q = np.fft.fft(q)\\n # Final touch, we have Re(1/eps)\\n Re = q[:l].real + 1\\n # Egerton does this to correct the wrap-around problem, but in our\\n # case this is not necessary because we compute the fft on an\\n # extended and padded spectrum to avoid this problem.\\n # Re=real(q)\\n # Tail correction\\n # vm=Re[axis.size-1]\\n # Re[:(axis.size-1)]=Re[:(axis.size-1)]+1-(0.5*vm*((axis.size-1) /\\n # (axis.size*2-arange(0,axis.size-1)))**2)\\n # Re[axis.size:]=1+(0.5*vm*((axis.size-1) /\\n # (axis.size+arange(0,axis.size)))**2)\\n\\n # Epsilon appears:\\n # We calculate the real and imaginary parts of the CDF\\n e1 = Re / (Re ** 2 + Im ** 2)\\n e2 = Im / (Re ** 2 + Im ** 2)\\n\\n if iterations > 0 and N_ZLP is not None:\\n # Surface losses correction:\\n # Calculates the surface ELF from a vaccumm border effect\\n # A simulated surface plasmon is subtracted from the ELF\\n Srfelf = 4 * e2 / ((e1 + 1) ** 2 + e2 ** 2) - Im\\n adep = (tgt / (eaxis + delta) *\\n np.arctan(beta * tgt / eaxis) -\\n beta / 1000. /\\n (beta ** 2 + eaxis ** 2. / tgt ** 2))\\n Srfint = 2000 * K * adep * Srfelf / rk0 / te * ddeltaE #axis.scale\\n if correct_S_s == True:\\n print(\\\"correcting S_s\\\")\\n Srfint[Srfint<0] = 0\\n Srfint[Srfint>S_E] = S_E[Srfint>S_E]\\n y = S_E - Srfint\\n _logger.debug('Iteration number: %d / %d', io + 1, iterations)\\n if iterations == io + 1 and full_output is True:\\n output['S_s'] = Srfint\\n del Srfint\\n\\n eps = (e1 + e2 * 1j)\\n del y\\n del I_EELS\\n if 'thickness' in output:\\n # As above,prevent errors if the signal is a single spectrum\\n output['thickness'] = te\\n if full_output is False:\\n return eps\\n else:\\n return eps, output\",\n \"def solve_gamma(t, old, total):\\n\\n old, total = np.mean(old), np.mean(total)\\n gamma = -1 / t * np.log(old / total)\\n\\n return gamma\",\n \"def rk_adaptive(accel,m,r,h,v,recur,emin=10**-12,emax=10**-8,hmax=.1,hmin=.01,recurmax=100):\\n k1v = accel(m,r)\\n k1r = v\\n k2v = accel(m,r + 0.25*k1r*h)\\n k2r = v + (0.25*k1v)*h\\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\\n\\n # 4th order calculation\\n new_v4 = v + h*(25/216.*k1v + 1408/2565.*k3v + 2197/4104.*k4v - 1/5.*k5v)\\n new_r4 = r + h*(25/216.*k1r + 1408/2565.*k3r + 2197/4104.*k4r - 1/5.*k5r)\\n \\n # 5th order calculation\\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \\n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \\n\\n # Calculate truncation error between 5th and 4th order\\n eps = np.abs( (np.max(np.abs(new_r5)) - np.max(np.abs(new_r4))) / np.max(np.abs(new_r4)))\\n \\n # Compare eps to emin and emax and update h accordingly\\n if np.max(eps) < emin:\\n if h*2.0 < hmax:\\n h *= 2.0\\n new_v = new_v5\\n new_r = new_r5 \\n \\n if np.max(eps) > emax:\\n if h/2.0 > hmin:\\n h /= 2.0\\n print h\\n # Error too large, call rk_adaptive again with smaller h\\n if recur < recurmax:\\n recur += 1\\n rk_adaptive(accel,m,r,h,v,recur)\\n new_v = new_v5\\n new_r = new_r5\\n \\n else:\\n new_v = new_v5\\n new_r = new_r5\\n \\n return new_v, new_r, h\",\n \"def internal_heat_gain(dwelling):\\n losses_gain = -40 * dwelling.Nocc\\n water_heating_gains = (1000. / 24.) * dwelling.heat_gains_from_hw / DAYS_PER_MONTH\\n\\n mean_appliance_energy = 207.8 * (dwelling.GFA * dwelling.Nocc) ** 0.4714\\n appliance_consumption_per_day = (mean_appliance_energy / 365.) * (\\n 1 + 0.157 * numpy.cos((2. * math.pi / 12.) * (numpy.arange(12) - .78)))\\n\\n appliance_consumption = appliance_consumption_per_day * DAYS_PER_MONTH\\n\\n if dwelling.reduced_gains:\\n met_gain = 50 * dwelling.Nocc\\n cooking_gain = 23 + 5 * dwelling.Nocc\\n appliance_gain = (0.67 * 1000. / 24) * appliance_consumption_per_day\\n light_gain = 0.4 * dwelling.full_light_gain\\n else:\\n met_gain = 60 * dwelling.Nocc\\n cooking_gain = 35 + 7 * dwelling.Nocc\\n appliance_gain = (1000. / 24) * appliance_consumption_per_day\\n light_gain = dwelling.full_light_gain\\n\\n total_internal_gains = (met_gain\\n + light_gain\\n + appliance_gain\\n + cooking_gain\\n + water_heating_gains\\n + dwelling.pump_gain\\n + losses_gain)\\n\\n if dwelling.reduced_gains:\\n summer_met_gain = 60 * dwelling.Nocc\\n summer_cooking_gain = 35 + 7 * dwelling.Nocc\\n summer_appliance_gain = (1000. / 24) * appliance_consumption_per_day\\n summer_light_gain = dwelling.full_light_gain\\n total_internal_gains_summer = (summer_met_gain +\\n water_heating_gains +\\n summer_light_gain +\\n summer_appliance_gain +\\n summer_cooking_gain +\\n dwelling.pump_gain +\\n losses_gain\\n - dwelling.heating_system_pump_gain)\\n else:\\n total_internal_gains_summer = total_internal_gains - dwelling.heating_system_pump_gain\\n\\n # Apply results to dwelling\\n return dict(appliance_consumption=appliance_consumption,\\n met_gain=met_gain,\\n cooking_gain=cooking_gain,\\n appliance_gain=appliance_gain,\\n light_gain=light_gain,\\n water_heating_gains=water_heating_gains,\\n losses_gain=losses_gain,\\n total_internal_gains=total_internal_gains,\\n total_internal_gains_summer=total_internal_gains_summer)\",\n \"def dK_dtheta(self,dL_dK,X,X2,target):\\r\\n if X2 is None: X2 = X\\r\\n FX = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X)\\r\\n FX2 = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X2)\\r\\n\\r\\n La = np.column_stack((self.a[0]*np.ones((self.n_basis,1)),self.a[1]*self.basis_omega))\\r\\n Lo = np.column_stack((self.basis_omega,self.basis_omega))\\r\\n Lp = np.column_stack((self.basis_phi,self.basis_phi+np.pi/2))\\r\\n r,omega,phi = self._cos_factorization(La,Lo,Lp)\\r\\n Gint = self._int_computation( r,omega,phi, r,omega,phi)\\r\\n\\r\\n Flower = np.array(self._cos(self.basis_alpha,self.basis_omega,self.basis_phi)(self.lower))[:,None]\\r\\n\\r\\n #dK_dvar\\r\\n dK_dvar = 1./self.variance*mdot(FX,self.Gi,FX2.T)\\r\\n\\r\\n #dK_dlen\\r\\n da_dlen = [-1./self.lengthscale**2,0.]\\r\\n dLa_dlen = np.column_stack((da_dlen[0]*np.ones((self.n_basis,1)),da_dlen[1]*self.basis_omega))\\r\\n r1,omega1,phi1 = self._cos_factorization(dLa_dlen,Lo,Lp)\\r\\n dGint_dlen = self._int_computation(r1,omega1,phi1, r,omega,phi)\\r\\n dGint_dlen = dGint_dlen + dGint_dlen.T\\r\\n dG_dlen = 1./2*Gint + self.lengthscale/2*dGint_dlen\\r\\n dK_dlen = -mdot(FX,self.Gi,dG_dlen/self.variance,self.Gi,FX2.T)\\r\\n\\r\\n #dK_dper\\r\\n dFX_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X ,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X)\\r\\n dFX2_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X2,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X2)\\r\\n\\r\\n dLa_dper = np.column_stack((-self.a[0]*self.basis_omega/self.period, -self.a[1]*self.basis_omega**2/self.period))\\r\\n dLp_dper = np.column_stack((self.basis_phi+np.pi/2,self.basis_phi+np.pi))\\r\\n r1,omega1,phi1 = self._cos_factorization(dLa_dper,Lo,dLp_dper)\\r\\n\\r\\n IPPprim1 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi/2))\\r\\n IPPprim1 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi/2))\\r\\n IPPprim2 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + self.upper*np.cos(phi-phi1.T))\\r\\n IPPprim2 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + self.lower*np.cos(phi-phi1.T))\\r\\n #IPPprim2[0,0] = 2*(self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\\r\\n IPPprim = np.where(np.isnan(IPPprim1),IPPprim2,IPPprim1)\\r\\n\\r\\n IPPint1 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi)\\r\\n IPPint1 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi)\\r\\n IPPint2 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./2*self.upper**2*np.cos(phi-phi1.T)\\r\\n IPPint2 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./2*self.lower**2*np.cos(phi-phi1.T)\\r\\n #IPPint2[0,0] = (self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\\r\\n IPPint = np.where(np.isnan(IPPint1),IPPint2,IPPint1)\\r\\n\\r\\n dLa_dper2 = np.column_stack((-self.a[1]*self.basis_omega/self.period))\\r\\n dLp_dper2 = np.column_stack((self.basis_phi+np.pi/2))\\r\\n r2,omega2,phi2 = dLa_dper2.T,Lo[:,0:1],dLp_dper2.T\\r\\n\\r\\n dGint_dper = np.dot(r,r1.T)/2 * (IPPprim - IPPint) + self._int_computation(r2,omega2,phi2, r,omega,phi)\\r\\n dGint_dper = dGint_dper + dGint_dper.T\\r\\n\\r\\n dFlower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\\r\\n\\r\\n dG_dper = 1./self.variance*(self.lengthscale/2*dGint_dper + self.b[0]*(np.dot(dFlower_dper,Flower.T)+np.dot(Flower,dFlower_dper.T)))\\r\\n\\r\\n dK_dper = mdot(dFX_dper,self.Gi,FX2.T) - mdot(FX,self.Gi,dG_dper,self.Gi,FX2.T) + mdot(FX,self.Gi,dFX2_dper.T)\\r\\n\\r\\n target[0] += np.sum(dK_dvar*dL_dK)\\r\\n target[1] += np.sum(dK_dlen*dL_dK)\\r\\n target[2] += np.sum(dK_dper*dL_dK)\",\n \"def K(self, u, v):\\n return (self.L(u, v) * self.N(u, v) - np.square(self.M(u, v))) / \\\\\\n (self.E(u, v) * self.G(u, v) - np.square(self.F(u, v)))\",\n \"def price_heston_mc(kappa_,theta_,sigma_,rho_,r_,T_,L_,V0_,S0_,K0_,N_):\\r\\n esp_ = monte_carlo(kappa_,theta_,sigma_,rho_,r_,T_,L_,V0_,S0_,K0_,N_)\\r\\n return exp(-r_*T_)*esp_\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6411429","0.61664015","0.60879153","0.59830314","0.58720684","0.5814098","0.58111423","0.58111423","0.577404","0.5765074","0.5746197","0.57347727","0.5694414","0.5672527","0.5637371","0.5624423","0.56225246","0.5611478","0.5611203","0.5557416","0.5555901","0.5545839","0.5539001","0.5519944","0.54987246","0.5487196","0.5485526","0.5475468","0.5465655","0.54407054","0.54297286","0.5413739","0.54039866","0.5398821","0.539731","0.53924847","0.5384838","0.5383824","0.5383052","0.538219","0.5371888","0.53651905","0.5364333","0.535864","0.5350602","0.53501207","0.534204","0.5340611","0.5335728","0.53316003","0.53298837","0.5325229","0.5321421","0.5318152","0.53168213","0.5316668","0.5314634","0.531446","0.53111595","0.5307363","0.53026426","0.52908736","0.5287677","0.5287202","0.5286938","0.5280484","0.52759445","0.5272048","0.5265578","0.52492756","0.52461296","0.5237068","0.52325386","0.5231941","0.5231628","0.52310234","0.5229983","0.52298576","0.5226044","0.52251166","0.5222672","0.522242","0.5222272","0.5221614","0.5221545","0.52120227","0.5209348","0.5206215","0.52036417","0.5194325","0.51910794","0.5186964","0.5170503","0.5166939","0.516453","0.51619154","0.5159256","0.5158139","0.5153991","0.5150197","0.51452804"],"string":"[\n \"0.6411429\",\n \"0.61664015\",\n \"0.60879153\",\n \"0.59830314\",\n \"0.58720684\",\n \"0.5814098\",\n \"0.58111423\",\n \"0.58111423\",\n \"0.577404\",\n \"0.5765074\",\n \"0.5746197\",\n \"0.57347727\",\n \"0.5694414\",\n \"0.5672527\",\n \"0.5637371\",\n \"0.5624423\",\n \"0.56225246\",\n \"0.5611478\",\n \"0.5611203\",\n \"0.5557416\",\n \"0.5555901\",\n \"0.5545839\",\n \"0.5539001\",\n \"0.5519944\",\n \"0.54987246\",\n \"0.5487196\",\n \"0.5485526\",\n \"0.5475468\",\n \"0.5465655\",\n \"0.54407054\",\n \"0.54297286\",\n \"0.5413739\",\n \"0.54039866\",\n \"0.5398821\",\n \"0.539731\",\n \"0.53924847\",\n \"0.5384838\",\n \"0.5383824\",\n \"0.5383052\",\n \"0.538219\",\n \"0.5371888\",\n \"0.53651905\",\n \"0.5364333\",\n \"0.535864\",\n \"0.5350602\",\n \"0.53501207\",\n \"0.534204\",\n \"0.5340611\",\n \"0.5335728\",\n \"0.53316003\",\n \"0.53298837\",\n \"0.5325229\",\n \"0.5321421\",\n \"0.5318152\",\n \"0.53168213\",\n \"0.5316668\",\n \"0.5314634\",\n \"0.531446\",\n \"0.53111595\",\n \"0.5307363\",\n \"0.53026426\",\n \"0.52908736\",\n \"0.5287677\",\n \"0.5287202\",\n \"0.5286938\",\n \"0.5280484\",\n \"0.52759445\",\n \"0.5272048\",\n \"0.5265578\",\n \"0.52492756\",\n \"0.52461296\",\n \"0.5237068\",\n \"0.52325386\",\n \"0.5231941\",\n \"0.5231628\",\n \"0.52310234\",\n \"0.5229983\",\n \"0.52298576\",\n \"0.5226044\",\n \"0.52251166\",\n \"0.5222672\",\n \"0.522242\",\n \"0.5222272\",\n \"0.5221614\",\n \"0.5221545\",\n \"0.52120227\",\n \"0.5209348\",\n \"0.5206215\",\n \"0.52036417\",\n \"0.5194325\",\n \"0.51910794\",\n \"0.5186964\",\n \"0.5170503\",\n \"0.5166939\",\n \"0.516453\",\n \"0.51619154\",\n \"0.5159256\",\n \"0.5158139\",\n \"0.5153991\",\n \"0.5150197\",\n \"0.51452804\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":5496,"cells":{"query":{"kind":"string","value":"Warn the user that running with nipy being imported locally is a bad idea."},"document":{"kind":"string","value":"def _test_local_install():\n if os.getcwd() == os.sep.join(\n os.path.abspath(__file__).split(os.sep)[:-2]):\n import warnings\n warnings.warn('Running the tests from the install directory may '\n 'trigger some failures')"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def is_nuke():\n try:\n import _nuke\n return True\n except ImportError:\n return False","def provoke_and_handle_ImportError():\n try:\n from you import me\n except ImportError as impe:\n print(f\"Sorry! {impe}\")","def unavailable_importer(**kwargs):\n return LazyImportTester(\"_qiskit_this_module_does_not_exist_\", **kwargs)","def _suppress_warnings():\n import warnings\n import sys\n import os\n if os.path.basename(sys.argv[0]) != \"trial\":\n warnings.simplefilter(\"ignore\")","def disabled_test_no_warnings(import_path: str) -> None:\n imp_cmd = (\n sys.executable,\n '-W', 'error',\n '-c', f'import {import_path!s}',\n )\n\n subprocess.check_call(imp_cmd)","def runipy_available():\n try:\n import runipy\n except ImportError:\n return False\n return True","def warning(*args, noContext: bool=True, showLineNumber: bool=True, **kwargs)->None:\n pass","def lint():\n toolkit.lint(exclude=[\"__init__.py\"])","def no_xb_gui():\n logger.warning(\"Could not import the GUI.\")\n logger.warning(\"For instructions on how to install the GUI,\")\n logger.warning(\"check the docs janclemenslab.org/das/install.html.\")","def import_fail_info(mod_name,fns=None):\n\n if fns == None:\n warn(\"Loading of %s failed.\\n\" % (mod_name,))\n else:\n warn(\"Loading of %s from %s failed.\\n\" % (fns,mod_name))","def importlib_only(fxn):\n return unittest.skipIf(using___import__, \"importlib-specific test\")(fxn)","def issilent():\n return GLOBAL['VERBOSE'] == False","def skip_require():\n global ignore_once\n ignore_once = True","def noCheck():\n dislin.nochek()","def has_warnings(self) -> bool:","def is_unexposed(self):\r\n return conf.lib.clang_isUnexposed(self)","def test_if_ipython():\n try:\n return __IPYTHON__\n except NameError:\n return False","def provoke_and_handle_ModuleNotFoundError():\n try:\n import arsiton324\n except ModuleNotFoundError as mnfe:\n print(f\"Sorry! {mnfe} was found!\")","def ignore_builtin_verification():\n return not current_space().skip_builtin_verification","def _should_ignore(self, name):\n _name = name.lower()\n return (_name.startswith(\"deprecated\") or\n _name.startswith(\"_\") or\n _name in (\"remote\", \"reserved\",\n \"dialogs_py\", \"dialogs_ipy\", \"dialogs_jy\"))","def test_getattr_error_attr_not_found():\n with pytest.raises(ImportError):\n from astropy.cosmology.flrw import this_is_not_a_variable # noqa: F401","def add_warning_non_file(self, code: Code, msg: str,\n is_persistant: bool = False) -> None:","def warn():\n pass","def import_packages_global():\n return \"\"","def show_missing():\n if missing_modules:\n info(\"The following modules are currently not installed and would enable additional tasks:\")\n for pkg_name in missing_modules:\n info(' ' + pkg_name)","def no_afni():\n if Info.version() is None:\n return True\n return False","def test_import_allows_multiple_modules_failure(self):\n # Deliberately using modules that will already be imported to avoid side effects.\n feature = LazyImportTester([\"site\", \"sys\", \"_qiskit_module_does_not_exist_\"])\n with mock_availability_test(feature) as check:\n check.assert_not_called()\n self.assertFalse(feature)\n check.assert_called_once()","def _check_imports():\n\n optlist = ['ALPSO', 'CONMIN', 'FSQP', 'IPOPT', 'NLPQLP',\n 'NSGA2', 'PSQP', 'SLSQP', 'SNOPT', 'NLPY_AUGLAG', 'NOMAD']\n\n for optimizer in optlist[:]:\n try:\n __import__('pyoptsparse', globals(), locals(), [optimizer], 0)\n except ImportError:\n optlist.remove(optimizer)\n\n return optlist","def has_warnings_active(self) -> bool:","def missing_in_gn(self):\n return self._missing_gn_flags","def main():\n\n warning_message = \"This script contains the code that builds the \" \\\n + \"main page of the FCA (File Converter App).\" \\\n + \"\\n\\nThis script should NOT be run DIRECTLY.\" \\\n + \"\\n\\nPlease, import it in another script.\"\n\n cGUIf.show_warning(\"Import warning\",warning_message)","def test_ensureWhenNotImported(self):\n modules = {}\n self.patch(sys, \"modules\", modules)\n ensureNotImported([\"m1\", \"m2\"], \"A message.\", preventImports=[\"m1\", \"m2\", \"m3\"])\n self.assertEqual(modules, {\"m1\": None, \"m2\": None, \"m3\": None})","def no_additional_complaints() -> None:\n logging.getLogger(\"asyncio\").setLevel(\"CRITICAL\")\n warnings.simplefilter(\"ignore\")","def missing_in_gyp_by_file(self):\n return self._missing_gyp_files","def _c_optimizations_ignored():\n pure_env = os.environ.get('PURE_PYTHON')\n return pure_env != \"0\" if pure_env is not None else PYPY","def is_running_locally():\n local = False\n if \"POLYAXON_NO_OP\" in os.environ:\n local = True\n return local","def is_not_used(self):\n pass","def has_errors_fatal(self) -> bool:","def is_ipython():\n return 'get_ipython' in globals()","def _strict_warning(self):\n if self.options.get('strict', True):\n return ('Strict mode enabled (the default), so this could be due to an '\n 'integer key, such as an HTTP status code.')\n return ('Strict mode disabled. Prance cannot help you narrow this further '\n 'down, sorry.')","def _run_from_ipython():\n try:\n __IPYTHON__\n return True\n except NameError:\n return False","def disableIncorrectNameWarning(*args, **kwargs)->None:\n pass","def check_invalid_args_general(config):\n # Not mathematically correct, but might be required if prior is not\n # appropriate.\n if hasattr(config, 'kl_scale') and config.kl_scale != 1.0:\n warnings.warn('Prior matching term will be scaled by %f.'\n % config.kl_scale)\n\n if hasattr(config, 'store_final_model') and \\\n hasattr(config, 'train_from_scratch') and \\\n config.store_final_model and config.train_from_scratch:\n warnings.warn('Note, when training from scratch, the final model is ' +\n 'only trained on the last task!')","def has_nlu(self):\n return self.metadata.has_been_coded_for(\"nlu\")","def isIgnoredPkg(self, *args):\n return _libsbml.SBMLDocument_isIgnoredPkg(self, *args)","def test_ensureWhenNotImportedDontPrevent(self):\n modules = {}\n self.patch(sys, \"modules\", modules)\n ensureNotImported([\"m1\", \"m2\"], \"A message.\")\n self.assertEqual(modules, {})","def test_import_allows_attributes_failure(self):\n # We can just use existing modules for this.\n name_map = {\n \"sys\": (\"executable\", \"path\"),\n \"builtins\": (\"list\", \"_qiskit_dummy_attribute_\"),\n }\n\n feature = LazyImportTester(name_map)\n self.assertFalse(feature)","def filter_warnings():\n warnings.simplefilter(\"ignore\", category=UserWarning)\n warnings.simplefilter(\"ignore\", category=LightningDeprecationWarning)","def test_suppress_import(self):\n logging.info(\"testing suppress import\")\n\n generated_file = os.path.join(self._test_workspace,\n \"generated.suppress\")\n\n extract_cmd = ['CodeChecker', 'parse',\n os.path.join(self._test_workspace, \"reports\"),\n \"--suppress\", generated_file,\n \"--export-source-suppress\"\n ]\n\n ret = call_cmd(extract_cmd,\n self._test_project_path,\n env.test_env(self._test_workspace))\n self.assertEqual(ret, 2, \"Failed to generate suppress file.\")\n\n codechecker_cfg = env.import_test_cfg(\n self._test_workspace)['codechecker_cfg']\n\n product_url = env.parts_to_url(codechecker_cfg)\n import_cmd = ['CodeChecker', 'cmd', 'suppress', '-i', generated_file,\n '--url', product_url, self._run_name]\n\n print(import_cmd)\n ret = call_cmd(import_cmd,\n self._test_project_path,\n env.test_env(self._test_workspace))\n self.assertEqual(ret, 0, \"Failed to import suppress file.\")","def checkImport(self):\r\n for imp in self.cap_file.Import.packages:\r\n if a2s(imp.aid) not in export_refs:\r\n return False\r\n return True","def setup_test():\n if LooseVersion(np.__version__) >= LooseVersion('1.14'):\n np.set_printoptions(legacy='1.13')\n\n # Temporary fix until scipy release in October 2018\n # must be removed after that\n # print the first occurrence of matching warnings for each location\n # (module + line number) where the warning is issued\n if (\n LooseVersion(np.__version__) >= LooseVersion('1.15')\n and LooseVersion(scipy.version.short_version) <= '1.1.0'\n ):\n warnings.simplefilter('default')","def test_ImportError(n=2):\n\n p = bad_import()\n\n try:\n p.result()\n except ImportError:\n print(\"Caught ImportError\")\n else:\n assert False, \"Raise the wrong Error\"","def no_coverage_warn():\n if covdb is None or len(covdb.coverage_files) == 0:\n show_message_box(\"Need to Import Traces First\",\n \"Can't perform this action yet, no traces have been imported\",\n MessageBoxButtonSet.OKButtonSet,\n MessageBoxIcon.ErrorIcon)\n return True\n return False","def were_in_ipython():\n shell = get_ipython()\n if shell is None:\n raise NotInIPythonError\n else:\n return True","def test_absent_imports():\n module, HABEMUS_MODULE = optional_import(\"not_real_module\")\n\n assert not HABEMUS_MODULE\n assert module.__name__ == \"not_real_module\"\n with pytest.raises(ModuleNotFoundError):\n _ = module.layers","def is_imported():\n return len(inspect.stack()) > 3","def test_missing_pypirc(self):\n self.assertEqual(\n package_manager.extra_pypi_index_servers('does not exist'),\n [])","def ignore_python_warnings(function):\n\n @functools.wraps(function)\n def wrapped(*args, **kwargs):\n \"\"\"\n Wrapped function.\n \"\"\"\n\n with warnings.catch_warnings():\n warnings.simplefilter('ignore')\n\n return function(*args, **kwargs)\n\n return wrapped","def check_for_unused_names(self):\n for s in self.unused_names:\n self.warning(\"'%s' is unused.\"%s)\n\n# warns for param that specified with -c (but also if name gets defined in __main__,\n# e.g. by default_density=global_params.default_density in a script file\n## for name in self.params():\n## if name in self.context:\n## self.warning(\"'%s' still exists in global_params.context\"%name)\n\n # detect duplicate param value that wasn't used (e.g. specified with after script)\n for name,val in self.params().items():\n if name in self.context:\n if self.context[name]!=self.inspect_value(name):\n self.warning(\"'%s=%s' is unused.\"%(name,self.context[name]))","def test_ensureWhenFailedToImport(self):\n modules = {\"m2\": None}\n self.patch(sys, \"modules\", modules)\n ensureNotImported([\"m1\", \"m2\"], \"A message.\", preventImports=[\"m1\", \"m2\"])\n self.assertEqual(modules, {\"m1\": None, \"m2\": None})","def load_numpy_distutils_misc_util(finder, module):\n module.IgnoreName(\"numscons\")","def check_imports():\n try:\n import dns # pylint: disable=C0415,W0611 # noqa: F401\n import ecdsa # pylint: disable=C0415,W0611 # noqa: F401\n import google.protobuf # pylint: disable=C0415,W0611 # noqa: F401\n import jsonrpclib # pylint: disable=C0415,W0611 # noqa: F401\n import pyaes # pylint: disable=C0415,W0611 # noqa: F401\n import qrcode # pylint: disable=C0415,W0611 # noqa: F401\n import requests # pylint: disable=C0415 # noqa: F401\n except ImportError as i_e:\n sys.exit(\"Error: %s. Try 'sudo pip install <module-name>'\" % str(i_e))\n from google.protobuf import descriptor # pylint: disable=C0415,W0611 # noqa: F401\n from google.protobuf import message # pylint: disable=C0415,W0611 # noqa: F401\n from google.protobuf import reflection # pylint: disable=C0415,W0611 # noqa: F401\n from google.protobuf import ( # pylint: disable=C0415,W0611 # noqa: F401\n descriptor_pb2,\n )\n from jsonrpclib import ( # pylint: disable=C0415,W0611 # noqa: F401\n SimpleJSONRPCServer,\n )\n\n # make sure that certificates are here\n certs = requests.utils.DEFAULT_CA_BUNDLE_PATH\n if not os.path.exists(certs):\n raise AssertionError(\"Certificates not found\")","def test_LPyModelDriver_nolpy(): # pragma: no lpy\n assert_raises(RuntimeError, LPyModelDriver.LPyModelDriver,\n 'test', scripts['lpy'])","def missing_in_gyp(self):\n return self._missing_gyp_flags","def __init__(self):\n super().__init__(\n \"This module requires installation of megnet, \"\n \"which is not found in your current environment.\"\n \"Please install it via `pip install megnet` or \"\n \"via github source\"\n )","def _should_ignore_module(cls, module_name):\n # exclude test modules for now to avoid spurious failures\n # TODO(jelle): enable for test modules too\n return module_name.split(\".\")[-1].startswith(\"test\")","def modifyComponentsNotPreferableOnServer(self):\n # Nothing to do\n pass","def ignore_warnings(my_func):\n\n def wrapper(self, *args, **kwargs):\n \"\"\"\n This is where the warning suppression occurs.\n \"\"\"\n if sys.version_info >= (3, 2):\n warnings.simplefilter(\"ignore\", ResourceWarning)\n with warnings.catch_warnings():\n my_func(self, *args, **kwargs)\n\n return wrapper","def missing_ltihooks(finder, caller):\n caller.IgnoreName(\"ltihooks\")","def no_prereq_install():\n return str2bool(os.environ.get('NO_PREREQ_INSTALL', 'False'))","def init_warnings():\n warnings.simplefilter(\"ignore\", category=AstropyWarning)","def discardedException( self, exc_stuff ):\n extype = exc_stuff[0]\n value = exc_stuff[1]\n tb = exc_stuff[2]\n if isJython :\n # Misc intermediate ImportError exceptions may occur\n # during Jython import we need to ignore them ; if a module can't be\n # really imported a final ImportError will break the execution of the debuggee\n # so it's safe to ignore ImportError for Jythn here\n if issubclass(extype,ImportError) :\n return True # discarded\n return False","def test_import_error_message_maintained(self):\n settings = GrpcSettings({\n 'INTERCEPTORS': [\n ('tests.invalid_module.InvalidClassName', {})\n ]\n })\n with self.assertRaises(ImportError):\n _ = settings.INTERCEPTORS","def run_from_ipython():\n try:\n __IPYTHON__\n return True\n except NameError:\n return False","def error_impresion(self):\n self._info(\"error_impresion\")","def requirement_missing(script):\n if \"requires\" in script:\n if script[\"requires\"] is None:\n return False\n for package in script[\"requires\"].split():\n try:\n pkg_resources.working_set.require(package)\n except Exception:\n return True\n return False","def allow_warnings(self):\n return self._allow_warnings","def not_installed(self) -> bool:\n return pulumi.get(self, \"not_installed\")","def _validate_running_as_fvalidation_exempt_user():\n if acm.UserName() not in FValidation_settings.SUPERUSERS:\n # Ensure that tool is run as a user exempt from FValidation\n # in order to avoid GUI pop-ups when touching entities.\n raise ValueError(\"This tool must be run by a user that is exempt from FValidation.\")","def test_deprecated_private_variables(attr):\n with pytest.warns(AstropyDeprecationWarning):\n resolve_name(\"astropy\", \"cosmology\", \"flrw\", attr)","def add_ignore_module(modules: List[Any]):\n global BUILTIN_LIKELY_MODULES\n for module in modules:\n if module not in BUILTIN_LIKELY_MODULES:\n BUILTIN_LIKELY_MODULES.append(module)","def nfvi_compute_plugin_disabled():\n return (_compute_plugin is None)","def warning(self, *args, **kwargs):","def check_stability(self):","def add_warning_non_file(self, code: Code, msg: str,\n is_persistant: bool = False) -> None:\n self.add_error_non_file(code, msg, severity=Severity.WARNING,\n is_persistant=is_persistant)","def no_require():\n from twill import commands\n \n l = commands.browser._post_load_hooks\n l = [ fn for fn in l if fn != _require_post_load_hook ]\n commands.browser._post_load_hooks = l\n\n global _requirements\n _requirements = []","def is_notebook():\n return \"ipykernel\" in sys.modules","def detect_import(self):\n if self.contains_match(CONTAINS_IMPORT): self.es6import = True\n elif self.contains_match(CONTAINS_REQUIRE): self.es6import = False\n else: self.es6import = self.get_project_pref('detect_prefer_imports')","def _set_insufficient_confidence_warning(\n self): # pragma: no cover\n self.failed_initial_confidence = True\n self.surface_result('LO_INIT_CONF')\n self.warnings.append(\n 'Bisect failed to reproduce the regression with enough confidence.')","def test_check_model_dependencies_missing_warning(dependency_testing_model, complete_env) -> None:\n incomplete_env = Python(\n [r for r in complete_env.requirements if r not in ['PyYAML==0.0.1', 'pandas==0.0.1']]\n ) # drop a single dependency to be caught\n with warnings.catch_warnings(record=True) as caught_warnings:\n assert not check_model_dependencies(\n model_cls=dependency_testing_model,\n environment=incomplete_env,\n raise_for_missing=False,\n )\n warn_msg = caught_warnings[0].message.args[0]\n assert warn_msg == \"the following packages are required by the model but missing \" \\\n \"from the environment:\\npandas (installed via ['pandas'])\" \\\n \"\\nyaml (installed via ['PyYAML'])\"","def has_err_warn(self):\r\n return self._arm.has_err_warn","def test_import_nothandled():\n sys.meta_path.append(TaskImporter())\n with pytest.raises(ImportError):\n import_module('not.exist')","def unsure_how_to_install(self):\n msg = \"Unsure how to install {0}.\".format(self.name)\n if self.info_uri:\n msg += \"\\nRefer to {0} for information\".format(self.info_uri)\n\n if platform.system() == 'Darwin':\n if 'brew' in self._provider_package and not helpers['brew']:\n msg += (\"\\nCOT can use Homebrew (https://brew.sh), \"\n \"if available on your system, to install {0}.\"\n .format(self.name))\n if 'port' in self._provider_package and not helpers['port']:\n msg += (\"\\nCOT can use MacPorts (https://www.macports.org/), \"\n \"if available on your system, to install {0}.\"\n .format(self.name))\n if ('brew' in self._provider_package or\n 'port' in self._provider_package):\n return RuntimeError(msg)\n else:\n return NotImplementedError(msg)\n elif platform.system() == 'Linux' and (\n ('apt-get' in self._provider_package or\n 'yum' in self._provider_package) and\n not (helpers['apt-get'] or helpers['yum'])):\n msg += (\"\\nCOT can use package managers 'yum' or 'apt-get' to\"\n \" install helpers on your system, but it appears that\"\n \" you have neither of these package managers?\")\n return RuntimeError(msg)\n else:\n return NotImplementedError(msg)","def _warn(msg):\n warnings.warn(msg, TessyWarning, stacklevel=3)","def check_no_silent_crash(self, override=False):\n if self.results:\n score = self.results.linter.stats.get('global_note', False)\n if score is False:\n messages = self.results.linter.stats.get('by_msg', {})\n if messages.get('syntax-error', False) and not override:\n self.logging.warning('\\n------------------------------------------------------------------')\n self.logging.warning('PYLINT FAILED BECAUSE SYNTAX ERROR.')\n self.logging.warning('------------------------------------------------------------------')\n self.logging.warning('\\n')\n self.failed_files.append(self.fname)\n return False\n self.logging.info('\\n------------------------------------------------------------------')\n self.logging.info('FILE WAS IGNORED.')\n self.logging.info('------------------------------------------------------------------')\n return True\n return False","def test_noexceptions(nb_path, tmpdir):\n nb = load_notebook(nb_path)\n pyfile = \"%s.py\" % str(\n tmpdir.join(os.path.splitext(os.path.basename(nb_path))[0]))\n export_py(nb, pyfile)\n execfile(pyfile, {})","def test_deprecated_modules(self):\n\n deprecated_modules_present = False\n\n deprecated_modules = [\n \"game_assets\",\n \"models\",\n \"world\",\n \"modular_assets\",\n ]\n\n for path in self.application_files:\n for module in deprecated_modules:\n module_text = open(path).read()\n found_reference = False\n if \"import %s\" % module in module_text:\n found_reference = True\n if \"from %s\" % module in module_text:\n found_reference = True\n\n if found_reference:\n print(\"Found '%s' reference in %s\" % (module, path))\n deprecated_modules_present = True\n\n self.assertFalse(deprecated_modules_present)","def has_off_hook_warning(self) -> bool:","def CheckNoBannedFunctions(input_api, output_api):\n warnings = []\n\n def GetMessageForFunction(input_api, affected_file, line_num, line, func_name,\n message):\n result = []\n if input_api.re.search(r\"^ *//\", line): # Ignore comments.\n return result\n if line.endswith(\" nocheck\"): # Ignore lines with nocheck comments.\n return result\n\n if func_name in line:\n result.append(' %s:%d:' % (affected_file.LocalPath(), line_num))\n for message_line in message:\n result.append(' %s' % message_line)\n\n return result\n\n\n file_filter = lambda f: f.LocalPath().endswith(('.cc', '.mm', '.h'))\n for f in input_api.AffectedFiles(file_filter=file_filter):\n for line_num, line in f.ChangedContents():\n for func_name, message in _BANNED_CPP_FUNCTIONS:\n problems = GetMessageForFunction(input_api, f, line_num, line,\n func_name, message)\n if problems:\n warnings.extend(problems)\n\n result = []\n if (warnings):\n result.append(output_api.PresubmitPromptWarning(\n 'Banned functions were used.\\n' + '\\n'.join(warnings)))\n return result","def check_for_underscore(self):\n # If something injected a '_' variable in __builtin__, delete\n # ipython's automatic one so we don't clobber that. gettext() in\n # particular uses _, so we need to stay away from it.\n if '_' in __builtin__.__dict__:\n try:\n del self.shell.user_ns['_']\n except KeyError:\n pass"],"string":"[\n \"def is_nuke():\\n try:\\n import _nuke\\n return True\\n except ImportError:\\n return False\",\n \"def provoke_and_handle_ImportError():\\n try:\\n from you import me\\n except ImportError as impe:\\n print(f\\\"Sorry! {impe}\\\")\",\n \"def unavailable_importer(**kwargs):\\n return LazyImportTester(\\\"_qiskit_this_module_does_not_exist_\\\", **kwargs)\",\n \"def _suppress_warnings():\\n import warnings\\n import sys\\n import os\\n if os.path.basename(sys.argv[0]) != \\\"trial\\\":\\n warnings.simplefilter(\\\"ignore\\\")\",\n \"def disabled_test_no_warnings(import_path: str) -> None:\\n imp_cmd = (\\n sys.executable,\\n '-W', 'error',\\n '-c', f'import {import_path!s}',\\n )\\n\\n subprocess.check_call(imp_cmd)\",\n \"def runipy_available():\\n try:\\n import runipy\\n except ImportError:\\n return False\\n return True\",\n \"def warning(*args, noContext: bool=True, showLineNumber: bool=True, **kwargs)->None:\\n pass\",\n \"def lint():\\n toolkit.lint(exclude=[\\\"__init__.py\\\"])\",\n \"def no_xb_gui():\\n logger.warning(\\\"Could not import the GUI.\\\")\\n logger.warning(\\\"For instructions on how to install the GUI,\\\")\\n logger.warning(\\\"check the docs janclemenslab.org/das/install.html.\\\")\",\n \"def import_fail_info(mod_name,fns=None):\\n\\n if fns == None:\\n warn(\\\"Loading of %s failed.\\\\n\\\" % (mod_name,))\\n else:\\n warn(\\\"Loading of %s from %s failed.\\\\n\\\" % (fns,mod_name))\",\n \"def importlib_only(fxn):\\n return unittest.skipIf(using___import__, \\\"importlib-specific test\\\")(fxn)\",\n \"def issilent():\\n return GLOBAL['VERBOSE'] == False\",\n \"def skip_require():\\n global ignore_once\\n ignore_once = True\",\n \"def noCheck():\\n dislin.nochek()\",\n \"def has_warnings(self) -> bool:\",\n \"def is_unexposed(self):\\r\\n return conf.lib.clang_isUnexposed(self)\",\n \"def test_if_ipython():\\n try:\\n return __IPYTHON__\\n except NameError:\\n return False\",\n \"def provoke_and_handle_ModuleNotFoundError():\\n try:\\n import arsiton324\\n except ModuleNotFoundError as mnfe:\\n print(f\\\"Sorry! {mnfe} was found!\\\")\",\n \"def ignore_builtin_verification():\\n return not current_space().skip_builtin_verification\",\n \"def _should_ignore(self, name):\\n _name = name.lower()\\n return (_name.startswith(\\\"deprecated\\\") or\\n _name.startswith(\\\"_\\\") or\\n _name in (\\\"remote\\\", \\\"reserved\\\",\\n \\\"dialogs_py\\\", \\\"dialogs_ipy\\\", \\\"dialogs_jy\\\"))\",\n \"def test_getattr_error_attr_not_found():\\n with pytest.raises(ImportError):\\n from astropy.cosmology.flrw import this_is_not_a_variable # noqa: F401\",\n \"def add_warning_non_file(self, code: Code, msg: str,\\n is_persistant: bool = False) -> None:\",\n \"def warn():\\n pass\",\n \"def import_packages_global():\\n return \\\"\\\"\",\n \"def show_missing():\\n if missing_modules:\\n info(\\\"The following modules are currently not installed and would enable additional tasks:\\\")\\n for pkg_name in missing_modules:\\n info(' ' + pkg_name)\",\n \"def no_afni():\\n if Info.version() is None:\\n return True\\n return False\",\n \"def test_import_allows_multiple_modules_failure(self):\\n # Deliberately using modules that will already be imported to avoid side effects.\\n feature = LazyImportTester([\\\"site\\\", \\\"sys\\\", \\\"_qiskit_module_does_not_exist_\\\"])\\n with mock_availability_test(feature) as check:\\n check.assert_not_called()\\n self.assertFalse(feature)\\n check.assert_called_once()\",\n \"def _check_imports():\\n\\n optlist = ['ALPSO', 'CONMIN', 'FSQP', 'IPOPT', 'NLPQLP',\\n 'NSGA2', 'PSQP', 'SLSQP', 'SNOPT', 'NLPY_AUGLAG', 'NOMAD']\\n\\n for optimizer in optlist[:]:\\n try:\\n __import__('pyoptsparse', globals(), locals(), [optimizer], 0)\\n except ImportError:\\n optlist.remove(optimizer)\\n\\n return optlist\",\n \"def has_warnings_active(self) -> bool:\",\n \"def missing_in_gn(self):\\n return self._missing_gn_flags\",\n \"def main():\\n\\n warning_message = \\\"This script contains the code that builds the \\\" \\\\\\n + \\\"main page of the FCA (File Converter App).\\\" \\\\\\n + \\\"\\\\n\\\\nThis script should NOT be run DIRECTLY.\\\" \\\\\\n + \\\"\\\\n\\\\nPlease, import it in another script.\\\"\\n\\n cGUIf.show_warning(\\\"Import warning\\\",warning_message)\",\n \"def test_ensureWhenNotImported(self):\\n modules = {}\\n self.patch(sys, \\\"modules\\\", modules)\\n ensureNotImported([\\\"m1\\\", \\\"m2\\\"], \\\"A message.\\\", preventImports=[\\\"m1\\\", \\\"m2\\\", \\\"m3\\\"])\\n self.assertEqual(modules, {\\\"m1\\\": None, \\\"m2\\\": None, \\\"m3\\\": None})\",\n \"def no_additional_complaints() -> None:\\n logging.getLogger(\\\"asyncio\\\").setLevel(\\\"CRITICAL\\\")\\n warnings.simplefilter(\\\"ignore\\\")\",\n \"def missing_in_gyp_by_file(self):\\n return self._missing_gyp_files\",\n \"def _c_optimizations_ignored():\\n pure_env = os.environ.get('PURE_PYTHON')\\n return pure_env != \\\"0\\\" if pure_env is not None else PYPY\",\n \"def is_running_locally():\\n local = False\\n if \\\"POLYAXON_NO_OP\\\" in os.environ:\\n local = True\\n return local\",\n \"def is_not_used(self):\\n pass\",\n \"def has_errors_fatal(self) -> bool:\",\n \"def is_ipython():\\n return 'get_ipython' in globals()\",\n \"def _strict_warning(self):\\n if self.options.get('strict', True):\\n return ('Strict mode enabled (the default), so this could be due to an '\\n 'integer key, such as an HTTP status code.')\\n return ('Strict mode disabled. Prance cannot help you narrow this further '\\n 'down, sorry.')\",\n \"def _run_from_ipython():\\n try:\\n __IPYTHON__\\n return True\\n except NameError:\\n return False\",\n \"def disableIncorrectNameWarning(*args, **kwargs)->None:\\n pass\",\n \"def check_invalid_args_general(config):\\n # Not mathematically correct, but might be required if prior is not\\n # appropriate.\\n if hasattr(config, 'kl_scale') and config.kl_scale != 1.0:\\n warnings.warn('Prior matching term will be scaled by %f.'\\n % config.kl_scale)\\n\\n if hasattr(config, 'store_final_model') and \\\\\\n hasattr(config, 'train_from_scratch') and \\\\\\n config.store_final_model and config.train_from_scratch:\\n warnings.warn('Note, when training from scratch, the final model is ' +\\n 'only trained on the last task!')\",\n \"def has_nlu(self):\\n return self.metadata.has_been_coded_for(\\\"nlu\\\")\",\n \"def isIgnoredPkg(self, *args):\\n return _libsbml.SBMLDocument_isIgnoredPkg(self, *args)\",\n \"def test_ensureWhenNotImportedDontPrevent(self):\\n modules = {}\\n self.patch(sys, \\\"modules\\\", modules)\\n ensureNotImported([\\\"m1\\\", \\\"m2\\\"], \\\"A message.\\\")\\n self.assertEqual(modules, {})\",\n \"def test_import_allows_attributes_failure(self):\\n # We can just use existing modules for this.\\n name_map = {\\n \\\"sys\\\": (\\\"executable\\\", \\\"path\\\"),\\n \\\"builtins\\\": (\\\"list\\\", \\\"_qiskit_dummy_attribute_\\\"),\\n }\\n\\n feature = LazyImportTester(name_map)\\n self.assertFalse(feature)\",\n \"def filter_warnings():\\n warnings.simplefilter(\\\"ignore\\\", category=UserWarning)\\n warnings.simplefilter(\\\"ignore\\\", category=LightningDeprecationWarning)\",\n \"def test_suppress_import(self):\\n logging.info(\\\"testing suppress import\\\")\\n\\n generated_file = os.path.join(self._test_workspace,\\n \\\"generated.suppress\\\")\\n\\n extract_cmd = ['CodeChecker', 'parse',\\n os.path.join(self._test_workspace, \\\"reports\\\"),\\n \\\"--suppress\\\", generated_file,\\n \\\"--export-source-suppress\\\"\\n ]\\n\\n ret = call_cmd(extract_cmd,\\n self._test_project_path,\\n env.test_env(self._test_workspace))\\n self.assertEqual(ret, 2, \\\"Failed to generate suppress file.\\\")\\n\\n codechecker_cfg = env.import_test_cfg(\\n self._test_workspace)['codechecker_cfg']\\n\\n product_url = env.parts_to_url(codechecker_cfg)\\n import_cmd = ['CodeChecker', 'cmd', 'suppress', '-i', generated_file,\\n '--url', product_url, self._run_name]\\n\\n print(import_cmd)\\n ret = call_cmd(import_cmd,\\n self._test_project_path,\\n env.test_env(self._test_workspace))\\n self.assertEqual(ret, 0, \\\"Failed to import suppress file.\\\")\",\n \"def checkImport(self):\\r\\n for imp in self.cap_file.Import.packages:\\r\\n if a2s(imp.aid) not in export_refs:\\r\\n return False\\r\\n return True\",\n \"def setup_test():\\n if LooseVersion(np.__version__) >= LooseVersion('1.14'):\\n np.set_printoptions(legacy='1.13')\\n\\n # Temporary fix until scipy release in October 2018\\n # must be removed after that\\n # print the first occurrence of matching warnings for each location\\n # (module + line number) where the warning is issued\\n if (\\n LooseVersion(np.__version__) >= LooseVersion('1.15')\\n and LooseVersion(scipy.version.short_version) <= '1.1.0'\\n ):\\n warnings.simplefilter('default')\",\n \"def test_ImportError(n=2):\\n\\n p = bad_import()\\n\\n try:\\n p.result()\\n except ImportError:\\n print(\\\"Caught ImportError\\\")\\n else:\\n assert False, \\\"Raise the wrong Error\\\"\",\n \"def no_coverage_warn():\\n if covdb is None or len(covdb.coverage_files) == 0:\\n show_message_box(\\\"Need to Import Traces First\\\",\\n \\\"Can't perform this action yet, no traces have been imported\\\",\\n MessageBoxButtonSet.OKButtonSet,\\n MessageBoxIcon.ErrorIcon)\\n return True\\n return False\",\n \"def were_in_ipython():\\n shell = get_ipython()\\n if shell is None:\\n raise NotInIPythonError\\n else:\\n return True\",\n \"def test_absent_imports():\\n module, HABEMUS_MODULE = optional_import(\\\"not_real_module\\\")\\n\\n assert not HABEMUS_MODULE\\n assert module.__name__ == \\\"not_real_module\\\"\\n with pytest.raises(ModuleNotFoundError):\\n _ = module.layers\",\n \"def is_imported():\\n return len(inspect.stack()) > 3\",\n \"def test_missing_pypirc(self):\\n self.assertEqual(\\n package_manager.extra_pypi_index_servers('does not exist'),\\n [])\",\n \"def ignore_python_warnings(function):\\n\\n @functools.wraps(function)\\n def wrapped(*args, **kwargs):\\n \\\"\\\"\\\"\\n Wrapped function.\\n \\\"\\\"\\\"\\n\\n with warnings.catch_warnings():\\n warnings.simplefilter('ignore')\\n\\n return function(*args, **kwargs)\\n\\n return wrapped\",\n \"def check_for_unused_names(self):\\n for s in self.unused_names:\\n self.warning(\\\"'%s' is unused.\\\"%s)\\n\\n# warns for param that specified with -c (but also if name gets defined in __main__,\\n# e.g. by default_density=global_params.default_density in a script file\\n## for name in self.params():\\n## if name in self.context:\\n## self.warning(\\\"'%s' still exists in global_params.context\\\"%name)\\n\\n # detect duplicate param value that wasn't used (e.g. specified with after script)\\n for name,val in self.params().items():\\n if name in self.context:\\n if self.context[name]!=self.inspect_value(name):\\n self.warning(\\\"'%s=%s' is unused.\\\"%(name,self.context[name]))\",\n \"def test_ensureWhenFailedToImport(self):\\n modules = {\\\"m2\\\": None}\\n self.patch(sys, \\\"modules\\\", modules)\\n ensureNotImported([\\\"m1\\\", \\\"m2\\\"], \\\"A message.\\\", preventImports=[\\\"m1\\\", \\\"m2\\\"])\\n self.assertEqual(modules, {\\\"m1\\\": None, \\\"m2\\\": None})\",\n \"def load_numpy_distutils_misc_util(finder, module):\\n module.IgnoreName(\\\"numscons\\\")\",\n \"def check_imports():\\n try:\\n import dns # pylint: disable=C0415,W0611 # noqa: F401\\n import ecdsa # pylint: disable=C0415,W0611 # noqa: F401\\n import google.protobuf # pylint: disable=C0415,W0611 # noqa: F401\\n import jsonrpclib # pylint: disable=C0415,W0611 # noqa: F401\\n import pyaes # pylint: disable=C0415,W0611 # noqa: F401\\n import qrcode # pylint: disable=C0415,W0611 # noqa: F401\\n import requests # pylint: disable=C0415 # noqa: F401\\n except ImportError as i_e:\\n sys.exit(\\\"Error: %s. Try 'sudo pip install <module-name>'\\\" % str(i_e))\\n from google.protobuf import descriptor # pylint: disable=C0415,W0611 # noqa: F401\\n from google.protobuf import message # pylint: disable=C0415,W0611 # noqa: F401\\n from google.protobuf import reflection # pylint: disable=C0415,W0611 # noqa: F401\\n from google.protobuf import ( # pylint: disable=C0415,W0611 # noqa: F401\\n descriptor_pb2,\\n )\\n from jsonrpclib import ( # pylint: disable=C0415,W0611 # noqa: F401\\n SimpleJSONRPCServer,\\n )\\n\\n # make sure that certificates are here\\n certs = requests.utils.DEFAULT_CA_BUNDLE_PATH\\n if not os.path.exists(certs):\\n raise AssertionError(\\\"Certificates not found\\\")\",\n \"def test_LPyModelDriver_nolpy(): # pragma: no lpy\\n assert_raises(RuntimeError, LPyModelDriver.LPyModelDriver,\\n 'test', scripts['lpy'])\",\n \"def missing_in_gyp(self):\\n return self._missing_gyp_flags\",\n \"def __init__(self):\\n super().__init__(\\n \\\"This module requires installation of megnet, \\\"\\n \\\"which is not found in your current environment.\\\"\\n \\\"Please install it via `pip install megnet` or \\\"\\n \\\"via github source\\\"\\n )\",\n \"def _should_ignore_module(cls, module_name):\\n # exclude test modules for now to avoid spurious failures\\n # TODO(jelle): enable for test modules too\\n return module_name.split(\\\".\\\")[-1].startswith(\\\"test\\\")\",\n \"def modifyComponentsNotPreferableOnServer(self):\\n # Nothing to do\\n pass\",\n \"def ignore_warnings(my_func):\\n\\n def wrapper(self, *args, **kwargs):\\n \\\"\\\"\\\"\\n This is where the warning suppression occurs.\\n \\\"\\\"\\\"\\n if sys.version_info >= (3, 2):\\n warnings.simplefilter(\\\"ignore\\\", ResourceWarning)\\n with warnings.catch_warnings():\\n my_func(self, *args, **kwargs)\\n\\n return wrapper\",\n \"def missing_ltihooks(finder, caller):\\n caller.IgnoreName(\\\"ltihooks\\\")\",\n \"def no_prereq_install():\\n return str2bool(os.environ.get('NO_PREREQ_INSTALL', 'False'))\",\n \"def init_warnings():\\n warnings.simplefilter(\\\"ignore\\\", category=AstropyWarning)\",\n \"def discardedException( self, exc_stuff ):\\n extype = exc_stuff[0]\\n value = exc_stuff[1]\\n tb = exc_stuff[2]\\n if isJython :\\n # Misc intermediate ImportError exceptions may occur\\n # during Jython import we need to ignore them ; if a module can't be\\n # really imported a final ImportError will break the execution of the debuggee\\n # so it's safe to ignore ImportError for Jythn here\\n if issubclass(extype,ImportError) :\\n return True # discarded\\n return False\",\n \"def test_import_error_message_maintained(self):\\n settings = GrpcSettings({\\n 'INTERCEPTORS': [\\n ('tests.invalid_module.InvalidClassName', {})\\n ]\\n })\\n with self.assertRaises(ImportError):\\n _ = settings.INTERCEPTORS\",\n \"def run_from_ipython():\\n try:\\n __IPYTHON__\\n return True\\n except NameError:\\n return False\",\n \"def error_impresion(self):\\n self._info(\\\"error_impresion\\\")\",\n \"def requirement_missing(script):\\n if \\\"requires\\\" in script:\\n if script[\\\"requires\\\"] is None:\\n return False\\n for package in script[\\\"requires\\\"].split():\\n try:\\n pkg_resources.working_set.require(package)\\n except Exception:\\n return True\\n return False\",\n \"def allow_warnings(self):\\n return self._allow_warnings\",\n \"def not_installed(self) -> bool:\\n return pulumi.get(self, \\\"not_installed\\\")\",\n \"def _validate_running_as_fvalidation_exempt_user():\\n if acm.UserName() not in FValidation_settings.SUPERUSERS:\\n # Ensure that tool is run as a user exempt from FValidation\\n # in order to avoid GUI pop-ups when touching entities.\\n raise ValueError(\\\"This tool must be run by a user that is exempt from FValidation.\\\")\",\n \"def test_deprecated_private_variables(attr):\\n with pytest.warns(AstropyDeprecationWarning):\\n resolve_name(\\\"astropy\\\", \\\"cosmology\\\", \\\"flrw\\\", attr)\",\n \"def add_ignore_module(modules: List[Any]):\\n global BUILTIN_LIKELY_MODULES\\n for module in modules:\\n if module not in BUILTIN_LIKELY_MODULES:\\n BUILTIN_LIKELY_MODULES.append(module)\",\n \"def nfvi_compute_plugin_disabled():\\n return (_compute_plugin is None)\",\n \"def warning(self, *args, **kwargs):\",\n \"def check_stability(self):\",\n \"def add_warning_non_file(self, code: Code, msg: str,\\n is_persistant: bool = False) -> None:\\n self.add_error_non_file(code, msg, severity=Severity.WARNING,\\n is_persistant=is_persistant)\",\n \"def no_require():\\n from twill import commands\\n \\n l = commands.browser._post_load_hooks\\n l = [ fn for fn in l if fn != _require_post_load_hook ]\\n commands.browser._post_load_hooks = l\\n\\n global _requirements\\n _requirements = []\",\n \"def is_notebook():\\n return \\\"ipykernel\\\" in sys.modules\",\n \"def detect_import(self):\\n if self.contains_match(CONTAINS_IMPORT): self.es6import = True\\n elif self.contains_match(CONTAINS_REQUIRE): self.es6import = False\\n else: self.es6import = self.get_project_pref('detect_prefer_imports')\",\n \"def _set_insufficient_confidence_warning(\\n self): # pragma: no cover\\n self.failed_initial_confidence = True\\n self.surface_result('LO_INIT_CONF')\\n self.warnings.append(\\n 'Bisect failed to reproduce the regression with enough confidence.')\",\n \"def test_check_model_dependencies_missing_warning(dependency_testing_model, complete_env) -> None:\\n incomplete_env = Python(\\n [r for r in complete_env.requirements if r not in ['PyYAML==0.0.1', 'pandas==0.0.1']]\\n ) # drop a single dependency to be caught\\n with warnings.catch_warnings(record=True) as caught_warnings:\\n assert not check_model_dependencies(\\n model_cls=dependency_testing_model,\\n environment=incomplete_env,\\n raise_for_missing=False,\\n )\\n warn_msg = caught_warnings[0].message.args[0]\\n assert warn_msg == \\\"the following packages are required by the model but missing \\\" \\\\\\n \\\"from the environment:\\\\npandas (installed via ['pandas'])\\\" \\\\\\n \\\"\\\\nyaml (installed via ['PyYAML'])\\\"\",\n \"def has_err_warn(self):\\r\\n return self._arm.has_err_warn\",\n \"def test_import_nothandled():\\n sys.meta_path.append(TaskImporter())\\n with pytest.raises(ImportError):\\n import_module('not.exist')\",\n \"def unsure_how_to_install(self):\\n msg = \\\"Unsure how to install {0}.\\\".format(self.name)\\n if self.info_uri:\\n msg += \\\"\\\\nRefer to {0} for information\\\".format(self.info_uri)\\n\\n if platform.system() == 'Darwin':\\n if 'brew' in self._provider_package and not helpers['brew']:\\n msg += (\\\"\\\\nCOT can use Homebrew (https://brew.sh), \\\"\\n \\\"if available on your system, to install {0}.\\\"\\n .format(self.name))\\n if 'port' in self._provider_package and not helpers['port']:\\n msg += (\\\"\\\\nCOT can use MacPorts (https://www.macports.org/), \\\"\\n \\\"if available on your system, to install {0}.\\\"\\n .format(self.name))\\n if ('brew' in self._provider_package or\\n 'port' in self._provider_package):\\n return RuntimeError(msg)\\n else:\\n return NotImplementedError(msg)\\n elif platform.system() == 'Linux' and (\\n ('apt-get' in self._provider_package or\\n 'yum' in self._provider_package) and\\n not (helpers['apt-get'] or helpers['yum'])):\\n msg += (\\\"\\\\nCOT can use package managers 'yum' or 'apt-get' to\\\"\\n \\\" install helpers on your system, but it appears that\\\"\\n \\\" you have neither of these package managers?\\\")\\n return RuntimeError(msg)\\n else:\\n return NotImplementedError(msg)\",\n \"def _warn(msg):\\n warnings.warn(msg, TessyWarning, stacklevel=3)\",\n \"def check_no_silent_crash(self, override=False):\\n if self.results:\\n score = self.results.linter.stats.get('global_note', False)\\n if score is False:\\n messages = self.results.linter.stats.get('by_msg', {})\\n if messages.get('syntax-error', False) and not override:\\n self.logging.warning('\\\\n------------------------------------------------------------------')\\n self.logging.warning('PYLINT FAILED BECAUSE SYNTAX ERROR.')\\n self.logging.warning('------------------------------------------------------------------')\\n self.logging.warning('\\\\n')\\n self.failed_files.append(self.fname)\\n return False\\n self.logging.info('\\\\n------------------------------------------------------------------')\\n self.logging.info('FILE WAS IGNORED.')\\n self.logging.info('------------------------------------------------------------------')\\n return True\\n return False\",\n \"def test_noexceptions(nb_path, tmpdir):\\n nb = load_notebook(nb_path)\\n pyfile = \\\"%s.py\\\" % str(\\n tmpdir.join(os.path.splitext(os.path.basename(nb_path))[0]))\\n export_py(nb, pyfile)\\n execfile(pyfile, {})\",\n \"def test_deprecated_modules(self):\\n\\n deprecated_modules_present = False\\n\\n deprecated_modules = [\\n \\\"game_assets\\\",\\n \\\"models\\\",\\n \\\"world\\\",\\n \\\"modular_assets\\\",\\n ]\\n\\n for path in self.application_files:\\n for module in deprecated_modules:\\n module_text = open(path).read()\\n found_reference = False\\n if \\\"import %s\\\" % module in module_text:\\n found_reference = True\\n if \\\"from %s\\\" % module in module_text:\\n found_reference = True\\n\\n if found_reference:\\n print(\\\"Found '%s' reference in %s\\\" % (module, path))\\n deprecated_modules_present = True\\n\\n self.assertFalse(deprecated_modules_present)\",\n \"def has_off_hook_warning(self) -> bool:\",\n \"def CheckNoBannedFunctions(input_api, output_api):\\n warnings = []\\n\\n def GetMessageForFunction(input_api, affected_file, line_num, line, func_name,\\n message):\\n result = []\\n if input_api.re.search(r\\\"^ *//\\\", line): # Ignore comments.\\n return result\\n if line.endswith(\\\" nocheck\\\"): # Ignore lines with nocheck comments.\\n return result\\n\\n if func_name in line:\\n result.append(' %s:%d:' % (affected_file.LocalPath(), line_num))\\n for message_line in message:\\n result.append(' %s' % message_line)\\n\\n return result\\n\\n\\n file_filter = lambda f: f.LocalPath().endswith(('.cc', '.mm', '.h'))\\n for f in input_api.AffectedFiles(file_filter=file_filter):\\n for line_num, line in f.ChangedContents():\\n for func_name, message in _BANNED_CPP_FUNCTIONS:\\n problems = GetMessageForFunction(input_api, f, line_num, line,\\n func_name, message)\\n if problems:\\n warnings.extend(problems)\\n\\n result = []\\n if (warnings):\\n result.append(output_api.PresubmitPromptWarning(\\n 'Banned functions were used.\\\\n' + '\\\\n'.join(warnings)))\\n return result\",\n \"def check_for_underscore(self):\\n # If something injected a '_' variable in __builtin__, delete\\n # ipython's automatic one so we don't clobber that. gettext() in\\n # particular uses _, so we need to stay away from it.\\n if '_' in __builtin__.__dict__:\\n try:\\n del self.shell.user_ns['_']\\n except KeyError:\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59475875","0.5733747","0.5700879","0.56831914","0.56009203","0.5547987","0.54913825","0.5431076","0.5426784","0.53830874","0.53597766","0.53400105","0.53313553","0.53298444","0.52693295","0.5264683","0.5247983","0.5241664","0.5224841","0.5179244","0.5177511","0.5171002","0.51662105","0.5145082","0.5107308","0.5099041","0.5096394","0.5096328","0.5078653","0.5074061","0.5054752","0.5033172","0.5029847","0.5026492","0.50252444","0.5017961","0.50152206","0.5011554","0.50023377","0.5001105","0.49909812","0.49841407","0.49789426","0.49720275","0.49714416","0.49711275","0.49626094","0.4947703","0.4932984","0.49321315","0.49293733","0.4918651","0.49062544","0.489819","0.4896423","0.48954844","0.48877853","0.48831964","0.4881329","0.48712847","0.48639172","0.4861478","0.48554665","0.48434925","0.48408797","0.48392335","0.48379812","0.48349783","0.48201376","0.48159823","0.48109084","0.4810497","0.48070475","0.4804283","0.47945318","0.4786666","0.4775008","0.47696596","0.4766923","0.47640958","0.476246","0.47576","0.47484392","0.47471544","0.4732011","0.47281012","0.472802","0.47191772","0.47189903","0.4717881","0.47144753","0.4711507","0.471103","0.4704807","0.47038782","0.4699514","0.46963176","0.46950102","0.46922806","0.46902224"],"string":"[\n \"0.59475875\",\n \"0.5733747\",\n \"0.5700879\",\n \"0.56831914\",\n \"0.56009203\",\n \"0.5547987\",\n \"0.54913825\",\n \"0.5431076\",\n \"0.5426784\",\n \"0.53830874\",\n \"0.53597766\",\n \"0.53400105\",\n \"0.53313553\",\n \"0.53298444\",\n \"0.52693295\",\n \"0.5264683\",\n \"0.5247983\",\n \"0.5241664\",\n \"0.5224841\",\n \"0.5179244\",\n \"0.5177511\",\n \"0.5171002\",\n \"0.51662105\",\n \"0.5145082\",\n \"0.5107308\",\n \"0.5099041\",\n \"0.5096394\",\n \"0.5096328\",\n \"0.5078653\",\n \"0.5074061\",\n \"0.5054752\",\n \"0.5033172\",\n \"0.5029847\",\n \"0.5026492\",\n \"0.50252444\",\n \"0.5017961\",\n \"0.50152206\",\n \"0.5011554\",\n \"0.50023377\",\n \"0.5001105\",\n \"0.49909812\",\n \"0.49841407\",\n \"0.49789426\",\n \"0.49720275\",\n \"0.49714416\",\n \"0.49711275\",\n \"0.49626094\",\n \"0.4947703\",\n \"0.4932984\",\n \"0.49321315\",\n \"0.49293733\",\n \"0.4918651\",\n \"0.49062544\",\n \"0.489819\",\n \"0.4896423\",\n \"0.48954844\",\n \"0.48877853\",\n \"0.48831964\",\n \"0.4881329\",\n \"0.48712847\",\n \"0.48639172\",\n \"0.4861478\",\n \"0.48554665\",\n \"0.48434925\",\n \"0.48408797\",\n \"0.48392335\",\n \"0.48379812\",\n \"0.48349783\",\n \"0.48201376\",\n \"0.48159823\",\n \"0.48109084\",\n \"0.4810497\",\n \"0.48070475\",\n \"0.4804283\",\n \"0.47945318\",\n \"0.4786666\",\n \"0.4775008\",\n \"0.47696596\",\n \"0.4766923\",\n \"0.47640958\",\n \"0.476246\",\n \"0.47576\",\n \"0.47484392\",\n \"0.47471544\",\n \"0.4732011\",\n \"0.47281012\",\n \"0.472802\",\n \"0.47191772\",\n \"0.47189903\",\n \"0.4717881\",\n \"0.47144753\",\n \"0.4711507\",\n \"0.471103\",\n \"0.4704807\",\n \"0.47038782\",\n \"0.4699514\",\n \"0.46963176\",\n \"0.46950102\",\n \"0.46922806\",\n \"0.46902224\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5077109"},"document_rank":{"kind":"string","value":"29"}}},{"rowIdx":5497,"cells":{"query":{"kind":"string","value":"Tire l'objectif d'une partie de chiffre."},"document":{"kind":"string","value":"def tire_objectif() -> int:\n return random.randint(min_objectif, max_objectif)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def object(self):","def test_partie(joueur1: object,\n joueur2: object,\n tableau_invisible_joueur1: list, tableau_invisible_joueur2: list\n ):\n print(\"plateau du joueur 2 : \\n\")\n\n tour_de_jeu(joueur1, joueur2, tableau_invisible_joueur2)\n\n rafraichir_position(joueur2, joueur2.porte_avion)\n verif_bateau(joueur1, joueur2.porte_avion)\n\n print(\"plateau du joueur 1 : \\n\")\n tour_de_jeu(joueur2, joueur1, tableau_invisible_joueur1)\n\n rafraichir_position(joueur1, joueur1.porte_avion)\n verif_bateau(joueur2, joueur1.porte_avion)","def petite_partie(joueur1: object,\n joueur2: object,\n tableau_invisible_joueur1: list, tableau_invisible_joueur2: list\n ):\n print(\"plateau du joueur 2 : \\n\")\n\n tour_de_jeu(joueur1, joueur2, tableau_invisible_joueur2)\n\n rafraichir_position(joueur2, joueur2.porte_avion, joueur2.torpilleur, joueur2.croiseur)\n verif_bateau(joueur1, joueur2.porte_avion, joueur2.torpilleur, joueur2.croiseur)\n\n print(\"plateau du joueur 1 : \\n\")\n tour_de_jeu(joueur2, joueur1, tableau_invisible_joueur1)\n\n rafraichir_position(joueur1, joueur1.porte_avion, joueur1.torpilleur, joueur1.croiseur)\n verif_bateau(joueur2, joueur1.porte_avion, joueur1.torpilleur, joueur1.croiseur)","def mezclar_bolsa(self):","def grande_partie(joueur1: object, joueur2: object,\n tableau_invisible_joueur1: list, tableau_invisible_joueur2: list,\n ):\n print(\"plateau du joueur 2 : \\n\")\n\n tour_de_jeu(joueur1, joueur2, tableau_invisible_joueur2)\n\n rafraichir_position(joueur2, joueur2.porte_avion, joueur2.torpilleur, joueur2.croiseur, joueur2.canonniere,\n joueur2.destroyer)\n verif_bateau(joueur1, joueur2.porte_avion, joueur2.torpilleur, joueur2.croiseur, joueur2.canonniere,\n joueur2.destroyer)\n\n print(\"plateau du joueur 1 : \\n\")\n tour_de_jeu(joueur2, joueur1, tableau_invisible_joueur1)\n\n rafraichir_position(joueur1, joueur1.porte_avion, joueur1.torpilleur, joueur1.croiseur, joueur1.canonniere,\n joueur1.destroyer)\n verif_bateau(joueur2, joueur1.porte_avion, joueur1.torpilleur, joueur1.croiseur, joueur1.canonniere,\n joueur1.destroyer)","def objects(self):","def copier(partie):\n # Instanciation d'une nouvelle partie\n partie_copiee = Partie()\n\n for tour in partie.tours:\n tour_tmp = Tour(tour.x, tour.y) # Instanciation d'un tour\n partie_copiee.nouveau_tour(tour_tmp) # Ajout du tour\n\n return partie_copiee","def __init__(self, partie):\n self.ID = 0\n self.nbr_noeuds = 1\n self.nbr_feuilles = 1\n self.partie = partie\n self.nbr_fils = 0\n self.fils = []","def sketch_und_part(self):\n if (self.dimension == '3D'):\n #Sketch Wuerfel zeichnen\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\n name='Seitenansicht_Wuerfel',\n sheetSize=200.0)\n self.sketch_Wuerfel.rectangle(\n point1=(-self.laenge_x/2.0, -self.laenge_y/2.0),\n point2=(self.laenge_x/2.0, self.laenge_y/2.0))\n #Part Wuerfel generieren\n self.part_Wuerfel = self.model.Part(\n name=self.name+'_Wuerfel',\n dimensionality=THREE_D,\n type=DEFORMABLE_BODY)\n self.part_Wuerfel.BaseSolidExtrude(\n sketch=self.sketch_Wuerfel,\n depth=self.laenge_z/2.0) #z-Symmetrie\n #Sketch Pore zeichnen (fuer Quader und Zylinder)\n self.sketch_Pore = self.model.ConstrainedSketch(\n name='Seitenansicht_Pore',\n sheetSize=200.0)\n if (self.typ_Pore == 'Quader'):\n self.sketch_Pore.rectangle(\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Zylinder'):\n self.sketch_Pore.EllipseByCenterPerimeter(\n center=(0.0, 0.0),\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\n axisPoint2=(0.0, self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Ellipsoid' ):\n matlab.ellipsoidIgesOut(\n self.porenparameter_x,\n self.porenparameter_y,\n self.porenparameter_z,\n 'Ellipsoid')\n # if (self.porenparameter_x == self.porenparameter_z):\n # self.sketch_Pore.ConstructionLine(\n # point1=(0.0, -100.0),\n # point2=(0.0, 100.0))\n # self.sketch_Pore.EllipseByCenterPerimeter(\n # center=(0.0, 0.0),\n # axisPoint1=(self.porenparameter_x/2.0, 0.0),\n # axisPoint2=(0.0, self.porenparameter_y/2.0))\n # self.sketch_Pore.autoTrimCurve(\n # curve1=self.sketch_Pore.geometry[3],\n # point1=(-self.porenparameter_x/2.0, 0.0))\n # self.sketch_Pore.Line(\n # point1=(0.0, self.porenparameter_y/2.0),\n # point2=(0.0, -self.porenparameter_y/2.0))\n else:\n print('typ_Pore Error!')\n #Part Pore generieren\n if (self.typ_Pore == 'Ellipsoid' ):\n # if (self.porenparameter_x == self.porenparameter_z):\n # self.part_Pore.BaseSolidRevolve(\n # sketch=self.sketch_Pore,\n # angle=360.0,\n # flipRevolveDirection=OFF)\n self.iges_Datei = mdb.openIges(\n 'Ellipsoid.igs',\n msbo=False,\n trimCurve=DEFAULT,\n scaleFromFile=OFF)\n self.model.PartFromGeometryFile(\n name=self.name+'_Pore',\n geometryFile=self.iges_Datei,\n combine=False,\n stitchTolerance=1.0,\n dimensionality=THREE_D,\n type=DEFORMABLE_BODY,\n convertToAnalytical=1,\n stitchEdges=1,\n scale=1) # Skalierung\n self.part_Pore = self.model.parts[self.name+'_Pore']\n self.part_Pore.AddCells(\n faceList = self.part_Pore.faces,\n flipped=False)\n del self.iges_Datei\n os.remove('abaqus_read_iges0.log') #Arbeitsordner aufraeumen\n os.remove('temp-Ellipsoid-new.sat')\n os.remove('Ellipsoid.igs')\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\n self.part_Pore = self.model.Part(\n name=self.name+'_Pore',\n dimensionality=THREE_D,\n type=DEFORMABLE_BODY)\n self.part_Pore.BaseSolidExtrude(\n sketch=self.sketch_Pore,\n depth=self.porenparameter_z)\n #Assemble\n self.assembly = self.model.rootAssembly\n self.assembly.DatumCsysByDefault(CARTESIAN)\n self.assembly.Instance(\n name=self.name+'_Pore',\n part=self.part_Pore,\n dependent=ON)\n self.assembly.Instance(\n name=self.name+'_Wuerfel',\n part=self.part_Wuerfel,\n dependent=ON)\n #Translation\n self.assembly.translate(\n instanceList=(self.name+'_Wuerfel', ),\n vector=(0.0, 0.0, -self.laenge_z/2.0))\n if (self.typ_Pore == 'Ellipsoid'):\n self.assembly.translate(\n instanceList=(self.name+'_Pore', ),\n vector=(0.0, 0.0, 0.0))\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\n self.assembly.translate(\n instanceList=(self.name+'_Pore', ),\n vector=(0.0, 0.0, -self.porenparameter_z/2.0))\n #Rotation\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, 0.0),\n axisDirection=(1.0, 0.0, 0.0),\n angle=self.porenparameter_rx)\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, 0.0),\n axisDirection=(0.0, 1.0, 0.0),\n angle=self.porenparameter_ry)\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, 0.0),\n axisDirection=(0.0, 0.0,1.0),\n angle=self.porenparameter_rz)\n #Schneiden\n self.assembly.InstanceFromBooleanCut(\n name='RVE',\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\n originalInstances=SUPPRESS)\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\n # del self.model.parts[self.name+'_Wuerfel']\n # del self.model.parts[self.name+'_Pore']\n self.part_RVE = self.model.parts[self.name]\n elif (self.dimension == '2D'):\n #Sketch Wuerfel zeichnen\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\n name='Seitenansicht_Wuerfel',\n sheetSize=200.0)\n self.sketch_Wuerfel.rectangle(\n point1=(0.0, 0.0),\n point2=(self.laenge_x/2.0, self.laenge_y/2.0)) #x- und y-Symmetrie\n #Part Wuerfel generieren\n self.part_Wuerfel = self.model.Part(\n name=self.name+'_Wuerfel',\n dimensionality=TWO_D_PLANAR,\n type=DEFORMABLE_BODY)\n self.part_Wuerfel.BaseShell(sketch=self.sketch_Wuerfel)\n #Sketch Pore zeichnen\n self.sketch_Pore = self.model.ConstrainedSketch(\n name='Seitenansicht_Pore',\n sheetSize=200.0)\n if (self.typ_Pore == 'Ellipsoid'):\n self.sketch_Pore.ConstructionLine(\n point1=(0.0, -100.0),\n point2=(0.0, 100.0))\n self.sketch_Pore.EllipseByCenterPerimeter(\n center=(0.0, 0.0),\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\n axisPoint2=(0.0, self.porenparameter_y/2.0))\n self.sketch_Pore.autoTrimCurve(\n curve1=self.sketch_Pore.geometry[3],\n point1=(-self.porenparameter_x/2.0, 0.0))\n self.sketch_Pore.Line(\n point1=(0.0, self.porenparameter_y/2.0),\n point2=(0.0, -self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Quader'):\n self.sketch_Pore.rectangle(\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Zylinder'):\n self.sketch_Pore.EllipseByCenterPerimeter(\n center=(0.0, 0.0),\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\n axisPoint2=(0.0, self.porenparameter_y/2.0))\n else:\n print('typ_Pore Error!')\n #Part Pore generieren\n self.part_Pore = self.model.Part(\n name=self.name+'_Pore',\n dimensionality=TWO_D_PLANAR,\n type=DEFORMABLE_BODY)\n self.part_Pore.BaseShell(sketch=self.sketch_Pore)\n #Assemble\n self.assembly = self.model.rootAssembly\n self.assembly.DatumCsysByDefault(CARTESIAN)\n self.assembly.Instance(\n name=self.name+'_Wuerfel',\n part=self.part_Wuerfel,\n dependent=ON)\n self.assembly.Instance(\n name=self.name+'_Pore',\n part=self.part_Pore,\n dependent=ON)\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, self.laenge_z/2.0),\n axisDirection=(0.0, 0.0, self.laenge_z/2.0+1),\n angle=self.porenparameter_rz)\n self.assembly.InstanceFromBooleanCut(\n name='RVE',\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\n originalInstances=SUPPRESS)\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\n del self.model.parts[self.name+'_Wuerfel']\n #del self.model.parts[self.name+'_Pore']\n self.part_RVE = self.model.parts[self.name]\n else:\n print('dimension Error!')","def get_contenu(self):\n return self.objets","def objectFields(self):\n raise NotImplementedError","def retirer_objet(self, nom_membre):\n membre = self.get_membre(nom_membre)\n objet = membre.tenu\n membre.tenu = None","def test_get_part(self):\n pass","def algoritmo(posicionInicial):\n\tglobal vertices, lados\n\n\t# Inicio el algoritmo QuickHull y almacenare el resultado en vertices\n\tconvex = quickHull.QuickHull(posicionInicial)\n\tvertices = convex.quickHull(verticesObjeto)\n\tprint(\"\\nVertices en la envolvente convexa:\\n\")\n\tfor vertex in (vertices):\n\t\tprint(vertex)\n\n\t# creo la lista de lados a partir del los vertices de la envolvente\n\tlados = creaLados(vertices)\n\n\t# creo la maya y el objeto\n\tmi_mesh = bpy.data.meshes.new(nombre)\n\tmi_objeto = bpy.data.objects.new(nombre, mi_mesh)\n\n\t# coloco el objeto en la misma posicion en la que estaba el objeto\n\t# anteriormente seleccionado.\n\tmi_objeto.location = posicionInicial\n\n\t# enlazo el objeto a la escena\n\tbpy.context.scene.objects.link(mi_objeto)\n\n\t# creo el la maya del objeto\n\tmi_mesh.from_pydata(vertices,lados,caras)\n\tmi_mesh.update(calc_edges=True)","def NuevaPartida(self,):\n\t\"\"\" Numeros Disponibles \"\"\"\n\tDisponibles[0] = True\n\tDisponibles[1] = True\n\tDisponibles[2] = True\n\tDisponibles[3] = True\n\tDisponibles[4] = True\n\tDisponibles[5] = True\n\t\"\"\" Jugador Uno \"\"\"\n\tJ1[0] = 0\n\tJ1[1] = 0\n\tJ1[2] = 0\n\tJ1[3] = 0\n\tJ1[4] = 0\n\tJ1[5] = 0\n\t\"\"\" Jugador Dos \"\"\"\n\tJ2[0] = 0\n\tJ2[1] = 0\n\tJ2[2] = 0\n\tJ2[3] = 0\n\tJ2[4] = 0\n\tJ2[5] = 0\n\t\"\"\" Jugador Tres \"\"\"\n\tJ3[0] = 0\n\tJ3[1] = 0\n\tJ3[2] = 0\n\tJ3[3] = 0\n\tJ3[4] = 0\n\tJ3[5] = 0\n\t\"\"\" Jugador Cuatro \"\"\"\n\tJ4[0] = 0\n\tJ4[1] = 0\n\tJ4[2] = 0\n\tJ4[3] = 0\n\tJ4[4] = 0\n\tJ4[5] = 0","def tenir_objet(self, nom_membre=None, objet=None):\n if nom_membre:\n membre = self.get_membre(nom_membre)\n else:\n membre = None\n for m in self.membres:\n if m.tenu is None and m.peut_tenir():\n membre = m\n break\n\n if membre is None:\n raise ValueError(\"aucun membre n'est disponible\")\n\n if membre.tenu:\n raise ValueError(\"le membre {} tient déjà l'objet {} \".format(\n nom_membre, membre.tenu))\n\n if objet is None:\n raise ValueError(\"l'objet passé en paramètre est None. Pour \" \\\n \"retirer un objet tenu, utilisez la méthode retirer_objet\")\n\n membre.tenu = objet\n objet.contenu = self.tenus","def moi(self):\n\n pass","def nouvellePartie(self):\n for i in range(0, 3):\n for j in range(0, 3):\n self.partie.uplateau[i, j].initialiser()\n self.canvas_uplateau[i, j].delete('pion')\n self.afficher_message(\" Nouvelle Partie\")","def __init__(self, folder):\n print \"folder passed is \", folder\n self.folder = folder\n self.geometry = gf.geometry(self.folder)\n self.elements = gf.dictionary_set()\n self.area = np.zeros(shape = (8))\n self.Vol = (self.geometry.properties['span_number']*(self.geometry.properties['span_width']*\n self.geometry.properties['span_height'] + self.geometry.properties['cover_height']\n *self.geometry.properties['span_width']/2))\n self.F = np.zeros(shape = (8, 8))\n of.view_factor(self.geometry, self.F, self.area, self.Vol)\n tran = [self.geometry.properties['tra_cover_out'],0.0,0.0,\n self.geometry.properties['tra_sidewall_out'],\n self.geometry.properties['tra_cover_in'],\n self.geometry.properties['tra_sidewall_in'],0.0,0.0]\n emi = [self.geometry.properties['emi_cover_out'],1.0,1.0,\n self.geometry.properties['emi_sidewall_out'],\n self.geometry.properties['emi_cover_in'],\n self.geometry.properties['emi_sidewall_in'],1.0,1.0] \n self.tr, self.em, self.re = of.optictal_prop(tran,emi)\n if ((self.tr + self.em).any() > 1.0):\n print \"error in optical properties\"\n self.T = np.zeros(shape = (2,10))\n self.RH = np.zeros(shape = (2,10))\n # 8 inside,9 outside \n self.qcond = np.zeros(shape = (2,8))\n self.qconv = np.zeros(shape = (2,8))\n self.qrad = np.zeros(shape = (2,8))\n self.j = np.zeros(shape = (2,8))\n self.g = np.zeros(shape = (2,8))\n self.alpha = np.zeros(shape = (2,8))\n deltaT = 300\n RH_in = 0.6\n fg.set_initial_conditions(self.geometry.properties['t_air_inside'],\n 278,\n RH_in,self.T,self.RH , self.geometry.properties['t_air'],self.g,\n self.geometry.properties['sky_temp'])\n self.T, self.j, self.g, self.alpha, self.qrad, self.qconv = fg.solver_T(self.T,self.qrad,self.qconv,self.alpha,self.j,self.g,self.em,self.tr,\n self.geometry.properties['wind_speed'],\n self.F,self.geometry.properties['heat_flux'],1,1.0,self.area,\n self.geometry.properties['rho'],self.geometry.properties['cp'],\n self.Vol,self.geometry.properties['degree_window'],deltaT)","def presenetCar():","def lancement_partie(joueur1: object, joueur2: object,\n tableau_invisible_joueur1: list, tableau_invisible_joueur2: list,\n number_of_ships: int):\n # Victoire devient True quand un joueur détruit tout les bateaux adverse\n victoire = False\n # PHASE 1 PLACEMENT BATEAU\n\n positionner_bateau(joueur1, number_of_ships)\n positionner_bateau(joueur2, number_of_ships)\n\n # PHASE 2 VERIFICATION DE L ETAT DES BATEAUX\n while not victoire:\n\n if number_of_ships == 3:\n petite_partie(joueur1, joueur2, tableau_invisible_joueur1, tableau_invisible_joueur2)\n\n elif number_of_ships == 1:\n test_partie(joueur1, joueur2, tableau_invisible_joueur1, tableau_invisible_joueur2)\n\n elif number_of_ships == 5:\n grande_partie(joueur1,\n joueur2,\n tableau_invisible_joueur1, tableau_invisible_joueur2,\n )\n\n if verif_win(joueur2, number_of_ships):\n victoire = True\n print(\"le joueur 1 a gagné\")\n\n if verif_win(joueur1, number_of_ships):\n victoire = True\n print(\"le joueur 2 a gagné\")\n\n envoi_score(joueur1, joueur2)\n afficher_score(joueur1, joueur2)","def __init__(self,obj):\n self.nature_libelle = obj['NatureLibelle']\n self.ins_nom = obj['InsNom']\n self.ins_numero_install = obj['InsNumeroInstall']\n self.equipement_id = obj['EquipementId']","def run_choucas(self):\n \n if self.dlg.cb_fondcarte.isChecked():\n # On affiche un fond de carte de la France par défaut\n # S'il n'est pas déjà afficher\n estAffiche = False\n for lyr in QgsMapLayerRegistry.instance().mapLayers().values():\n if lyr.name() == \"France\":\n estAffiche = True\n break \n if not estAffiche :\n uri = os.path.join(os.path.dirname(__file__) + str('/resources/fond_de_carte/france/'),'France.shp')\n #fond_path = ':/plugins/PluginChoucas/fond_de_carte/France.shp'\n \n vlayer = QgsVectorLayer(uri, \"France\", \"ogr\")\n # symbol = QgsMarkerSymbolV2.createSimple({'name': '', 'color': 'land' })\n # vlayer.rendererV2().setSymbol(symbol)\n QgsMapLayerRegistry.instance().addMapLayer(vlayer) \n \n \n # On recupere l'emprise selectionee\n selectedEmpriseIndex = self.dlg.comboEmprise.currentIndex()\n selectedEmprise = self.cleEmprise[selectedEmpriseIndex]\n tabCleEmprise = selectedEmprise.split(\"#\")\n \n if self.dlg.comboEmprise.count() == 0:\n typeemprise = ''\n codeemprise = ''\n else:\n typeemprise = tabCleEmprise[0]\n codeemprise = tabCleEmprise[1]\n \n \n # On recupere la source selectionee\n selectedSourceIndex = self.dlg.comboSources.currentIndex()\n selectedSource = self.list_sources[selectedSourceIndex]\n self.source = selectedSource\n \n # On recupere l entite selectionee\n selectedEntityIndex = self.dlg.comboEntities.currentIndex()\n selectedEntity = self.list_entities[selectedEntityIndex]\n self.entity = selectedEntity\n \n # On definit le proxy\n util.chargeProxy(self.dlg.cb_proxy)\n \n # On calcule la bbox\n # Ecrins\n projection = util.get_first_object(self.root, self.source, 'projection')\n empriseSelect = util.get_first_object(self.root, self.source, 'emprise')\n # print (\"emprise catalogue pour la source \" + self.source + \" = \" + empriseSelect)\n if empriseSelect == 'none':\n card = None\n else:\n card = bbox.getBbox(typeemprise, codeemprise, projection)\n\n style = {}\n style['couleur'] = util.get_first_object(self.root, self.source, 'couleur')\n style['svg'] = util.get_second_object(self.root, self.source, self.entity, 'svg')\n style['size'] = util.get_second_object(self.root, self.source, self.entity, 'size')\n style['forme'] = util.get_second_object(self.root, self.source, self.entity, 'forme')\n \n typeGeom = util.get_second_object(self.root, self.source, self.entity, 'geom')\n urlQGis = typeGeom + '?crs=' + projection\n\n # Si le mode choisi est [En ligne]\n if self.dlg.rb_online.isChecked():\n \n # On recupere dans le catalogue \n flux = util.get_first_object(self.root, self.source, 'flux')\n if flux == 'API':\n urlBrute = util.get_second_object(self.root, self.source, self.entity, 'url')\n else:\n urlBrute = ''\n \n attributs = util.get_attributs(self.root, self.source, self.entity)\n \n nomLayer = self.source + '-' + self.entity + '-' + codeemprise\n \n if self.source == 'osm':\n \n filtres = util.getFiltres(self.root, self.source, self.entity)\n osm.loadOSM(nomLayer, card, filtres, attributs, style)\n \n elif self.source == 'rando.ecrins-parcnational.fr' and typeGeom == 'Point':\n \n geotrek.loadPointEcrin(style)\n \n # QMessageBox.information(None, \"OUPS:\", \n # 'Departement non disponible pour cet API')\n else:\n if card == None:\n url = urlBrute\n else:\n # Par BBOX\n url = online.getUrlWithBBox(card, urlBrute)\n # On ajoute la couche\n online.displayLayer(url, urlQGis, self.source, nomLayer, typeGeom, attributs, style)\n \n # Si le mode choisi est [Hors ligne]\n if self.dlg.rb_offline.isChecked():\n offline.offline(self.root, self.source, self.entity)\n \n if self.dlg.rb_local.isChecked():\n \n urlBrute = util.get_second_object(self.root, self.source, self.entity, 'url')\n nomLayer = self.source + '-' + self.entity + '-' + codeemprise\n # On prend tous les attribts quand c'est un fichier\n local.loadPoint(nomLayer, urlBrute, urlQGis, card, style)","def perimeter(self):","def calculatePieces(self):\n pass;","def obj(self) -> object:\n pass","def get_objects_data(self):\n pass","def _target_filter(self, obj):\r\n return type(obj).__name__ in ['Cube'] and not obj.is_grasped # List because may be extended to other objects.\r","def post_init(self):\n val = get_constant(\"pi_invention.pieces_a_joindre\")\n pieces_a_joindre = FieldSet(\"pieces_a_joindre\", \"Pièces à joindre\", [HTML(val)])\n self.fieldsets += [pieces_a_joindre]\n\n conditions = get_constant(\"pi_invention.conditions\")\n self.conditions = conditions","def auto_rivet():\n sel_list = pm.ls(sl=1)\n\n # the last selection is the mesh\n objects = sel_list[:-1]\n geo = sel_list[-1]\n\n # get the closest point to the surface\n geo_shape = geo.getShape()\n\n follicles = []\n\n for obj in objects:\n # pivot point of the obj\n pivot = obj.getRotatePivot(space='world')\n uv = geo_shape.getUVAtPoint(pivot, space='world')\n\n # create a hair follicle\n follicle = pm.nt.Follicle()\n follicles.append(follicle)\n follicle.simulationMethod.set(0)\n geo_shape.worldMatrix >> follicle.inputWorldMatrix\n geo_shape.outMesh >> follicle.inputMesh\n follicle.parameterU.set(uv[0])\n follicle.parameterV.set(uv[1])\n\n # parent the object to the follicles transform node\n follicle_transform = follicle.getParent()\n\n follicle.outTranslate >> follicle_transform.translate\n follicle.outRotate >> follicle_transform.rotate\n\n pm.parent(obj, follicle_transform)\n\n return follicles","def visible_objects_and_duplis():\n\n for obj in context.visible_objects:\n if obj.type == 'MESH':\n if obj.modeling_cloth: \n yield (obj, obj.matrix_world.copy())","def visible_objects_and_duplis():\n\n for obj in context.visible_objects:\n if obj.type == 'MESH':\n if obj.modeling_cloth: \n yield (obj, obj.matrix_world.copy())","def afficherOBJ(self):\r\n str_abr = self.abr.afficher()## appel de l'affichage d'un ABR\r\n return str(self.debut)+':'+str(self.fin)+';'+str_abr ##concaténation du resultat\r","def afficher(self, personnage, jeu, partie):\n en_main = jeu.en_main.get(personnage)\n tableau = jeu.tableau\n if en_main:\n msg = \"Dans votre main, vous avez {} et {}.\".format(\n en_main[0].nom_complet_indefini,\n en_main[1].nom_complet_indefini)\n else:\n msg = \"Vous n'avez encore rien dans votre main.\"\n \n if tableau:\n tableau = [piece.nom_complet_indefini for piece in tableau]\n aff_tableau = \", \".join(tableau[:-1]) + \" et \" + tableau[-1]\n msg += \"\\nSur le tableau se trouve {}.\".format(aff_tableau)\n\n if partie.tour is personnage:\n msg += \"\\nC'est votre tour.\"\n \n return msg","def part_id(self):\n ...","def part(self):\n return self._modelPart","def __str__(self):\r\n return self.afficherOBJ()","def test_data_object_vaporise(self):\n pass","def other_object(img):\n return img[500:570, 1000:1070]","def object_for(objectid):","def properties(self):","def properties(self):","def properties(self):","def _blob(self):\n self.__rewrite_sldIdLst()\n # # at least the following needs to be added before using\n # # _reltype_ordering again for Presentation\n # self.__rewrite_notesMasterIdLst()\n # self.__rewrite_handoutMasterIdLst()\n # self.__rewrite_sldMasterIdLst()\n return super(Presentation, self)._blob","def get_obj():\n idPadre = request.args.get('id')\n nombrePadre = nombreObjeto(idPadre)\n global variablesActualizables\n variablesActualizables = -1\n print(\"consulta objetos id: {}, padre: {}\".format(idPadre,nombrePadre))\n\n try:\n objetos = g.db.query(Objetos).filter_by(NombreObjetoPadreObjeto=nombrePadre).filter_by(Activo=True).all()\n except NoResultFound:\n print \"NO resultados para el padre {}\".format(nombrePadre)\n objetos = []\n\n try:\n funciones = g.db.query(Funciones).filter_by(NombreObjetoPadreFuncion=idPadre).all()\n except NoResultFound:\n print \"NO funciones para el padre {}\".format(nombrePadre)\n funciones = []\n\n try:\n variables = g.db.query(Variables).filter_by(NombreObjetoPadreVariable=idPadre).all()\n except NoResultFound:\n print \"NO variables para el padre {}\".format(nombrePadre)\n variables = []\n if nombrePadre != None:\n Padre=\"Elementos de {}\".format(nombrePadre)\n else:\n Padre=\"Objetos Activos\"\n return render_template('show_objects.html',padre=Padre, objetos=objetos, funciones=funciones, variables=variables)","def present(self):","def fields(self):","def __init__(self):\n mi_parqueo = list()","def part_6():\n\n raise NotImplementedError","def Item(self) -> object:","def Item(self) -> object:","def COMBI(self):\n\n self.FB()\n self.LAT()\n self.ROT()","def __init__(self):\n self.nombre_roues = 4\n self.nombre_fauteils = 1\n self.moteur = False\n self.volant = True","def __init__(self):\n self.tours = []\n self.grille = Grille()","def get_object_to_run(self):","def __init__(self, piece):\n self.piece = piece","def afficher_carte(self):\n print(self)","def visible_objects_and_duplis():\r\n \r\n for obj in context.visible_objects:\r\n if obj.type == 'MESH':\r\n yield (obj, obj.matrix_world.copy())\r\n \r\n if obj.dupli_type != 'NONE':\r\n obj.dupli_list_create(scene)\r\n for dob in obj.dupli_list:\r\n obj_dupli = dob.object\r\n if obj_dupli.type == 'MESH':\r\n yield (obj_dupli, dob.matrix.copy())\r\n \r\n obj.dupli_list_clear()","def get_is_por_holder(self, obj):\n user = self.context['request'].user\n if not user.is_authenticated:\n return False\n # pylint: disable=no-member\n profile = UserProfile.objects.get(user=user)\n\n if profile == obj.club.secy:\n return True\n\n if profile in obj.club.joint_secy.all():\n return True\n\n if profile == obj.club.council.gensec:\n return True\n\n if profile in obj.club.council.joint_gensec.all():\n return True\n\n return False","def get_mvts(self, plateau):\n if self.type == \"p\": #Pion\n if self.color == \"w\":\n diags = [[self.x-1, self.y+1],[self.x+1, self.y+1]] #Mouvements possibles de diagonales\n faces = [[self.x, self.y+1]] #Mouvements possibles de face\n if not self.moved: #Si le pion n'a pas encore bougé de la partie\n faces.append([self.x, self.y+2])\n else:\n diags = [[self.x-1, self.y-1], [self.x+1, self.y-1]]\n faces = [[self.x, self.y-1]] #Mouvements possibles de \n if not self.moved:\n faces.append([self.x, self.y-2])\n pos = [] #Position de déplacement validées\n for d in diags:\n if verif_case(d[0], d[1]): #Si la case est sur le plateau \n pion = plateau.get_pion(d[0],d[1])\n if pion != None and pion.color != self.color: #Si il y a un pion ennemi\n pos.append(d)\n for f in faces: \n if verif_case(f[0],f[1]):\n pion = plateau.get_pion(f[0], f[1])\n if pion == None: #Si il n'y a pas de pion\n pos.append(f)\n return pos\n elif self.type == \"t\": #Tour\n pos = []\n dir = [[1,0],[-1,0],[0,1],[0,-1]] #4 directions possibles\n for d in dir:\n x,y = self.x+d[0],self.y+d[1] #Projection de position\n while verif_case(x,y): #Tant que (x, y) est sur le plateau\n pion = plateau.get_pion(x, y)\n if pion != None: #Si il y a un pion\n if pion.color != self.color: #Si il n'est pas allié\n pos.append([x,y])\n break\n pos.append([x,y])\n x += d[0]\n y += d[1]\n return pos\n elif self.type == \"c\": #Cavalier\n l = [-2,-1,1,2]\n mvts = [[x,y] for x in l for y in l if abs(x)!=abs(y)]\n pos = []\n for m in mvts:\n x = self.x + m[0]\n y = self.y + m[1]\n if verif_case(x,y):\n pion = plateau.get_pion(x, y)\n if pion == None or pion.color != self.color:\n pos.append([x, y])\n return pos\n elif self.type == \"f\": #Fou\n dir = [[1,1],[-1,1],[-1,-1],[1,-1]]\n pos = []\n for d in dir:\n x,y = self.x+d[0],self.y+d[1]\n while verif_case(x,y):\n pion = plateau.get_pion(x, y)\n if pion != None:\n if pion.color != self.color:\n pos.append([x,y])\n break\n pos.append([x,y])\n x += d[0]\n y += d[1]\n return pos\n elif self.type == \"k\": #Roi\n mvts = [[1,0],[-1,1],[0,-1],[-1,-1],[-1,0],[-1,1],[0,1],[1,1]] #4 mouvements possibles\n pos = []\n for m in mvts:\n x = self.x + m[0]\n y = self.y + m[1]\n if verif_case(x, y):\n pion = plateau.get_pion(x, y)\n if pion == None or pion.color != self.color:\n pos.append([self.x + m[0], self.y + m[1]])\n return pos\n elif self.type == \"q\": #Dame\n pos = []\n dir = [[1,0],[1,-1],[0,-1],[-1,-1],[-1,0],[-1,1],[0,1],[1,1]]\n for d in dir:\n x,y = self.x+d[0],self.y+d[1]\n while verif_case(x,y):\n pion = plateau.get_pion(x, y)\n if pion != None:\n if pion.color != joueur:\n pos.append([x,y])\n break\n pos.append([x,y])\n x += d[0]\n y += d[1]\n return pos","def cliquer_sur_unité(self):","def __init__(self,donnee_admin):\n self.ref = donnee_admin[0]\n self.date_saisie = donnee_admin[1]\n self.remplissage = donnee_admin[2]\n self.date_entree = donnee_admin[3]\n self.date_sortie = donnee_admin[4]","def area(self):","def actualise_fenetre(self,plateau,fenetre,joueur,info,bouton,etape_texte):\n\n self.affiche_plateau(plateau,fenetre)\n liste_im_joueur = [pygame.image.load(\"joueur\"+str(i)+\".png\").convert_alpha() for i in range(1,5)]\n for i in range (4) :\n x_joueur = 60\n y_joueur = 60\n liste_im_joueur[i] = pygame.transform.scale(liste_im_joueur[i], (int(x_joueur),int(y_joueur)))\n\n for i in range(len(plateau.dico_joueurs)) :\n fenetre.blit(liste_im_joueur[i],(1030,320+i*80))\n fenetre.blit(police_small.render(str(plateau.dico_joueurs[i].nom) + \" : \",False,pygame.Color(\"#000000\")),(800,340+i*75))\n fenetre.blit(police1.render(\"Score : \"+str(plateau.dico_joueurs[i].points),False,pygame.Color(\"#000000\")),(800,340+i*75+15))\n fenetre.blit(police1.render(\"Ordre de mission : \"+str(sorted(plateau.dico_joueurs[i].fantome_target)),False,pygame.Color(\"#000000\")),(800,340+i*75+30))\n fenetre.blit(police1.render(\"Jokers restants : \"+str(plateau.dico_joueurs[i].nb_joker),False,pygame.Color(\"#000000\")),(800,340+i*75+45))\n \n #test texte pour afficher le joueur qui joue\n if self.turn == True :\n fenetre.blit(police.render(\"C'est à vous de jouer\",False,pygame.Color(0,0,0)),(800,240))\n else:\n fenetre.blit(police.render(\"C'est le tour de votre adversaire\",False,pygame.Color(0,0,0)),(800,240))\n \n #affichage du message d'erreur\n for i in range(len(info)) : \n fenetre.blit(police.render(info[i],False,pygame.Color(\"#000000\")),(760,180+i*20))\n \n fenetre.blit(police.render(etape_texte,False,pygame.Color(\"#000000\")),(760,160))\n \n \n bouton.draw(fenetre)\n \n pygame.display.flip()","def partid(self): # -> None:\n ...","def extra_object_files(self):","def chercherChemin(self):\n\n \n liste=self._circuit.vue(self.x,self.y,self.rayonVision)\n \n listeSuppr=[]\n couche_vehicule= self._circuit.Couche_vehicules\n \n for case in liste :\n #on élimine les cases infranchissbles les cases qui ne sont pas sur le chemin à suivre \n\n if self._circuit.numeroWayPoint(case[0],case[1])==0 or ( self._circuit.numeroWayPoint(self.x,self.y)!=self._circuit.lastWayPoint and self._circuit.numeroWayPoint(case[0],case[1])<= self._circuit.numeroWayPoint(self.x,self.y)) or( self._circuit.numeroWayPoint(case[0],case[1])>= 5*self._circuit.numeroWayPoint(self.x,self.y) and self._circuit.numeroWayPoint(self.x,self.y)!=0) or ( self._circuit.numeroWayPoint(self.x,self.y)==self._circuit.lastWayPoint and self._circuit.numeroWayPoint(case[0],case[1])== self._circuit.numeroWayPoint(self.x,self.y)) or self._circuit.plateau[case[1],case[0],couche_vehicule]!=None:#on élimine les points derrière\n \n listeSuppr.append(case)\n\n \n for case in listeSuppr:\n \n liste.remove(case)\n \n if len(liste)>=1:\n l=liste[0]\n\n for nour in liste :\n \n if distance((self.x,self.y),(l[0],l[1])) > distance((self.x,self.y),(nour[0],nour[1])):\n l=nour\n pasx=0\n pasy=0\n if self.x<l[0] : \n pasx=1\n elif self.x>l[0] :\n pasx=-1\n if self.y<l[1] : \n pasy=1\n elif self.y>l[1] :\n pasy=-1\n debug.dprint(\" id {} {}:({},{}) Waypoint {} Point:({},{}) WayPoint {} vitesse :{} reservoir:{}\".format(self.id,self.typeV,self.x,self.y,self._circuit.numeroWayPoint(self.x,self.y),l[0],l[1],self._circuit.numeroWayPoint(l[0],l[1]),self.vitesse,self.reservoir))\n self.orientation=atan2(pasy,pasx)\n\n self.vitesse=1\n\n debug.dprint(self) \n \n super().deplacer()\n \n\n self.rayonVision=4\n else :# on augemente le rayon de vision au cas ou toutes les cases sont occupées ou non franchissables\n self.rayonVision*=3","def get(self, obj):","def __sub__(self,other):\n\t\treal = self.realPart - other.realPart\n\t\timaginary = self.imaginaryPart - other.imaginaryPart\n\n\t\t#create and return complexNumber\n\t\treturn real,imaginary","def test_data_object_get_details(self):\n pass","def __getitem__(self, index):\n path, name, txt = self.imgs[index]\n img = self.loader(path)\n\n img_size = img.size\n img_size = (400,400)\n\n loader = loadjson\n \n data = loader(txt, self.objectsofinterest,img)\n\n pointsBelief = data['pointsBelief'] \n objects_centroid = data['centroids']\n points_all = data['points']\n points_keypoints = data['keypoints_2d']\n translations = torch.from_numpy(np.array(\n data['translations'])).float()\n rotations = torch.from_numpy(np.array(\n data['rotations'])).float() \n\n if len(points_all) == 0:\n points_all = torch.zeros(1, 10, 2).double()\n \n # self.save == true assumes there is only \n # one object instance in the scene. \n if translations.size()[0] > 1:\n translations = translations[0].unsqueeze(0)\n rotations = rotations[0].unsqueeze(0)\n\n # If there are no objects, still need to return similar shape array\n if len(translations) == 0:\n translations = torch.zeros(1,3).float()\n rotations = torch.zeros(1,4).float()\n\n # Camera intrinsics\n path_cam = path.replace(name,'_camera_settings.json')\n with open(path_cam) as data_file: \n data = json.load(data_file)\n # Assumes one camera\n cam = data['camera_settings'][0]['intrinsic_settings']\n\n matrix_camera = np.zeros((3,3))\n matrix_camera[0,0] = cam['fx']\n matrix_camera[1,1] = cam['fy']\n matrix_camera[0,2] = cam['cx']\n matrix_camera[1,2] = cam['cy']\n matrix_camera[2,2] = 1\n\n # Load the cuboid sizes\n path_set = path.replace(name,'_object_settings.json')\n with open(path_set) as data_file: \n data = json.load(data_file)\n\n cuboid = torch.zeros(1)\n\n if self.objectsofinterest is None:\n cuboid = np.array(data['exported_objects'][0]['cuboid_dimensions'])\n else:\n for info in data[\"exported_objects\"]:\n if self.objectsofinterest in info['class']:\n cuboid = np.array(info['cuboid_dimensions'])\n\n img_original = img.copy() \n\n \n def Reproject(points,tm, rm):\n \"\"\"\n Reprojection of points when rotating the image\n \"\"\"\n proj_cuboid = np.array(points)\n\n rmat = np.identity(3)\n rmat[0:2] = rm\n tmat = np.identity(3)\n tmat[0:2] = tm\n\n new_cuboid = np.matmul(\n rmat, np.vstack((proj_cuboid.T, np.ones(len(points)))))\n new_cuboid = np.matmul(tmat, new_cuboid)\n new_cuboid = new_cuboid[0:2].T\n\n return new_cuboid\n\n # Random image manipulation, rotation and translation with zero padding\n dx = round(np.random.normal(0, 2) * float(self.random_translation[0]))\n dy = round(np.random.normal(0, 2) * float(self.random_translation[1]))\n angle = round(np.random.normal(0, 1) * float(self.random_rotation))\n\n tm = np.float32([[1, 0, dx], [0, 1, dy]])\n rm = cv2.getRotationMatrix2D(\n (img.size[0]/2, img.size[1]/2), angle, 1)\n\n for i_objects in range(len(pointsBelief)):\n points = pointsBelief[i_objects]\n new_cuboid = Reproject(points, tm, rm)\n pointsBelief[i_objects] = new_cuboid.tolist()\n objects_centroid[i_objects] = tuple(new_cuboid.tolist()[-1])\n pointsBelief[i_objects] = list(map(tuple, pointsBelief[i_objects]))\n\n for i_objects in range(len(points_keypoints)):\n points = points_keypoints[i_objects]\n new_cuboid = Reproject(points, tm, rm)\n points_keypoints[i_objects] = new_cuboid.tolist()\n points_keypoints[i_objects] = list(map(tuple, points_keypoints[i_objects]))\n \n image_r = cv2.warpAffine(np.array(img), rm, img.size)\n result = cv2.warpAffine(image_r, tm, img.size)\n img = Image.fromarray(result)\n\n # Note: All point coordinates are in the image space, e.g., pixel value.\n # This is used when we do saving --- helpful for debugging\n if self.save or self.test: \n # Use the save to debug the data\n if self.test:\n draw = ImageDraw.Draw(img_original)\n else:\n draw = ImageDraw.Draw(img)\n \n # PIL drawing functions, here for sharing draw\n def DrawKeypoints(points):\n for key in points:\n DrawDot(key,(12, 115, 170),7) \n \n def DrawLine(point1, point2, lineColor, lineWidth):\n if not point1 is None and not point2 is None:\n draw.line([point1,point2],fill=lineColor,width=lineWidth)\n\n def DrawDot(point, pointColor, pointRadius):\n if not point is None:\n xy = [point[0]-pointRadius, point[1]-pointRadius, point[0]+pointRadius, point[1]+pointRadius]\n draw.ellipse(xy, fill=pointColor, outline=pointColor)\n\n def DrawCube(points, which_color = 0, color = None):\n '''Draw cube with a thick solid line across the front top edge.'''\n lineWidthForDrawing = 2\n lineColor1 = (255, 215, 0) # yellow-ish\n lineColor2 = (12, 115, 170) # blue-ish\n lineColor3 = (45, 195, 35) # green-ish\n if which_color == 3:\n lineColor = lineColor3\n else:\n lineColor = lineColor1\n\n if not color is None:\n lineColor = color \n\n # draw front\n DrawLine(points[0], points[1], lineColor, 8) #lineWidthForDrawing)\n DrawLine(points[1], points[2], lineColor, lineWidthForDrawing)\n DrawLine(points[3], points[2], lineColor, lineWidthForDrawing)\n DrawLine(points[3], points[0], lineColor, lineWidthForDrawing)\n \n # draw back\n DrawLine(points[4], points[5], lineColor, lineWidthForDrawing)\n DrawLine(points[6], points[5], lineColor, lineWidthForDrawing)\n DrawLine(points[6], points[7], lineColor, lineWidthForDrawing)\n DrawLine(points[4], points[7], lineColor, lineWidthForDrawing)\n \n # draw sides\n DrawLine(points[0], points[4], lineColor, lineWidthForDrawing)\n DrawLine(points[7], points[3], lineColor, lineWidthForDrawing)\n DrawLine(points[5], points[1], lineColor, lineWidthForDrawing)\n DrawLine(points[2], points[6], lineColor, lineWidthForDrawing)\n\n # draw dots\n DrawDot(points[0], pointColor=(255,255,255), pointRadius = 3)\n DrawDot(points[1], pointColor=(0,0,0), pointRadius = 3)\n\n # Draw all the found objects. \n for points_belief_objects in pointsBelief:\n DrawCube(points_belief_objects)\n for keypoint in points_keypoints:\n DrawKeypoints(keypoint)\n\n img = self.transform(img)\n \n return {\n \"img\":img,\n \"translations\":translations,\n \"rot_quaternions\":rotations,\n 'pointsBelief':np.array(points_all[0]),\n 'matrix_camera':matrix_camera,\n 'img_original': np.array(img_original),\n 'cuboid': cuboid,\n 'file_name':name,\n }\n\n # Create the belief map\n beliefsImg = CreateBeliefMap(\n img, \n pointsBelief=pointsBelief,\n nbpoints = 9,\n sigma = self.sigma)\n\n # Create the image maps for belief\n transform = transforms.Compose([transforms.Resize(min(img_size))])\n totensor = transforms.Compose([transforms.ToTensor()])\n\n for j in range(len(beliefsImg)):\n beliefsImg[j] = self.target_transform(beliefsImg[j])\n # beliefsImg[j].save('{}.png'.format(j))\n beliefsImg[j] = totensor(beliefsImg[j])\n\n beliefs = torch.zeros((len(beliefsImg),beliefsImg[0].size(1),beliefsImg[0].size(2)))\n for j in range(len(beliefsImg)):\n beliefs[j] = beliefsImg[j][0]\n \n\n # Create affinity maps\n scale = 8\n if min (img.size) / 8.0 != min (img_size)/8.0:\n # print (scale)\n scale = min (img.size)/(min (img_size)/8.0)\n\n affinities = GenerateMapAffinity(img,8,pointsBelief,objects_centroid,scale)\n img = self.transform(img)\n\n # Transform the images for training input\n w_crop = np.random.randint(0, img.size[0] - img_size[0]+1)\n h_crop = np.random.randint(0, img.size[1] - img_size[1]+1)\n transform = transforms.Compose([transforms.Resize(min(img_size))])\n totensor = transforms.Compose([transforms.ToTensor()])\n\n if not self.normal is None:\n normalize = transforms.Compose([transforms.Normalize\n ((self.normal[0],self.normal[0],self.normal[0]),\n (self.normal[1],self.normal[1],self.normal[1])),\n AddNoise(self.noise)])\n else:\n normalize = transforms.Compose([AddNoise(0.0001)])\n \n img = crop(img,h_crop,w_crop,img_size[1],img_size[0])\n img = totensor(img)\n\n img = normalize(img)\n\n w_crop = int(w_crop/8)\n h_crop = int(h_crop/8)\n\n affinities = affinities[:,h_crop:h_crop+int(img_size[1]/8),w_crop:w_crop+int(img_size[0]/8)]\n beliefs = beliefs[:,h_crop:h_crop+int(img_size[1]/8),w_crop:w_crop+int(img_size[0]/8)]\n\n if affinities.size()[1] == 49 and not self.test:\n affinities = torch.cat([affinities,torch.zeros(16,1,50)],dim=1)\n\n if affinities.size()[2] == 49 and not self.test:\n affinities = torch.cat([affinities,torch.zeros(16,50,1)],dim=2)\n\n return {\n 'img':img, \n \"affinities\":affinities, \n 'beliefs':beliefs,\n }","def test_01_BuildObjects(self):\n # print(PrettyFormatAny.form(self.m_pyhouse_obj, 'A1-01-A - Main', 190))\n # print(PrettyFormatAny.form(self.m_pyhouse_obj.House, 'A1-02-B - House', 190))\n # print(PrettyFormatAny.form(self.m_pyhouse_obj.House.Location, 'A1-01-C - Location', 190))\n self.assertIsInstance(self.m_pyhouse_obj, PyHouseInformation)\n self.assertIsInstance(self.m_pyhouse_obj.House, HouseInformation)\n self.assertIsInstance(self.m_pyhouse_obj.House.Location, LocationInformationPrivate)","def __init__(self, altura, peso, edad):\n\t\tself.altura = altura # OJO TODAS LAS VARIABLES SON PUBLICAS \n\t\tself.peso = peso \n\t\tself.edad = edad\n\t\tself.profesion = \"\" # esta la inicializamos nosotros\n\t\tself.lista_tareas = []\n\t\tself.__privado = 1 # este atributo es privado no podemos acceder a el desde fuera","def nextIntersectors(self, inter):\n assert self.poly1.pnFacesInPoly() and self.poly2.pnFacesInPoly()\n otherFInters = self.getIntersectorList(inter.f.vertices)\n # First intersector\n pInters = self.getIntersectorList(inter.pe.pFace.vertices)\n otherI1 = next(filter(lambda x: x is not None and x.f == inter.f and x != inter,\n pInters),\n None)\n if otherI1 is None:\n # The pFace does not intersect inter.f a second time,\n # looking for a place where inter.f intersects the pFace\n otherI1 = next(filter(lambda x: x is not None and x.f == inter.pe.pFace,\n otherFInters),\n None)\n if otherI1 is None:\n # polyhedron(inter.f.vertices + inter.pe.pFace.vertices,\n # inter.pe.pFace.edges() + inter.f.edges(),\n # [inter.f, inter.pe.pFace]).plot(True, col=('none', 'k', 'r'))\n # # print(inter.f, '\\n\\n', inter.pe.pFace)\n assert all(v in self.poly1.vertices for v in inter.f.vertices) or all(v in self.poly2.vertices for v in inter.f.vertices)\n assert self.poly1.facesInVertices() and self.poly2.facesInVertices()\n assert self.poly1.pnFacesInPoly() and self.poly2.pnFacesInPoly()\n assert self.poly1.nonDoubleVertices() and self.poly2.nonDoubleVertices()\n # # print('\\n', [(i, i.f) for i in filter(lambda x: x is not False, pInters)])\n # # print([sum(min(v.dist(v2) for v2 in inter.f.vertices) for v in i.f.vertices) for i in filter(lambda x: x is not False, pInters)])\n # # print('\\n', [(i, i.f) for i in filter(lambda x: x is not False, otherFInters)])\n # # print([sum(min(v.dist(v2) for v2 in inter.pe.pFace.vertices) for v in i.f.vertices) for i in filter(lambda x: x is not False, otherFInters)])\n raise ValueError('No intersector found')\n # Second intersector\n nInters = self.getIntersectorList(inter.pe.nFace.vertices)\n otherI2 = next(filter(lambda x: x is not None and x.f == inter.f and x != inter,\n nInters),\n None)\n if otherI2 is None:\n # The nFace does not intersect inter.f a second time,\n # looking for a place where inter.f intersects the nFace\n otherI2 = next(filter(lambda x: x is not None and x.f == inter.pe.nFace,\n otherFInters),\n None)\n if otherI2 is None:\n polyhedron(inter.f.vertices + inter.pe.nFace.vertices,\n inter.pe.nFace.edges() + inter.f.edges(),\n [inter.f, inter.pe.nFace]).plot(True, col=('none', 'k', 'r'))\n # # print(inter.f, inter.pe.pFace)\n raise ValueError('No intersector found')\n inter.adjacents = (otherI1, otherI2)\n return (otherI1, otherI2)","def extract(self):\n pass","def objets_uniques(self):\n objets = []\n for membre in self.membres:\n for objet in membre.equipe:\n if objet.unique:\n objets.append(objet)\n objets.extend(objet.prototype.objets_contenus(objet))\n if membre.tenu and membre.tenu.unique:\n objet = membre.tenu\n objets.append(objet)\n objets.extend(objet.prototype.objets_contenus(objet))\n\n return objets","def item_perceel_crab_adapter(obj, request):\n return {\n 'id': obj.id,\n 'centroid': obj.centroid,\n 'postadressen': obj.postadressen,\n 'metadata': {\n 'begin_tijd': obj.metadata.begin_tijd,\n 'begin_datum': obj.metadata.begin_datum,\n 'begin_bewerking': {\n 'id': obj.metadata.begin_bewerking.id,\n 'naam': obj.metadata.begin_bewerking.naam,\n 'definitie': obj.metadata.begin_bewerking.definitie\n },\n 'begin_organisatie': {\n 'id': obj.metadata.begin_organisatie.id,\n 'naam': obj.metadata.begin_organisatie.naam,\n 'definitie': obj.metadata.begin_organisatie.definitie\n }\n }\n }","def test_nbands_vrt_object(self):\n self.assertEqual(_test_object(landsat_vrt)[0], 2)","def __init__(self, realpart, imagpart):\n self.r = realpart\n self.i = imagpart","def CL(self):","def pickUp(self):\n pos = self.getRoverLocation()\n item = self.map[pos.y,pos.x]\n if type(item) == Part:\n self.inventory.addPart(str(item))\n self.map[pos.y,pos.x] = None","def partid(self): # -> Unknown:\n ...","def _addPredicate(self, pid, chunks):\n parent = chunks[pid]\n sub = None\n obj = None\n aux = list()\n auxlabel = \"\"\n # 1st round find absolute subject & object\n for i in range(len(parent.children)):\n child = chunks[parent.children[i]]\n # Process by categories.\n if child.func in SubDict:\n sub = child\n elif child.func in ObjDict:\n obj = child\n\n # 2nd round find potential subject & object with aux.\n for i in range(len(parent.children)):\n child = chunks[parent.children[i]]\n # Process by categories.\n if child.func in SubDict or child.func in ObjDict:\n continue\n elif child.func in ObjPostDict:\n if not obj and child.type in EntityTypeDict:\n obj = child\n else:\n aux.append(child.id)\n auxlabel += \"[{0}]\\n\".format(child.surface)\n elif child.func in SubPassiveObjDict:\n if parent.passive == 1:\n if not obj and child.type in EntityTypeDict:\n obj = child\n elif not sub and child.type in EntityTypeDict:\n sub = child\n else:\n aux.append(child.id)\n auxlabel += \"[{0}]\\n\".format(child.surface)\n else:\n if not sub and child.type in EntityTypeDict:\n sub = child\n elif not obj and child.type in EntityTypeDict:\n obj = child\n else:\n aux.append(child.id)\n auxlabel += \"[{0}]\\n\".format(child.surface)\n elif child.func in ObjPassiveSubDict:\n if parent.passive == 1:\n if not sub and child.type in EntityTypeDict:\n sub = child\n elif not obj and child.type in EntityTypeDict:\n obj = child\n else:\n aux.append(child.id)\n auxlabel += \"[{0}]\\n\".format(child.surface)\n else:\n if not obj and child.type in EntityTypeDict:\n obj = child\n elif not sub and child.type in EntityTypeDict:\n sub = child\n else:\n aux.append(child.id)\n auxlabel += \"[{0}]\\n\".format(child.surface)\n else:\n aux.append(child.id)\n auxlabel += \"[{0}]\\n\".format(child.surface)\n\n if parent.passive == 0:\n # Add parent and subject.\n # if sub and obj:\n # parent.main = \"<{0}>[{2}]{1}\".format(sub.main, parent.main, obj.main)\n # elif sub:\n # parent.main = \"<{0}>[NONE]{1}\".format(sub.main, parent.main)\n # elif obj:\n # parent.main = \"<NONE>[{1}]{0}\".format(parent.main, obj.main)\n if sub:\n parent.main = \"<{0}>{1}\".format(sub.main, parent.main)\n self._addNode(parent, sub=sub.main)\n if not self.G.has_node(sub.main):\n self._addNode(sub)\n self._addEdge(sub.main, parent.main, label=\"主体\\n\", etype=\"sub\")\n else:\n self._addNode(parent)\n # Add object.\n if obj:\n if not self.G.has_node(obj.main):\n self._addNode(obj)\n self._addEdge(parent.main, obj.main, label=\"客体\\n\" + auxlabel, etype=\"obj\")\n else:\n # Add obj as sub\n # if sub and obj:\n # parent.main = \"<{0}>[{2}]{1}\".format(sub.main, parent.main, obj.main)\n # elif obj:\n # parent.main = \"<{0}>[NONE]{1}\".format(obj.main, parent.main)\n # elif sub:\n # parent.main = \"<NONE>[{1}]{0}\".format(parent.main, sub.main)\n if obj:\n parent.main = \"<{0}>{1}\".format(obj.main, parent.main)\n self._addNode(parent, sub=obj.main)\n if not self.G.has_node(obj.main):\n self._addNode(obj)\n self._addEdge(obj.main, parent.main, label=\"主体\\n\", etype=\"sub\")\n else:\n self._addNode(parent)\n # Add sub as obj\n if sub:\n if not self.G.has_node(sub.main):\n self._addNode(sub)\n self._addEdge(parent.main, sub.main, label=\"客体\\n\", etype=\"obj\")\n # # Add obj as aux.\n # if obj:\n # aux.append(obj.id)\n # auxlabel += \"[{0}]\\n\".format(obj.surface)\n self._processAux(aux, parent.main, chunks)","def writeGroundPlane(self,obj,renderer):\n\n result = \"\"\n bbox = FreeCAD.BoundBox()\n for view in obj.Group:\n if view.Source and hasattr(view.Source,\"Shape\") and hasattr(view.Source.Shape,\"BoundBox\"):\n bbox.add(view.Source.Shape.BoundBox)\n if bbox.isValid():\n import Part\n margin = bbox.DiagonalLength/2\n p1 = FreeCAD.Vector(bbox.XMin-margin,bbox.YMin-margin,0)\n p2 = FreeCAD.Vector(bbox.XMax+margin,bbox.YMin-margin,0)\n p3 = FreeCAD.Vector(bbox.XMax+margin,bbox.YMax+margin,0)\n p4 = FreeCAD.Vector(bbox.XMin-margin,bbox.YMax+margin,0)\n\n # create temporary object. We do this to keep the renderers code as simple as possible:\n # they only need to deal with one type of object: RenderView objects\n dummy1 = FreeCAD.ActiveDocument.addObject(\"Part::Feature\",\"renderdummy1\")\n dummy1.Shape = Part.Face(Part.makePolygon([p1,p2,p3,p4,p1]))\n dummy2 = FreeCAD.ActiveDocument.addObject(\"App::FeaturePython\",\"renderdummy2\")\n View(dummy2)\n dummy2.Source = dummy1\n ViewProviderView(dummy2.ViewObject)\n FreeCAD.ActiveDocument.recompute()\n\n result = self.writeObject(dummy2,renderer)\n\n # remove temp objects\n FreeCAD.ActiveDocument.removeObject(dummy2.Name)\n FreeCAD.ActiveDocument.removeObject(dummy1.Name)\n FreeCAD.ActiveDocument.recompute()\n\n return result","def test_api_object_partial_property(self, api_object):\n api_object.status = 'PARTIAL'\n assert api_object.partial\n assert not api_object.creating","def addReco(obj1,obj2):\n px = obj1.px + obj2.px\n py = obj1.py + obj2.py\n pz = obj1.pz + obj2.pz\n E = obj1.E + obj2.E\n return Reco(px,py,pz,E)","def reckon(self):","def __init__(self, diccionario):\n self.numero = diccionario['numero']\n self.nombre = diccionario['equipo_nombre']\n self.pokmov = lectores.pokemon_y_movimiento_a_tuplas(diccionario)","def is_full(self):","def get_product_area(self, obj):\n\t\treturn obj.product.product","def get_object(self, img):\n objectType = 'none'\n colourProb = np.ones((3,)) / 3.0\n distance = 0.0\n angle = 0.0\n self.patternFound = False\n \n #patternFound, corners = self.get_corners(img)\n self.get_corners(img)\n \n if (self.patternFound):\n \n # Determine if the object is horizontal or vertical\n delta_x = abs(self.corners[0,0,0] - self.corners[2,0,0])\n delta_y = abs(self.corners[0,0,1] - self.corners[2,0,1])\n horizontal = (delta_y > delta_x)\n if (horizontal):\n objectType = 'horizontal'\n else:\n objectType = 'vertical'\n \n # Compute distances and angles\n if (horizontal):\n height = ((abs (self.corners [0,0,1] - self.corners [2,0,1]) +\n abs (self.corners [9,0,1] - self.corners [11,0,1])) / 2.0);\n \n patternHeight = (self.patternSize[0]-1.0) * self.patternUnit\n \n else:\n height = (abs (self.corners [0,0,1] - self.corners [9,0,1]) +\n abs (self.corners [2,0,1] - self.corners [11,0,1])) / 2.0;\n \n patternHeight = (self.patternSize[1]-1.0) * self.patternUnit\n \n #distance = 1.0 / (0.0001 * height);\n distance = self.intrinsic_matrix[1,1] * patternHeight / (height * 10.0) \n\n center = (self.corners [0,0,0] + self.corners [2,0,0] +\n self.corners [9,0,0] + self.corners [11,0,0]) / 4.0;\n \n #angle = 0.0018 * center - 0.6425;\n #angle *= -1.0;\n angle = -np.arctan2(center - self.intrinsic_matrix[0,2], self.intrinsic_matrix[0,0])\n \n \n #### Classify object by colour\n \n # Extract rectangle corners\n points = np.array(\n [self.corners [0],\n self.corners [2],\n self.corners [9],\n self.corners [11]]\n )\n \n points.shape = (4,2)\n points = np.int32(points)\n\n # Compute region of interest\n mask = np.zeros((self.imageSize[1], self.imageSize[0]), dtype =np.uint8) \n cv2.fillConvexPoly (mask, points, (255, 255, 255)) \n \n # Compute mean colour inside region of interest\n mean_colour = cv2.mean(img, mask);\n \n red = mean_colour[2];\n green = mean_colour[1];\n blue = mean_colour[0];\n sum = red + green + blue;\n\n colourProb[0] = red / sum;\n colourProb[1] = green / sum;\n colourProb[2] = blue / sum;\n \n \n return objectType, distance, angle, colourProb","def partid(self): # -> int:\n ...","def get_object(id):","def formulate_plan(self):\n return NotImplemented","def fields(self):\n ...","def _publish_objects(self):\n\n for obj in self._cozmo.world.visible_objects:\n now = rospy.Time.now()\n x = obj.pose.position.x * 0.001\n y = obj.pose.position.y * 0.001\n z = obj.pose.position.z * 0.001\n q = (obj.pose.rotation.q1, obj.pose.rotation.q2, obj.pose.rotation.q3, obj.pose.rotation.q0)\n self._tfb.send_transform(\n (x, y, z), q, now, 'cube_' + str(obj.object_id), self._odom_frame\n )\n \n try:\n if obj.cube_id and self.target_cube != obj:\n self._tfb.send_transform((x, y, z), q, now, 'cube_' + str(obj.object_id), self._odom_frame)\n print(\"Found {}\".format(obj.cube_id))\n if not self.cube_found and self.robots_distance_to_object(self._cozmo, obj) < 400:\n self.target_cube = obj\n self.cube_found = True\n print(\"Locking on to {}\".format(obj.cube_id))\n else:\n if self.cube_found:\n print(\"Found that one already!\")\n else:\n print(\"Cube too far away!\")\n \n except:\n # print('OBJECT IS NOT A LIGHT CUBE')\n if(obj==self._cozmo.world.charger):\n return\n if(obj.object_type==CustomObjectTypes.CustomType00 and (self.front_wall_pose == None or not self.front_wall_pose.is_accurate)):\n self.front_wall_pose=obj.pose\n self._tfb.send_transform((x, y, z), q, now, 'Front', self._odom_frame)\n print('*** Comzmo has found the front wall! ***')\n if(obj.object_type==CustomObjectTypes.CustomType01 and (self.ramp_bottom_pose == None or not self.ramp_bottom_pose.is_accurate)):\n self.ramp_bottom_pose=obj.pose\n self._tfb.send_transform((x, y, z), q, now, 'Ramp', self._odom_frame)\n print('*** Comzmo has found the front wall! ***')\n if(obj.object_type==CustomObjectTypes.CustomType03 and (self.drop_spot_pose == None or not self.drop_spot_pose.is_accurate)):\n self.drop_spot_pose=obj.pose\n self._tfb.send_transform((x, y, z), q, now, 'Drop', self._odom_frame)\n print('*** Comzmo has found the drop Spot! ***')\n if(obj.object_type==CustomObjectTypes.CustomType04 and (self.back_wall_pose == None or not self.back_wall_pose.is_accurate)):\n self.back_wall_pose=obj.pose\n self._tfb.send_transform((x, y, z), q, now, 'Back', self._odom_frame)\n print('*** Comzmo has found the back wall! ***')\n if(obj.object_type==CustomObjectTypes.CustomType05 and (self.drop_target_pose == None or not self.drop_target_pose.is_accurate)):\n self.drop_target_pose=obj.pose\n self._tfb.send_transform((x, y, z), q, now, 'Target', self._odom_frame)\n print('*** Comzmo has found the Dropt Target! ***')\n if(obj.object_type==CustomObjectTypes.CustomType06 and (self.drop_clue_pose == None or not self.drop_clue_pose.is_accurate)):\n self.drop_clue_pose=obj.pose\n self._tfb.send_transform((x, y, z), q, now, 'Clue', self._odom_frame)\n print('*** Comzmo has found the Dropt Clue! ***')","def representation(self) -> DrawingObjects:\n pass","def area(self):\n ...","def test_get_composition(self):\n pass","def __init__(self, marqueur, allele, hauteur, informatif):\n\n self.marqueur = marqueur\n self.allele = allele\n self.hauteur = hauteur\n self.informatif = informatif","def get_representative_data_object(self, obj):\n if self.dim == 0:\n # In this way, obj can be a data object and this class can be\n # used even if the assignment is not between \"flattened components\"\n return obj\n else:\n nominal_index = self.nominal_index\n return obj[nominal_index]"],"string":"[\n \"def object(self):\",\n \"def test_partie(joueur1: object,\\n joueur2: object,\\n tableau_invisible_joueur1: list, tableau_invisible_joueur2: list\\n ):\\n print(\\\"plateau du joueur 2 : \\\\n\\\")\\n\\n tour_de_jeu(joueur1, joueur2, tableau_invisible_joueur2)\\n\\n rafraichir_position(joueur2, joueur2.porte_avion)\\n verif_bateau(joueur1, joueur2.porte_avion)\\n\\n print(\\\"plateau du joueur 1 : \\\\n\\\")\\n tour_de_jeu(joueur2, joueur1, tableau_invisible_joueur1)\\n\\n rafraichir_position(joueur1, joueur1.porte_avion)\\n verif_bateau(joueur2, joueur1.porte_avion)\",\n \"def petite_partie(joueur1: object,\\n joueur2: object,\\n tableau_invisible_joueur1: list, tableau_invisible_joueur2: list\\n ):\\n print(\\\"plateau du joueur 2 : \\\\n\\\")\\n\\n tour_de_jeu(joueur1, joueur2, tableau_invisible_joueur2)\\n\\n rafraichir_position(joueur2, joueur2.porte_avion, joueur2.torpilleur, joueur2.croiseur)\\n verif_bateau(joueur1, joueur2.porte_avion, joueur2.torpilleur, joueur2.croiseur)\\n\\n print(\\\"plateau du joueur 1 : \\\\n\\\")\\n tour_de_jeu(joueur2, joueur1, tableau_invisible_joueur1)\\n\\n rafraichir_position(joueur1, joueur1.porte_avion, joueur1.torpilleur, joueur1.croiseur)\\n verif_bateau(joueur2, joueur1.porte_avion, joueur1.torpilleur, joueur1.croiseur)\",\n \"def mezclar_bolsa(self):\",\n \"def grande_partie(joueur1: object, joueur2: object,\\n tableau_invisible_joueur1: list, tableau_invisible_joueur2: list,\\n ):\\n print(\\\"plateau du joueur 2 : \\\\n\\\")\\n\\n tour_de_jeu(joueur1, joueur2, tableau_invisible_joueur2)\\n\\n rafraichir_position(joueur2, joueur2.porte_avion, joueur2.torpilleur, joueur2.croiseur, joueur2.canonniere,\\n joueur2.destroyer)\\n verif_bateau(joueur1, joueur2.porte_avion, joueur2.torpilleur, joueur2.croiseur, joueur2.canonniere,\\n joueur2.destroyer)\\n\\n print(\\\"plateau du joueur 1 : \\\\n\\\")\\n tour_de_jeu(joueur2, joueur1, tableau_invisible_joueur1)\\n\\n rafraichir_position(joueur1, joueur1.porte_avion, joueur1.torpilleur, joueur1.croiseur, joueur1.canonniere,\\n joueur1.destroyer)\\n verif_bateau(joueur2, joueur1.porte_avion, joueur1.torpilleur, joueur1.croiseur, joueur1.canonniere,\\n joueur1.destroyer)\",\n \"def objects(self):\",\n \"def copier(partie):\\n # Instanciation d'une nouvelle partie\\n partie_copiee = Partie()\\n\\n for tour in partie.tours:\\n tour_tmp = Tour(tour.x, tour.y) # Instanciation d'un tour\\n partie_copiee.nouveau_tour(tour_tmp) # Ajout du tour\\n\\n return partie_copiee\",\n \"def __init__(self, partie):\\n self.ID = 0\\n self.nbr_noeuds = 1\\n self.nbr_feuilles = 1\\n self.partie = partie\\n self.nbr_fils = 0\\n self.fils = []\",\n \"def sketch_und_part(self):\\n if (self.dimension == '3D'):\\n #Sketch Wuerfel zeichnen\\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\\n name='Seitenansicht_Wuerfel',\\n sheetSize=200.0)\\n self.sketch_Wuerfel.rectangle(\\n point1=(-self.laenge_x/2.0, -self.laenge_y/2.0),\\n point2=(self.laenge_x/2.0, self.laenge_y/2.0))\\n #Part Wuerfel generieren\\n self.part_Wuerfel = self.model.Part(\\n name=self.name+'_Wuerfel',\\n dimensionality=THREE_D,\\n type=DEFORMABLE_BODY)\\n self.part_Wuerfel.BaseSolidExtrude(\\n sketch=self.sketch_Wuerfel,\\n depth=self.laenge_z/2.0) #z-Symmetrie\\n #Sketch Pore zeichnen (fuer Quader und Zylinder)\\n self.sketch_Pore = self.model.ConstrainedSketch(\\n name='Seitenansicht_Pore',\\n sheetSize=200.0)\\n if (self.typ_Pore == 'Quader'):\\n self.sketch_Pore.rectangle(\\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Zylinder'):\\n self.sketch_Pore.EllipseByCenterPerimeter(\\n center=(0.0, 0.0),\\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n axisPoint2=(0.0, self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Ellipsoid' ):\\n matlab.ellipsoidIgesOut(\\n self.porenparameter_x,\\n self.porenparameter_y,\\n self.porenparameter_z,\\n 'Ellipsoid')\\n # if (self.porenparameter_x == self.porenparameter_z):\\n # self.sketch_Pore.ConstructionLine(\\n # point1=(0.0, -100.0),\\n # point2=(0.0, 100.0))\\n # self.sketch_Pore.EllipseByCenterPerimeter(\\n # center=(0.0, 0.0),\\n # axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n # axisPoint2=(0.0, self.porenparameter_y/2.0))\\n # self.sketch_Pore.autoTrimCurve(\\n # curve1=self.sketch_Pore.geometry[3],\\n # point1=(-self.porenparameter_x/2.0, 0.0))\\n # self.sketch_Pore.Line(\\n # point1=(0.0, self.porenparameter_y/2.0),\\n # point2=(0.0, -self.porenparameter_y/2.0))\\n else:\\n print('typ_Pore Error!')\\n #Part Pore generieren\\n if (self.typ_Pore == 'Ellipsoid' ):\\n # if (self.porenparameter_x == self.porenparameter_z):\\n # self.part_Pore.BaseSolidRevolve(\\n # sketch=self.sketch_Pore,\\n # angle=360.0,\\n # flipRevolveDirection=OFF)\\n self.iges_Datei = mdb.openIges(\\n 'Ellipsoid.igs',\\n msbo=False,\\n trimCurve=DEFAULT,\\n scaleFromFile=OFF)\\n self.model.PartFromGeometryFile(\\n name=self.name+'_Pore',\\n geometryFile=self.iges_Datei,\\n combine=False,\\n stitchTolerance=1.0,\\n dimensionality=THREE_D,\\n type=DEFORMABLE_BODY,\\n convertToAnalytical=1,\\n stitchEdges=1,\\n scale=1) # Skalierung\\n self.part_Pore = self.model.parts[self.name+'_Pore']\\n self.part_Pore.AddCells(\\n faceList = self.part_Pore.faces,\\n flipped=False)\\n del self.iges_Datei\\n os.remove('abaqus_read_iges0.log') #Arbeitsordner aufraeumen\\n os.remove('temp-Ellipsoid-new.sat')\\n os.remove('Ellipsoid.igs')\\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\\n self.part_Pore = self.model.Part(\\n name=self.name+'_Pore',\\n dimensionality=THREE_D,\\n type=DEFORMABLE_BODY)\\n self.part_Pore.BaseSolidExtrude(\\n sketch=self.sketch_Pore,\\n depth=self.porenparameter_z)\\n #Assemble\\n self.assembly = self.model.rootAssembly\\n self.assembly.DatumCsysByDefault(CARTESIAN)\\n self.assembly.Instance(\\n name=self.name+'_Pore',\\n part=self.part_Pore,\\n dependent=ON)\\n self.assembly.Instance(\\n name=self.name+'_Wuerfel',\\n part=self.part_Wuerfel,\\n dependent=ON)\\n #Translation\\n self.assembly.translate(\\n instanceList=(self.name+'_Wuerfel', ),\\n vector=(0.0, 0.0, -self.laenge_z/2.0))\\n if (self.typ_Pore == 'Ellipsoid'):\\n self.assembly.translate(\\n instanceList=(self.name+'_Pore', ),\\n vector=(0.0, 0.0, 0.0))\\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\\n self.assembly.translate(\\n instanceList=(self.name+'_Pore', ),\\n vector=(0.0, 0.0, -self.porenparameter_z/2.0))\\n #Rotation\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, 0.0),\\n axisDirection=(1.0, 0.0, 0.0),\\n angle=self.porenparameter_rx)\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, 0.0),\\n axisDirection=(0.0, 1.0, 0.0),\\n angle=self.porenparameter_ry)\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, 0.0),\\n axisDirection=(0.0, 0.0,1.0),\\n angle=self.porenparameter_rz)\\n #Schneiden\\n self.assembly.InstanceFromBooleanCut(\\n name='RVE',\\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\\n originalInstances=SUPPRESS)\\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\\n # del self.model.parts[self.name+'_Wuerfel']\\n # del self.model.parts[self.name+'_Pore']\\n self.part_RVE = self.model.parts[self.name]\\n elif (self.dimension == '2D'):\\n #Sketch Wuerfel zeichnen\\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\\n name='Seitenansicht_Wuerfel',\\n sheetSize=200.0)\\n self.sketch_Wuerfel.rectangle(\\n point1=(0.0, 0.0),\\n point2=(self.laenge_x/2.0, self.laenge_y/2.0)) #x- und y-Symmetrie\\n #Part Wuerfel generieren\\n self.part_Wuerfel = self.model.Part(\\n name=self.name+'_Wuerfel',\\n dimensionality=TWO_D_PLANAR,\\n type=DEFORMABLE_BODY)\\n self.part_Wuerfel.BaseShell(sketch=self.sketch_Wuerfel)\\n #Sketch Pore zeichnen\\n self.sketch_Pore = self.model.ConstrainedSketch(\\n name='Seitenansicht_Pore',\\n sheetSize=200.0)\\n if (self.typ_Pore == 'Ellipsoid'):\\n self.sketch_Pore.ConstructionLine(\\n point1=(0.0, -100.0),\\n point2=(0.0, 100.0))\\n self.sketch_Pore.EllipseByCenterPerimeter(\\n center=(0.0, 0.0),\\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n axisPoint2=(0.0, self.porenparameter_y/2.0))\\n self.sketch_Pore.autoTrimCurve(\\n curve1=self.sketch_Pore.geometry[3],\\n point1=(-self.porenparameter_x/2.0, 0.0))\\n self.sketch_Pore.Line(\\n point1=(0.0, self.porenparameter_y/2.0),\\n point2=(0.0, -self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Quader'):\\n self.sketch_Pore.rectangle(\\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Zylinder'):\\n self.sketch_Pore.EllipseByCenterPerimeter(\\n center=(0.0, 0.0),\\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n axisPoint2=(0.0, self.porenparameter_y/2.0))\\n else:\\n print('typ_Pore Error!')\\n #Part Pore generieren\\n self.part_Pore = self.model.Part(\\n name=self.name+'_Pore',\\n dimensionality=TWO_D_PLANAR,\\n type=DEFORMABLE_BODY)\\n self.part_Pore.BaseShell(sketch=self.sketch_Pore)\\n #Assemble\\n self.assembly = self.model.rootAssembly\\n self.assembly.DatumCsysByDefault(CARTESIAN)\\n self.assembly.Instance(\\n name=self.name+'_Wuerfel',\\n part=self.part_Wuerfel,\\n dependent=ON)\\n self.assembly.Instance(\\n name=self.name+'_Pore',\\n part=self.part_Pore,\\n dependent=ON)\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, self.laenge_z/2.0),\\n axisDirection=(0.0, 0.0, self.laenge_z/2.0+1),\\n angle=self.porenparameter_rz)\\n self.assembly.InstanceFromBooleanCut(\\n name='RVE',\\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\\n originalInstances=SUPPRESS)\\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\\n del self.model.parts[self.name+'_Wuerfel']\\n #del self.model.parts[self.name+'_Pore']\\n self.part_RVE = self.model.parts[self.name]\\n else:\\n print('dimension Error!')\",\n \"def get_contenu(self):\\n return self.objets\",\n \"def objectFields(self):\\n raise NotImplementedError\",\n \"def retirer_objet(self, nom_membre):\\n membre = self.get_membre(nom_membre)\\n objet = membre.tenu\\n membre.tenu = None\",\n \"def test_get_part(self):\\n pass\",\n \"def algoritmo(posicionInicial):\\n\\tglobal vertices, lados\\n\\n\\t# Inicio el algoritmo QuickHull y almacenare el resultado en vertices\\n\\tconvex = quickHull.QuickHull(posicionInicial)\\n\\tvertices = convex.quickHull(verticesObjeto)\\n\\tprint(\\\"\\\\nVertices en la envolvente convexa:\\\\n\\\")\\n\\tfor vertex in (vertices):\\n\\t\\tprint(vertex)\\n\\n\\t# creo la lista de lados a partir del los vertices de la envolvente\\n\\tlados = creaLados(vertices)\\n\\n\\t# creo la maya y el objeto\\n\\tmi_mesh = bpy.data.meshes.new(nombre)\\n\\tmi_objeto = bpy.data.objects.new(nombre, mi_mesh)\\n\\n\\t# coloco el objeto en la misma posicion en la que estaba el objeto\\n\\t# anteriormente seleccionado.\\n\\tmi_objeto.location = posicionInicial\\n\\n\\t# enlazo el objeto a la escena\\n\\tbpy.context.scene.objects.link(mi_objeto)\\n\\n\\t# creo el la maya del objeto\\n\\tmi_mesh.from_pydata(vertices,lados,caras)\\n\\tmi_mesh.update(calc_edges=True)\",\n \"def NuevaPartida(self,):\\n\\t\\\"\\\"\\\" Numeros Disponibles \\\"\\\"\\\"\\n\\tDisponibles[0] = True\\n\\tDisponibles[1] = True\\n\\tDisponibles[2] = True\\n\\tDisponibles[3] = True\\n\\tDisponibles[4] = True\\n\\tDisponibles[5] = True\\n\\t\\\"\\\"\\\" Jugador Uno \\\"\\\"\\\"\\n\\tJ1[0] = 0\\n\\tJ1[1] = 0\\n\\tJ1[2] = 0\\n\\tJ1[3] = 0\\n\\tJ1[4] = 0\\n\\tJ1[5] = 0\\n\\t\\\"\\\"\\\" Jugador Dos \\\"\\\"\\\"\\n\\tJ2[0] = 0\\n\\tJ2[1] = 0\\n\\tJ2[2] = 0\\n\\tJ2[3] = 0\\n\\tJ2[4] = 0\\n\\tJ2[5] = 0\\n\\t\\\"\\\"\\\" Jugador Tres \\\"\\\"\\\"\\n\\tJ3[0] = 0\\n\\tJ3[1] = 0\\n\\tJ3[2] = 0\\n\\tJ3[3] = 0\\n\\tJ3[4] = 0\\n\\tJ3[5] = 0\\n\\t\\\"\\\"\\\" Jugador Cuatro \\\"\\\"\\\"\\n\\tJ4[0] = 0\\n\\tJ4[1] = 0\\n\\tJ4[2] = 0\\n\\tJ4[3] = 0\\n\\tJ4[4] = 0\\n\\tJ4[5] = 0\",\n \"def tenir_objet(self, nom_membre=None, objet=None):\\n if nom_membre:\\n membre = self.get_membre(nom_membre)\\n else:\\n membre = None\\n for m in self.membres:\\n if m.tenu is None and m.peut_tenir():\\n membre = m\\n break\\n\\n if membre is None:\\n raise ValueError(\\\"aucun membre n'est disponible\\\")\\n\\n if membre.tenu:\\n raise ValueError(\\\"le membre {} tient déjà l'objet {} \\\".format(\\n nom_membre, membre.tenu))\\n\\n if objet is None:\\n raise ValueError(\\\"l'objet passé en paramètre est None. Pour \\\" \\\\\\n \\\"retirer un objet tenu, utilisez la méthode retirer_objet\\\")\\n\\n membre.tenu = objet\\n objet.contenu = self.tenus\",\n \"def moi(self):\\n\\n pass\",\n \"def nouvellePartie(self):\\n for i in range(0, 3):\\n for j in range(0, 3):\\n self.partie.uplateau[i, j].initialiser()\\n self.canvas_uplateau[i, j].delete('pion')\\n self.afficher_message(\\\" Nouvelle Partie\\\")\",\n \"def __init__(self, folder):\\n print \\\"folder passed is \\\", folder\\n self.folder = folder\\n self.geometry = gf.geometry(self.folder)\\n self.elements = gf.dictionary_set()\\n self.area = np.zeros(shape = (8))\\n self.Vol = (self.geometry.properties['span_number']*(self.geometry.properties['span_width']*\\n self.geometry.properties['span_height'] + self.geometry.properties['cover_height']\\n *self.geometry.properties['span_width']/2))\\n self.F = np.zeros(shape = (8, 8))\\n of.view_factor(self.geometry, self.F, self.area, self.Vol)\\n tran = [self.geometry.properties['tra_cover_out'],0.0,0.0,\\n self.geometry.properties['tra_sidewall_out'],\\n self.geometry.properties['tra_cover_in'],\\n self.geometry.properties['tra_sidewall_in'],0.0,0.0]\\n emi = [self.geometry.properties['emi_cover_out'],1.0,1.0,\\n self.geometry.properties['emi_sidewall_out'],\\n self.geometry.properties['emi_cover_in'],\\n self.geometry.properties['emi_sidewall_in'],1.0,1.0] \\n self.tr, self.em, self.re = of.optictal_prop(tran,emi)\\n if ((self.tr + self.em).any() > 1.0):\\n print \\\"error in optical properties\\\"\\n self.T = np.zeros(shape = (2,10))\\n self.RH = np.zeros(shape = (2,10))\\n # 8 inside,9 outside \\n self.qcond = np.zeros(shape = (2,8))\\n self.qconv = np.zeros(shape = (2,8))\\n self.qrad = np.zeros(shape = (2,8))\\n self.j = np.zeros(shape = (2,8))\\n self.g = np.zeros(shape = (2,8))\\n self.alpha = np.zeros(shape = (2,8))\\n deltaT = 300\\n RH_in = 0.6\\n fg.set_initial_conditions(self.geometry.properties['t_air_inside'],\\n 278,\\n RH_in,self.T,self.RH , self.geometry.properties['t_air'],self.g,\\n self.geometry.properties['sky_temp'])\\n self.T, self.j, self.g, self.alpha, self.qrad, self.qconv = fg.solver_T(self.T,self.qrad,self.qconv,self.alpha,self.j,self.g,self.em,self.tr,\\n self.geometry.properties['wind_speed'],\\n self.F,self.geometry.properties['heat_flux'],1,1.0,self.area,\\n self.geometry.properties['rho'],self.geometry.properties['cp'],\\n self.Vol,self.geometry.properties['degree_window'],deltaT)\",\n \"def presenetCar():\",\n \"def lancement_partie(joueur1: object, joueur2: object,\\n tableau_invisible_joueur1: list, tableau_invisible_joueur2: list,\\n number_of_ships: int):\\n # Victoire devient True quand un joueur détruit tout les bateaux adverse\\n victoire = False\\n # PHASE 1 PLACEMENT BATEAU\\n\\n positionner_bateau(joueur1, number_of_ships)\\n positionner_bateau(joueur2, number_of_ships)\\n\\n # PHASE 2 VERIFICATION DE L ETAT DES BATEAUX\\n while not victoire:\\n\\n if number_of_ships == 3:\\n petite_partie(joueur1, joueur2, tableau_invisible_joueur1, tableau_invisible_joueur2)\\n\\n elif number_of_ships == 1:\\n test_partie(joueur1, joueur2, tableau_invisible_joueur1, tableau_invisible_joueur2)\\n\\n elif number_of_ships == 5:\\n grande_partie(joueur1,\\n joueur2,\\n tableau_invisible_joueur1, tableau_invisible_joueur2,\\n )\\n\\n if verif_win(joueur2, number_of_ships):\\n victoire = True\\n print(\\\"le joueur 1 a gagné\\\")\\n\\n if verif_win(joueur1, number_of_ships):\\n victoire = True\\n print(\\\"le joueur 2 a gagné\\\")\\n\\n envoi_score(joueur1, joueur2)\\n afficher_score(joueur1, joueur2)\",\n \"def __init__(self,obj):\\n self.nature_libelle = obj['NatureLibelle']\\n self.ins_nom = obj['InsNom']\\n self.ins_numero_install = obj['InsNumeroInstall']\\n self.equipement_id = obj['EquipementId']\",\n \"def run_choucas(self):\\n \\n if self.dlg.cb_fondcarte.isChecked():\\n # On affiche un fond de carte de la France par défaut\\n # S'il n'est pas déjà afficher\\n estAffiche = False\\n for lyr in QgsMapLayerRegistry.instance().mapLayers().values():\\n if lyr.name() == \\\"France\\\":\\n estAffiche = True\\n break \\n if not estAffiche :\\n uri = os.path.join(os.path.dirname(__file__) + str('/resources/fond_de_carte/france/'),'France.shp')\\n #fond_path = ':/plugins/PluginChoucas/fond_de_carte/France.shp'\\n \\n vlayer = QgsVectorLayer(uri, \\\"France\\\", \\\"ogr\\\")\\n # symbol = QgsMarkerSymbolV2.createSimple({'name': '', 'color': 'land' })\\n # vlayer.rendererV2().setSymbol(symbol)\\n QgsMapLayerRegistry.instance().addMapLayer(vlayer) \\n \\n \\n # On recupere l'emprise selectionee\\n selectedEmpriseIndex = self.dlg.comboEmprise.currentIndex()\\n selectedEmprise = self.cleEmprise[selectedEmpriseIndex]\\n tabCleEmprise = selectedEmprise.split(\\\"#\\\")\\n \\n if self.dlg.comboEmprise.count() == 0:\\n typeemprise = ''\\n codeemprise = ''\\n else:\\n typeemprise = tabCleEmprise[0]\\n codeemprise = tabCleEmprise[1]\\n \\n \\n # On recupere la source selectionee\\n selectedSourceIndex = self.dlg.comboSources.currentIndex()\\n selectedSource = self.list_sources[selectedSourceIndex]\\n self.source = selectedSource\\n \\n # On recupere l entite selectionee\\n selectedEntityIndex = self.dlg.comboEntities.currentIndex()\\n selectedEntity = self.list_entities[selectedEntityIndex]\\n self.entity = selectedEntity\\n \\n # On definit le proxy\\n util.chargeProxy(self.dlg.cb_proxy)\\n \\n # On calcule la bbox\\n # Ecrins\\n projection = util.get_first_object(self.root, self.source, 'projection')\\n empriseSelect = util.get_first_object(self.root, self.source, 'emprise')\\n # print (\\\"emprise catalogue pour la source \\\" + self.source + \\\" = \\\" + empriseSelect)\\n if empriseSelect == 'none':\\n card = None\\n else:\\n card = bbox.getBbox(typeemprise, codeemprise, projection)\\n\\n style = {}\\n style['couleur'] = util.get_first_object(self.root, self.source, 'couleur')\\n style['svg'] = util.get_second_object(self.root, self.source, self.entity, 'svg')\\n style['size'] = util.get_second_object(self.root, self.source, self.entity, 'size')\\n style['forme'] = util.get_second_object(self.root, self.source, self.entity, 'forme')\\n \\n typeGeom = util.get_second_object(self.root, self.source, self.entity, 'geom')\\n urlQGis = typeGeom + '?crs=' + projection\\n\\n # Si le mode choisi est [En ligne]\\n if self.dlg.rb_online.isChecked():\\n \\n # On recupere dans le catalogue \\n flux = util.get_first_object(self.root, self.source, 'flux')\\n if flux == 'API':\\n urlBrute = util.get_second_object(self.root, self.source, self.entity, 'url')\\n else:\\n urlBrute = ''\\n \\n attributs = util.get_attributs(self.root, self.source, self.entity)\\n \\n nomLayer = self.source + '-' + self.entity + '-' + codeemprise\\n \\n if self.source == 'osm':\\n \\n filtres = util.getFiltres(self.root, self.source, self.entity)\\n osm.loadOSM(nomLayer, card, filtres, attributs, style)\\n \\n elif self.source == 'rando.ecrins-parcnational.fr' and typeGeom == 'Point':\\n \\n geotrek.loadPointEcrin(style)\\n \\n # QMessageBox.information(None, \\\"OUPS:\\\", \\n # 'Departement non disponible pour cet API')\\n else:\\n if card == None:\\n url = urlBrute\\n else:\\n # Par BBOX\\n url = online.getUrlWithBBox(card, urlBrute)\\n # On ajoute la couche\\n online.displayLayer(url, urlQGis, self.source, nomLayer, typeGeom, attributs, style)\\n \\n # Si le mode choisi est [Hors ligne]\\n if self.dlg.rb_offline.isChecked():\\n offline.offline(self.root, self.source, self.entity)\\n \\n if self.dlg.rb_local.isChecked():\\n \\n urlBrute = util.get_second_object(self.root, self.source, self.entity, 'url')\\n nomLayer = self.source + '-' + self.entity + '-' + codeemprise\\n # On prend tous les attribts quand c'est un fichier\\n local.loadPoint(nomLayer, urlBrute, urlQGis, card, style)\",\n \"def perimeter(self):\",\n \"def calculatePieces(self):\\n pass;\",\n \"def obj(self) -> object:\\n pass\",\n \"def get_objects_data(self):\\n pass\",\n \"def _target_filter(self, obj):\\r\\n return type(obj).__name__ in ['Cube'] and not obj.is_grasped # List because may be extended to other objects.\\r\",\n \"def post_init(self):\\n val = get_constant(\\\"pi_invention.pieces_a_joindre\\\")\\n pieces_a_joindre = FieldSet(\\\"pieces_a_joindre\\\", \\\"Pièces à joindre\\\", [HTML(val)])\\n self.fieldsets += [pieces_a_joindre]\\n\\n conditions = get_constant(\\\"pi_invention.conditions\\\")\\n self.conditions = conditions\",\n \"def auto_rivet():\\n sel_list = pm.ls(sl=1)\\n\\n # the last selection is the mesh\\n objects = sel_list[:-1]\\n geo = sel_list[-1]\\n\\n # get the closest point to the surface\\n geo_shape = geo.getShape()\\n\\n follicles = []\\n\\n for obj in objects:\\n # pivot point of the obj\\n pivot = obj.getRotatePivot(space='world')\\n uv = geo_shape.getUVAtPoint(pivot, space='world')\\n\\n # create a hair follicle\\n follicle = pm.nt.Follicle()\\n follicles.append(follicle)\\n follicle.simulationMethod.set(0)\\n geo_shape.worldMatrix >> follicle.inputWorldMatrix\\n geo_shape.outMesh >> follicle.inputMesh\\n follicle.parameterU.set(uv[0])\\n follicle.parameterV.set(uv[1])\\n\\n # parent the object to the follicles transform node\\n follicle_transform = follicle.getParent()\\n\\n follicle.outTranslate >> follicle_transform.translate\\n follicle.outRotate >> follicle_transform.rotate\\n\\n pm.parent(obj, follicle_transform)\\n\\n return follicles\",\n \"def visible_objects_and_duplis():\\n\\n for obj in context.visible_objects:\\n if obj.type == 'MESH':\\n if obj.modeling_cloth: \\n yield (obj, obj.matrix_world.copy())\",\n \"def visible_objects_and_duplis():\\n\\n for obj in context.visible_objects:\\n if obj.type == 'MESH':\\n if obj.modeling_cloth: \\n yield (obj, obj.matrix_world.copy())\",\n \"def afficherOBJ(self):\\r\\n str_abr = self.abr.afficher()## appel de l'affichage d'un ABR\\r\\n return str(self.debut)+':'+str(self.fin)+';'+str_abr ##concaténation du resultat\\r\",\n \"def afficher(self, personnage, jeu, partie):\\n en_main = jeu.en_main.get(personnage)\\n tableau = jeu.tableau\\n if en_main:\\n msg = \\\"Dans votre main, vous avez {} et {}.\\\".format(\\n en_main[0].nom_complet_indefini,\\n en_main[1].nom_complet_indefini)\\n else:\\n msg = \\\"Vous n'avez encore rien dans votre main.\\\"\\n \\n if tableau:\\n tableau = [piece.nom_complet_indefini for piece in tableau]\\n aff_tableau = \\\", \\\".join(tableau[:-1]) + \\\" et \\\" + tableau[-1]\\n msg += \\\"\\\\nSur le tableau se trouve {}.\\\".format(aff_tableau)\\n\\n if partie.tour is personnage:\\n msg += \\\"\\\\nC'est votre tour.\\\"\\n \\n return msg\",\n \"def part_id(self):\\n ...\",\n \"def part(self):\\n return self._modelPart\",\n \"def __str__(self):\\r\\n return self.afficherOBJ()\",\n \"def test_data_object_vaporise(self):\\n pass\",\n \"def other_object(img):\\n return img[500:570, 1000:1070]\",\n \"def object_for(objectid):\",\n \"def properties(self):\",\n \"def properties(self):\",\n \"def properties(self):\",\n \"def _blob(self):\\n self.__rewrite_sldIdLst()\\n # # at least the following needs to be added before using\\n # # _reltype_ordering again for Presentation\\n # self.__rewrite_notesMasterIdLst()\\n # self.__rewrite_handoutMasterIdLst()\\n # self.__rewrite_sldMasterIdLst()\\n return super(Presentation, self)._blob\",\n \"def get_obj():\\n idPadre = request.args.get('id')\\n nombrePadre = nombreObjeto(idPadre)\\n global variablesActualizables\\n variablesActualizables = -1\\n print(\\\"consulta objetos id: {}, padre: {}\\\".format(idPadre,nombrePadre))\\n\\n try:\\n objetos = g.db.query(Objetos).filter_by(NombreObjetoPadreObjeto=nombrePadre).filter_by(Activo=True).all()\\n except NoResultFound:\\n print \\\"NO resultados para el padre {}\\\".format(nombrePadre)\\n objetos = []\\n\\n try:\\n funciones = g.db.query(Funciones).filter_by(NombreObjetoPadreFuncion=idPadre).all()\\n except NoResultFound:\\n print \\\"NO funciones para el padre {}\\\".format(nombrePadre)\\n funciones = []\\n\\n try:\\n variables = g.db.query(Variables).filter_by(NombreObjetoPadreVariable=idPadre).all()\\n except NoResultFound:\\n print \\\"NO variables para el padre {}\\\".format(nombrePadre)\\n variables = []\\n if nombrePadre != None:\\n Padre=\\\"Elementos de {}\\\".format(nombrePadre)\\n else:\\n Padre=\\\"Objetos Activos\\\"\\n return render_template('show_objects.html',padre=Padre, objetos=objetos, funciones=funciones, variables=variables)\",\n \"def present(self):\",\n \"def fields(self):\",\n \"def __init__(self):\\n mi_parqueo = list()\",\n \"def part_6():\\n\\n raise NotImplementedError\",\n \"def Item(self) -> object:\",\n \"def Item(self) -> object:\",\n \"def COMBI(self):\\n\\n self.FB()\\n self.LAT()\\n self.ROT()\",\n \"def __init__(self):\\n self.nombre_roues = 4\\n self.nombre_fauteils = 1\\n self.moteur = False\\n self.volant = True\",\n \"def __init__(self):\\n self.tours = []\\n self.grille = Grille()\",\n \"def get_object_to_run(self):\",\n \"def __init__(self, piece):\\n self.piece = piece\",\n \"def afficher_carte(self):\\n print(self)\",\n \"def visible_objects_and_duplis():\\r\\n \\r\\n for obj in context.visible_objects:\\r\\n if obj.type == 'MESH':\\r\\n yield (obj, obj.matrix_world.copy())\\r\\n \\r\\n if obj.dupli_type != 'NONE':\\r\\n obj.dupli_list_create(scene)\\r\\n for dob in obj.dupli_list:\\r\\n obj_dupli = dob.object\\r\\n if obj_dupli.type == 'MESH':\\r\\n yield (obj_dupli, dob.matrix.copy())\\r\\n \\r\\n obj.dupli_list_clear()\",\n \"def get_is_por_holder(self, obj):\\n user = self.context['request'].user\\n if not user.is_authenticated:\\n return False\\n # pylint: disable=no-member\\n profile = UserProfile.objects.get(user=user)\\n\\n if profile == obj.club.secy:\\n return True\\n\\n if profile in obj.club.joint_secy.all():\\n return True\\n\\n if profile == obj.club.council.gensec:\\n return True\\n\\n if profile in obj.club.council.joint_gensec.all():\\n return True\\n\\n return False\",\n \"def get_mvts(self, plateau):\\n if self.type == \\\"p\\\": #Pion\\n if self.color == \\\"w\\\":\\n diags = [[self.x-1, self.y+1],[self.x+1, self.y+1]] #Mouvements possibles de diagonales\\n faces = [[self.x, self.y+1]] #Mouvements possibles de face\\n if not self.moved: #Si le pion n'a pas encore bougé de la partie\\n faces.append([self.x, self.y+2])\\n else:\\n diags = [[self.x-1, self.y-1], [self.x+1, self.y-1]]\\n faces = [[self.x, self.y-1]] #Mouvements possibles de \\n if not self.moved:\\n faces.append([self.x, self.y-2])\\n pos = [] #Position de déplacement validées\\n for d in diags:\\n if verif_case(d[0], d[1]): #Si la case est sur le plateau \\n pion = plateau.get_pion(d[0],d[1])\\n if pion != None and pion.color != self.color: #Si il y a un pion ennemi\\n pos.append(d)\\n for f in faces: \\n if verif_case(f[0],f[1]):\\n pion = plateau.get_pion(f[0], f[1])\\n if pion == None: #Si il n'y a pas de pion\\n pos.append(f)\\n return pos\\n elif self.type == \\\"t\\\": #Tour\\n pos = []\\n dir = [[1,0],[-1,0],[0,1],[0,-1]] #4 directions possibles\\n for d in dir:\\n x,y = self.x+d[0],self.y+d[1] #Projection de position\\n while verif_case(x,y): #Tant que (x, y) est sur le plateau\\n pion = plateau.get_pion(x, y)\\n if pion != None: #Si il y a un pion\\n if pion.color != self.color: #Si il n'est pas allié\\n pos.append([x,y])\\n break\\n pos.append([x,y])\\n x += d[0]\\n y += d[1]\\n return pos\\n elif self.type == \\\"c\\\": #Cavalier\\n l = [-2,-1,1,2]\\n mvts = [[x,y] for x in l for y in l if abs(x)!=abs(y)]\\n pos = []\\n for m in mvts:\\n x = self.x + m[0]\\n y = self.y + m[1]\\n if verif_case(x,y):\\n pion = plateau.get_pion(x, y)\\n if pion == None or pion.color != self.color:\\n pos.append([x, y])\\n return pos\\n elif self.type == \\\"f\\\": #Fou\\n dir = [[1,1],[-1,1],[-1,-1],[1,-1]]\\n pos = []\\n for d in dir:\\n x,y = self.x+d[0],self.y+d[1]\\n while verif_case(x,y):\\n pion = plateau.get_pion(x, y)\\n if pion != None:\\n if pion.color != self.color:\\n pos.append([x,y])\\n break\\n pos.append([x,y])\\n x += d[0]\\n y += d[1]\\n return pos\\n elif self.type == \\\"k\\\": #Roi\\n mvts = [[1,0],[-1,1],[0,-1],[-1,-1],[-1,0],[-1,1],[0,1],[1,1]] #4 mouvements possibles\\n pos = []\\n for m in mvts:\\n x = self.x + m[0]\\n y = self.y + m[1]\\n if verif_case(x, y):\\n pion = plateau.get_pion(x, y)\\n if pion == None or pion.color != self.color:\\n pos.append([self.x + m[0], self.y + m[1]])\\n return pos\\n elif self.type == \\\"q\\\": #Dame\\n pos = []\\n dir = [[1,0],[1,-1],[0,-1],[-1,-1],[-1,0],[-1,1],[0,1],[1,1]]\\n for d in dir:\\n x,y = self.x+d[0],self.y+d[1]\\n while verif_case(x,y):\\n pion = plateau.get_pion(x, y)\\n if pion != None:\\n if pion.color != joueur:\\n pos.append([x,y])\\n break\\n pos.append([x,y])\\n x += d[0]\\n y += d[1]\\n return pos\",\n \"def cliquer_sur_unité(self):\",\n \"def __init__(self,donnee_admin):\\n self.ref = donnee_admin[0]\\n self.date_saisie = donnee_admin[1]\\n self.remplissage = donnee_admin[2]\\n self.date_entree = donnee_admin[3]\\n self.date_sortie = donnee_admin[4]\",\n \"def area(self):\",\n \"def actualise_fenetre(self,plateau,fenetre,joueur,info,bouton,etape_texte):\\n\\n self.affiche_plateau(plateau,fenetre)\\n liste_im_joueur = [pygame.image.load(\\\"joueur\\\"+str(i)+\\\".png\\\").convert_alpha() for i in range(1,5)]\\n for i in range (4) :\\n x_joueur = 60\\n y_joueur = 60\\n liste_im_joueur[i] = pygame.transform.scale(liste_im_joueur[i], (int(x_joueur),int(y_joueur)))\\n\\n for i in range(len(plateau.dico_joueurs)) :\\n fenetre.blit(liste_im_joueur[i],(1030,320+i*80))\\n fenetre.blit(police_small.render(str(plateau.dico_joueurs[i].nom) + \\\" : \\\",False,pygame.Color(\\\"#000000\\\")),(800,340+i*75))\\n fenetre.blit(police1.render(\\\"Score : \\\"+str(plateau.dico_joueurs[i].points),False,pygame.Color(\\\"#000000\\\")),(800,340+i*75+15))\\n fenetre.blit(police1.render(\\\"Ordre de mission : \\\"+str(sorted(plateau.dico_joueurs[i].fantome_target)),False,pygame.Color(\\\"#000000\\\")),(800,340+i*75+30))\\n fenetre.blit(police1.render(\\\"Jokers restants : \\\"+str(plateau.dico_joueurs[i].nb_joker),False,pygame.Color(\\\"#000000\\\")),(800,340+i*75+45))\\n \\n #test texte pour afficher le joueur qui joue\\n if self.turn == True :\\n fenetre.blit(police.render(\\\"C'est à vous de jouer\\\",False,pygame.Color(0,0,0)),(800,240))\\n else:\\n fenetre.blit(police.render(\\\"C'est le tour de votre adversaire\\\",False,pygame.Color(0,0,0)),(800,240))\\n \\n #affichage du message d'erreur\\n for i in range(len(info)) : \\n fenetre.blit(police.render(info[i],False,pygame.Color(\\\"#000000\\\")),(760,180+i*20))\\n \\n fenetre.blit(police.render(etape_texte,False,pygame.Color(\\\"#000000\\\")),(760,160))\\n \\n \\n bouton.draw(fenetre)\\n \\n pygame.display.flip()\",\n \"def partid(self): # -> None:\\n ...\",\n \"def extra_object_files(self):\",\n \"def chercherChemin(self):\\n\\n \\n liste=self._circuit.vue(self.x,self.y,self.rayonVision)\\n \\n listeSuppr=[]\\n couche_vehicule= self._circuit.Couche_vehicules\\n \\n for case in liste :\\n #on élimine les cases infranchissbles les cases qui ne sont pas sur le chemin à suivre \\n\\n if self._circuit.numeroWayPoint(case[0],case[1])==0 or ( self._circuit.numeroWayPoint(self.x,self.y)!=self._circuit.lastWayPoint and self._circuit.numeroWayPoint(case[0],case[1])<= self._circuit.numeroWayPoint(self.x,self.y)) or( self._circuit.numeroWayPoint(case[0],case[1])>= 5*self._circuit.numeroWayPoint(self.x,self.y) and self._circuit.numeroWayPoint(self.x,self.y)!=0) or ( self._circuit.numeroWayPoint(self.x,self.y)==self._circuit.lastWayPoint and self._circuit.numeroWayPoint(case[0],case[1])== self._circuit.numeroWayPoint(self.x,self.y)) or self._circuit.plateau[case[1],case[0],couche_vehicule]!=None:#on élimine les points derrière\\n \\n listeSuppr.append(case)\\n\\n \\n for case in listeSuppr:\\n \\n liste.remove(case)\\n \\n if len(liste)>=1:\\n l=liste[0]\\n\\n for nour in liste :\\n \\n if distance((self.x,self.y),(l[0],l[1])) > distance((self.x,self.y),(nour[0],nour[1])):\\n l=nour\\n pasx=0\\n pasy=0\\n if self.x<l[0] : \\n pasx=1\\n elif self.x>l[0] :\\n pasx=-1\\n if self.y<l[1] : \\n pasy=1\\n elif self.y>l[1] :\\n pasy=-1\\n debug.dprint(\\\" id {} {}:({},{}) Waypoint {} Point:({},{}) WayPoint {} vitesse :{} reservoir:{}\\\".format(self.id,self.typeV,self.x,self.y,self._circuit.numeroWayPoint(self.x,self.y),l[0],l[1],self._circuit.numeroWayPoint(l[0],l[1]),self.vitesse,self.reservoir))\\n self.orientation=atan2(pasy,pasx)\\n\\n self.vitesse=1\\n\\n debug.dprint(self) \\n \\n super().deplacer()\\n \\n\\n self.rayonVision=4\\n else :# on augemente le rayon de vision au cas ou toutes les cases sont occupées ou non franchissables\\n self.rayonVision*=3\",\n \"def get(self, obj):\",\n \"def __sub__(self,other):\\n\\t\\treal = self.realPart - other.realPart\\n\\t\\timaginary = self.imaginaryPart - other.imaginaryPart\\n\\n\\t\\t#create and return complexNumber\\n\\t\\treturn real,imaginary\",\n \"def test_data_object_get_details(self):\\n pass\",\n \"def __getitem__(self, index):\\n path, name, txt = self.imgs[index]\\n img = self.loader(path)\\n\\n img_size = img.size\\n img_size = (400,400)\\n\\n loader = loadjson\\n \\n data = loader(txt, self.objectsofinterest,img)\\n\\n pointsBelief = data['pointsBelief'] \\n objects_centroid = data['centroids']\\n points_all = data['points']\\n points_keypoints = data['keypoints_2d']\\n translations = torch.from_numpy(np.array(\\n data['translations'])).float()\\n rotations = torch.from_numpy(np.array(\\n data['rotations'])).float() \\n\\n if len(points_all) == 0:\\n points_all = torch.zeros(1, 10, 2).double()\\n \\n # self.save == true assumes there is only \\n # one object instance in the scene. \\n if translations.size()[0] > 1:\\n translations = translations[0].unsqueeze(0)\\n rotations = rotations[0].unsqueeze(0)\\n\\n # If there are no objects, still need to return similar shape array\\n if len(translations) == 0:\\n translations = torch.zeros(1,3).float()\\n rotations = torch.zeros(1,4).float()\\n\\n # Camera intrinsics\\n path_cam = path.replace(name,'_camera_settings.json')\\n with open(path_cam) as data_file: \\n data = json.load(data_file)\\n # Assumes one camera\\n cam = data['camera_settings'][0]['intrinsic_settings']\\n\\n matrix_camera = np.zeros((3,3))\\n matrix_camera[0,0] = cam['fx']\\n matrix_camera[1,1] = cam['fy']\\n matrix_camera[0,2] = cam['cx']\\n matrix_camera[1,2] = cam['cy']\\n matrix_camera[2,2] = 1\\n\\n # Load the cuboid sizes\\n path_set = path.replace(name,'_object_settings.json')\\n with open(path_set) as data_file: \\n data = json.load(data_file)\\n\\n cuboid = torch.zeros(1)\\n\\n if self.objectsofinterest is None:\\n cuboid = np.array(data['exported_objects'][0]['cuboid_dimensions'])\\n else:\\n for info in data[\\\"exported_objects\\\"]:\\n if self.objectsofinterest in info['class']:\\n cuboid = np.array(info['cuboid_dimensions'])\\n\\n img_original = img.copy() \\n\\n \\n def Reproject(points,tm, rm):\\n \\\"\\\"\\\"\\n Reprojection of points when rotating the image\\n \\\"\\\"\\\"\\n proj_cuboid = np.array(points)\\n\\n rmat = np.identity(3)\\n rmat[0:2] = rm\\n tmat = np.identity(3)\\n tmat[0:2] = tm\\n\\n new_cuboid = np.matmul(\\n rmat, np.vstack((proj_cuboid.T, np.ones(len(points)))))\\n new_cuboid = np.matmul(tmat, new_cuboid)\\n new_cuboid = new_cuboid[0:2].T\\n\\n return new_cuboid\\n\\n # Random image manipulation, rotation and translation with zero padding\\n dx = round(np.random.normal(0, 2) * float(self.random_translation[0]))\\n dy = round(np.random.normal(0, 2) * float(self.random_translation[1]))\\n angle = round(np.random.normal(0, 1) * float(self.random_rotation))\\n\\n tm = np.float32([[1, 0, dx], [0, 1, dy]])\\n rm = cv2.getRotationMatrix2D(\\n (img.size[0]/2, img.size[1]/2), angle, 1)\\n\\n for i_objects in range(len(pointsBelief)):\\n points = pointsBelief[i_objects]\\n new_cuboid = Reproject(points, tm, rm)\\n pointsBelief[i_objects] = new_cuboid.tolist()\\n objects_centroid[i_objects] = tuple(new_cuboid.tolist()[-1])\\n pointsBelief[i_objects] = list(map(tuple, pointsBelief[i_objects]))\\n\\n for i_objects in range(len(points_keypoints)):\\n points = points_keypoints[i_objects]\\n new_cuboid = Reproject(points, tm, rm)\\n points_keypoints[i_objects] = new_cuboid.tolist()\\n points_keypoints[i_objects] = list(map(tuple, points_keypoints[i_objects]))\\n \\n image_r = cv2.warpAffine(np.array(img), rm, img.size)\\n result = cv2.warpAffine(image_r, tm, img.size)\\n img = Image.fromarray(result)\\n\\n # Note: All point coordinates are in the image space, e.g., pixel value.\\n # This is used when we do saving --- helpful for debugging\\n if self.save or self.test: \\n # Use the save to debug the data\\n if self.test:\\n draw = ImageDraw.Draw(img_original)\\n else:\\n draw = ImageDraw.Draw(img)\\n \\n # PIL drawing functions, here for sharing draw\\n def DrawKeypoints(points):\\n for key in points:\\n DrawDot(key,(12, 115, 170),7) \\n \\n def DrawLine(point1, point2, lineColor, lineWidth):\\n if not point1 is None and not point2 is None:\\n draw.line([point1,point2],fill=lineColor,width=lineWidth)\\n\\n def DrawDot(point, pointColor, pointRadius):\\n if not point is None:\\n xy = [point[0]-pointRadius, point[1]-pointRadius, point[0]+pointRadius, point[1]+pointRadius]\\n draw.ellipse(xy, fill=pointColor, outline=pointColor)\\n\\n def DrawCube(points, which_color = 0, color = None):\\n '''Draw cube with a thick solid line across the front top edge.'''\\n lineWidthForDrawing = 2\\n lineColor1 = (255, 215, 0) # yellow-ish\\n lineColor2 = (12, 115, 170) # blue-ish\\n lineColor3 = (45, 195, 35) # green-ish\\n if which_color == 3:\\n lineColor = lineColor3\\n else:\\n lineColor = lineColor1\\n\\n if not color is None:\\n lineColor = color \\n\\n # draw front\\n DrawLine(points[0], points[1], lineColor, 8) #lineWidthForDrawing)\\n DrawLine(points[1], points[2], lineColor, lineWidthForDrawing)\\n DrawLine(points[3], points[2], lineColor, lineWidthForDrawing)\\n DrawLine(points[3], points[0], lineColor, lineWidthForDrawing)\\n \\n # draw back\\n DrawLine(points[4], points[5], lineColor, lineWidthForDrawing)\\n DrawLine(points[6], points[5], lineColor, lineWidthForDrawing)\\n DrawLine(points[6], points[7], lineColor, lineWidthForDrawing)\\n DrawLine(points[4], points[7], lineColor, lineWidthForDrawing)\\n \\n # draw sides\\n DrawLine(points[0], points[4], lineColor, lineWidthForDrawing)\\n DrawLine(points[7], points[3], lineColor, lineWidthForDrawing)\\n DrawLine(points[5], points[1], lineColor, lineWidthForDrawing)\\n DrawLine(points[2], points[6], lineColor, lineWidthForDrawing)\\n\\n # draw dots\\n DrawDot(points[0], pointColor=(255,255,255), pointRadius = 3)\\n DrawDot(points[1], pointColor=(0,0,0), pointRadius = 3)\\n\\n # Draw all the found objects. \\n for points_belief_objects in pointsBelief:\\n DrawCube(points_belief_objects)\\n for keypoint in points_keypoints:\\n DrawKeypoints(keypoint)\\n\\n img = self.transform(img)\\n \\n return {\\n \\\"img\\\":img,\\n \\\"translations\\\":translations,\\n \\\"rot_quaternions\\\":rotations,\\n 'pointsBelief':np.array(points_all[0]),\\n 'matrix_camera':matrix_camera,\\n 'img_original': np.array(img_original),\\n 'cuboid': cuboid,\\n 'file_name':name,\\n }\\n\\n # Create the belief map\\n beliefsImg = CreateBeliefMap(\\n img, \\n pointsBelief=pointsBelief,\\n nbpoints = 9,\\n sigma = self.sigma)\\n\\n # Create the image maps for belief\\n transform = transforms.Compose([transforms.Resize(min(img_size))])\\n totensor = transforms.Compose([transforms.ToTensor()])\\n\\n for j in range(len(beliefsImg)):\\n beliefsImg[j] = self.target_transform(beliefsImg[j])\\n # beliefsImg[j].save('{}.png'.format(j))\\n beliefsImg[j] = totensor(beliefsImg[j])\\n\\n beliefs = torch.zeros((len(beliefsImg),beliefsImg[0].size(1),beliefsImg[0].size(2)))\\n for j in range(len(beliefsImg)):\\n beliefs[j] = beliefsImg[j][0]\\n \\n\\n # Create affinity maps\\n scale = 8\\n if min (img.size) / 8.0 != min (img_size)/8.0:\\n # print (scale)\\n scale = min (img.size)/(min (img_size)/8.0)\\n\\n affinities = GenerateMapAffinity(img,8,pointsBelief,objects_centroid,scale)\\n img = self.transform(img)\\n\\n # Transform the images for training input\\n w_crop = np.random.randint(0, img.size[0] - img_size[0]+1)\\n h_crop = np.random.randint(0, img.size[1] - img_size[1]+1)\\n transform = transforms.Compose([transforms.Resize(min(img_size))])\\n totensor = transforms.Compose([transforms.ToTensor()])\\n\\n if not self.normal is None:\\n normalize = transforms.Compose([transforms.Normalize\\n ((self.normal[0],self.normal[0],self.normal[0]),\\n (self.normal[1],self.normal[1],self.normal[1])),\\n AddNoise(self.noise)])\\n else:\\n normalize = transforms.Compose([AddNoise(0.0001)])\\n \\n img = crop(img,h_crop,w_crop,img_size[1],img_size[0])\\n img = totensor(img)\\n\\n img = normalize(img)\\n\\n w_crop = int(w_crop/8)\\n h_crop = int(h_crop/8)\\n\\n affinities = affinities[:,h_crop:h_crop+int(img_size[1]/8),w_crop:w_crop+int(img_size[0]/8)]\\n beliefs = beliefs[:,h_crop:h_crop+int(img_size[1]/8),w_crop:w_crop+int(img_size[0]/8)]\\n\\n if affinities.size()[1] == 49 and not self.test:\\n affinities = torch.cat([affinities,torch.zeros(16,1,50)],dim=1)\\n\\n if affinities.size()[2] == 49 and not self.test:\\n affinities = torch.cat([affinities,torch.zeros(16,50,1)],dim=2)\\n\\n return {\\n 'img':img, \\n \\\"affinities\\\":affinities, \\n 'beliefs':beliefs,\\n }\",\n \"def test_01_BuildObjects(self):\\n # print(PrettyFormatAny.form(self.m_pyhouse_obj, 'A1-01-A - Main', 190))\\n # print(PrettyFormatAny.form(self.m_pyhouse_obj.House, 'A1-02-B - House', 190))\\n # print(PrettyFormatAny.form(self.m_pyhouse_obj.House.Location, 'A1-01-C - Location', 190))\\n self.assertIsInstance(self.m_pyhouse_obj, PyHouseInformation)\\n self.assertIsInstance(self.m_pyhouse_obj.House, HouseInformation)\\n self.assertIsInstance(self.m_pyhouse_obj.House.Location, LocationInformationPrivate)\",\n \"def __init__(self, altura, peso, edad):\\n\\t\\tself.altura = altura # OJO TODAS LAS VARIABLES SON PUBLICAS \\n\\t\\tself.peso = peso \\n\\t\\tself.edad = edad\\n\\t\\tself.profesion = \\\"\\\" # esta la inicializamos nosotros\\n\\t\\tself.lista_tareas = []\\n\\t\\tself.__privado = 1 # este atributo es privado no podemos acceder a el desde fuera\",\n \"def nextIntersectors(self, inter):\\n assert self.poly1.pnFacesInPoly() and self.poly2.pnFacesInPoly()\\n otherFInters = self.getIntersectorList(inter.f.vertices)\\n # First intersector\\n pInters = self.getIntersectorList(inter.pe.pFace.vertices)\\n otherI1 = next(filter(lambda x: x is not None and x.f == inter.f and x != inter,\\n pInters),\\n None)\\n if otherI1 is None:\\n # The pFace does not intersect inter.f a second time,\\n # looking for a place where inter.f intersects the pFace\\n otherI1 = next(filter(lambda x: x is not None and x.f == inter.pe.pFace,\\n otherFInters),\\n None)\\n if otherI1 is None:\\n # polyhedron(inter.f.vertices + inter.pe.pFace.vertices,\\n # inter.pe.pFace.edges() + inter.f.edges(),\\n # [inter.f, inter.pe.pFace]).plot(True, col=('none', 'k', 'r'))\\n # # print(inter.f, '\\\\n\\\\n', inter.pe.pFace)\\n assert all(v in self.poly1.vertices for v in inter.f.vertices) or all(v in self.poly2.vertices for v in inter.f.vertices)\\n assert self.poly1.facesInVertices() and self.poly2.facesInVertices()\\n assert self.poly1.pnFacesInPoly() and self.poly2.pnFacesInPoly()\\n assert self.poly1.nonDoubleVertices() and self.poly2.nonDoubleVertices()\\n # # print('\\\\n', [(i, i.f) for i in filter(lambda x: x is not False, pInters)])\\n # # print([sum(min(v.dist(v2) for v2 in inter.f.vertices) for v in i.f.vertices) for i in filter(lambda x: x is not False, pInters)])\\n # # print('\\\\n', [(i, i.f) for i in filter(lambda x: x is not False, otherFInters)])\\n # # print([sum(min(v.dist(v2) for v2 in inter.pe.pFace.vertices) for v in i.f.vertices) for i in filter(lambda x: x is not False, otherFInters)])\\n raise ValueError('No intersector found')\\n # Second intersector\\n nInters = self.getIntersectorList(inter.pe.nFace.vertices)\\n otherI2 = next(filter(lambda x: x is not None and x.f == inter.f and x != inter,\\n nInters),\\n None)\\n if otherI2 is None:\\n # The nFace does not intersect inter.f a second time,\\n # looking for a place where inter.f intersects the nFace\\n otherI2 = next(filter(lambda x: x is not None and x.f == inter.pe.nFace,\\n otherFInters),\\n None)\\n if otherI2 is None:\\n polyhedron(inter.f.vertices + inter.pe.nFace.vertices,\\n inter.pe.nFace.edges() + inter.f.edges(),\\n [inter.f, inter.pe.nFace]).plot(True, col=('none', 'k', 'r'))\\n # # print(inter.f, inter.pe.pFace)\\n raise ValueError('No intersector found')\\n inter.adjacents = (otherI1, otherI2)\\n return (otherI1, otherI2)\",\n \"def extract(self):\\n pass\",\n \"def objets_uniques(self):\\n objets = []\\n for membre in self.membres:\\n for objet in membre.equipe:\\n if objet.unique:\\n objets.append(objet)\\n objets.extend(objet.prototype.objets_contenus(objet))\\n if membre.tenu and membre.tenu.unique:\\n objet = membre.tenu\\n objets.append(objet)\\n objets.extend(objet.prototype.objets_contenus(objet))\\n\\n return objets\",\n \"def item_perceel_crab_adapter(obj, request):\\n return {\\n 'id': obj.id,\\n 'centroid': obj.centroid,\\n 'postadressen': obj.postadressen,\\n 'metadata': {\\n 'begin_tijd': obj.metadata.begin_tijd,\\n 'begin_datum': obj.metadata.begin_datum,\\n 'begin_bewerking': {\\n 'id': obj.metadata.begin_bewerking.id,\\n 'naam': obj.metadata.begin_bewerking.naam,\\n 'definitie': obj.metadata.begin_bewerking.definitie\\n },\\n 'begin_organisatie': {\\n 'id': obj.metadata.begin_organisatie.id,\\n 'naam': obj.metadata.begin_organisatie.naam,\\n 'definitie': obj.metadata.begin_organisatie.definitie\\n }\\n }\\n }\",\n \"def test_nbands_vrt_object(self):\\n self.assertEqual(_test_object(landsat_vrt)[0], 2)\",\n \"def __init__(self, realpart, imagpart):\\n self.r = realpart\\n self.i = imagpart\",\n \"def CL(self):\",\n \"def pickUp(self):\\n pos = self.getRoverLocation()\\n item = self.map[pos.y,pos.x]\\n if type(item) == Part:\\n self.inventory.addPart(str(item))\\n self.map[pos.y,pos.x] = None\",\n \"def partid(self): # -> Unknown:\\n ...\",\n \"def _addPredicate(self, pid, chunks):\\n parent = chunks[pid]\\n sub = None\\n obj = None\\n aux = list()\\n auxlabel = \\\"\\\"\\n # 1st round find absolute subject & object\\n for i in range(len(parent.children)):\\n child = chunks[parent.children[i]]\\n # Process by categories.\\n if child.func in SubDict:\\n sub = child\\n elif child.func in ObjDict:\\n obj = child\\n\\n # 2nd round find potential subject & object with aux.\\n for i in range(len(parent.children)):\\n child = chunks[parent.children[i]]\\n # Process by categories.\\n if child.func in SubDict or child.func in ObjDict:\\n continue\\n elif child.func in ObjPostDict:\\n if not obj and child.type in EntityTypeDict:\\n obj = child\\n else:\\n aux.append(child.id)\\n auxlabel += \\\"[{0}]\\\\n\\\".format(child.surface)\\n elif child.func in SubPassiveObjDict:\\n if parent.passive == 1:\\n if not obj and child.type in EntityTypeDict:\\n obj = child\\n elif not sub and child.type in EntityTypeDict:\\n sub = child\\n else:\\n aux.append(child.id)\\n auxlabel += \\\"[{0}]\\\\n\\\".format(child.surface)\\n else:\\n if not sub and child.type in EntityTypeDict:\\n sub = child\\n elif not obj and child.type in EntityTypeDict:\\n obj = child\\n else:\\n aux.append(child.id)\\n auxlabel += \\\"[{0}]\\\\n\\\".format(child.surface)\\n elif child.func in ObjPassiveSubDict:\\n if parent.passive == 1:\\n if not sub and child.type in EntityTypeDict:\\n sub = child\\n elif not obj and child.type in EntityTypeDict:\\n obj = child\\n else:\\n aux.append(child.id)\\n auxlabel += \\\"[{0}]\\\\n\\\".format(child.surface)\\n else:\\n if not obj and child.type in EntityTypeDict:\\n obj = child\\n elif not sub and child.type in EntityTypeDict:\\n sub = child\\n else:\\n aux.append(child.id)\\n auxlabel += \\\"[{0}]\\\\n\\\".format(child.surface)\\n else:\\n aux.append(child.id)\\n auxlabel += \\\"[{0}]\\\\n\\\".format(child.surface)\\n\\n if parent.passive == 0:\\n # Add parent and subject.\\n # if sub and obj:\\n # parent.main = \\\"<{0}>[{2}]{1}\\\".format(sub.main, parent.main, obj.main)\\n # elif sub:\\n # parent.main = \\\"<{0}>[NONE]{1}\\\".format(sub.main, parent.main)\\n # elif obj:\\n # parent.main = \\\"<NONE>[{1}]{0}\\\".format(parent.main, obj.main)\\n if sub:\\n parent.main = \\\"<{0}>{1}\\\".format(sub.main, parent.main)\\n self._addNode(parent, sub=sub.main)\\n if not self.G.has_node(sub.main):\\n self._addNode(sub)\\n self._addEdge(sub.main, parent.main, label=\\\"主体\\\\n\\\", etype=\\\"sub\\\")\\n else:\\n self._addNode(parent)\\n # Add object.\\n if obj:\\n if not self.G.has_node(obj.main):\\n self._addNode(obj)\\n self._addEdge(parent.main, obj.main, label=\\\"客体\\\\n\\\" + auxlabel, etype=\\\"obj\\\")\\n else:\\n # Add obj as sub\\n # if sub and obj:\\n # parent.main = \\\"<{0}>[{2}]{1}\\\".format(sub.main, parent.main, obj.main)\\n # elif obj:\\n # parent.main = \\\"<{0}>[NONE]{1}\\\".format(obj.main, parent.main)\\n # elif sub:\\n # parent.main = \\\"<NONE>[{1}]{0}\\\".format(parent.main, sub.main)\\n if obj:\\n parent.main = \\\"<{0}>{1}\\\".format(obj.main, parent.main)\\n self._addNode(parent, sub=obj.main)\\n if not self.G.has_node(obj.main):\\n self._addNode(obj)\\n self._addEdge(obj.main, parent.main, label=\\\"主体\\\\n\\\", etype=\\\"sub\\\")\\n else:\\n self._addNode(parent)\\n # Add sub as obj\\n if sub:\\n if not self.G.has_node(sub.main):\\n self._addNode(sub)\\n self._addEdge(parent.main, sub.main, label=\\\"客体\\\\n\\\", etype=\\\"obj\\\")\\n # # Add obj as aux.\\n # if obj:\\n # aux.append(obj.id)\\n # auxlabel += \\\"[{0}]\\\\n\\\".format(obj.surface)\\n self._processAux(aux, parent.main, chunks)\",\n \"def writeGroundPlane(self,obj,renderer):\\n\\n result = \\\"\\\"\\n bbox = FreeCAD.BoundBox()\\n for view in obj.Group:\\n if view.Source and hasattr(view.Source,\\\"Shape\\\") and hasattr(view.Source.Shape,\\\"BoundBox\\\"):\\n bbox.add(view.Source.Shape.BoundBox)\\n if bbox.isValid():\\n import Part\\n margin = bbox.DiagonalLength/2\\n p1 = FreeCAD.Vector(bbox.XMin-margin,bbox.YMin-margin,0)\\n p2 = FreeCAD.Vector(bbox.XMax+margin,bbox.YMin-margin,0)\\n p3 = FreeCAD.Vector(bbox.XMax+margin,bbox.YMax+margin,0)\\n p4 = FreeCAD.Vector(bbox.XMin-margin,bbox.YMax+margin,0)\\n\\n # create temporary object. We do this to keep the renderers code as simple as possible:\\n # they only need to deal with one type of object: RenderView objects\\n dummy1 = FreeCAD.ActiveDocument.addObject(\\\"Part::Feature\\\",\\\"renderdummy1\\\")\\n dummy1.Shape = Part.Face(Part.makePolygon([p1,p2,p3,p4,p1]))\\n dummy2 = FreeCAD.ActiveDocument.addObject(\\\"App::FeaturePython\\\",\\\"renderdummy2\\\")\\n View(dummy2)\\n dummy2.Source = dummy1\\n ViewProviderView(dummy2.ViewObject)\\n FreeCAD.ActiveDocument.recompute()\\n\\n result = self.writeObject(dummy2,renderer)\\n\\n # remove temp objects\\n FreeCAD.ActiveDocument.removeObject(dummy2.Name)\\n FreeCAD.ActiveDocument.removeObject(dummy1.Name)\\n FreeCAD.ActiveDocument.recompute()\\n\\n return result\",\n \"def test_api_object_partial_property(self, api_object):\\n api_object.status = 'PARTIAL'\\n assert api_object.partial\\n assert not api_object.creating\",\n \"def addReco(obj1,obj2):\\n px = obj1.px + obj2.px\\n py = obj1.py + obj2.py\\n pz = obj1.pz + obj2.pz\\n E = obj1.E + obj2.E\\n return Reco(px,py,pz,E)\",\n \"def reckon(self):\",\n \"def __init__(self, diccionario):\\n self.numero = diccionario['numero']\\n self.nombre = diccionario['equipo_nombre']\\n self.pokmov = lectores.pokemon_y_movimiento_a_tuplas(diccionario)\",\n \"def is_full(self):\",\n \"def get_product_area(self, obj):\\n\\t\\treturn obj.product.product\",\n \"def get_object(self, img):\\n objectType = 'none'\\n colourProb = np.ones((3,)) / 3.0\\n distance = 0.0\\n angle = 0.0\\n self.patternFound = False\\n \\n #patternFound, corners = self.get_corners(img)\\n self.get_corners(img)\\n \\n if (self.patternFound):\\n \\n # Determine if the object is horizontal or vertical\\n delta_x = abs(self.corners[0,0,0] - self.corners[2,0,0])\\n delta_y = abs(self.corners[0,0,1] - self.corners[2,0,1])\\n horizontal = (delta_y > delta_x)\\n if (horizontal):\\n objectType = 'horizontal'\\n else:\\n objectType = 'vertical'\\n \\n # Compute distances and angles\\n if (horizontal):\\n height = ((abs (self.corners [0,0,1] - self.corners [2,0,1]) +\\n abs (self.corners [9,0,1] - self.corners [11,0,1])) / 2.0);\\n \\n patternHeight = (self.patternSize[0]-1.0) * self.patternUnit\\n \\n else:\\n height = (abs (self.corners [0,0,1] - self.corners [9,0,1]) +\\n abs (self.corners [2,0,1] - self.corners [11,0,1])) / 2.0;\\n \\n patternHeight = (self.patternSize[1]-1.0) * self.patternUnit\\n \\n #distance = 1.0 / (0.0001 * height);\\n distance = self.intrinsic_matrix[1,1] * patternHeight / (height * 10.0) \\n\\n center = (self.corners [0,0,0] + self.corners [2,0,0] +\\n self.corners [9,0,0] + self.corners [11,0,0]) / 4.0;\\n \\n #angle = 0.0018 * center - 0.6425;\\n #angle *= -1.0;\\n angle = -np.arctan2(center - self.intrinsic_matrix[0,2], self.intrinsic_matrix[0,0])\\n \\n \\n #### Classify object by colour\\n \\n # Extract rectangle corners\\n points = np.array(\\n [self.corners [0],\\n self.corners [2],\\n self.corners [9],\\n self.corners [11]]\\n )\\n \\n points.shape = (4,2)\\n points = np.int32(points)\\n\\n # Compute region of interest\\n mask = np.zeros((self.imageSize[1], self.imageSize[0]), dtype =np.uint8) \\n cv2.fillConvexPoly (mask, points, (255, 255, 255)) \\n \\n # Compute mean colour inside region of interest\\n mean_colour = cv2.mean(img, mask);\\n \\n red = mean_colour[2];\\n green = mean_colour[1];\\n blue = mean_colour[0];\\n sum = red + green + blue;\\n\\n colourProb[0] = red / sum;\\n colourProb[1] = green / sum;\\n colourProb[2] = blue / sum;\\n \\n \\n return objectType, distance, angle, colourProb\",\n \"def partid(self): # -> int:\\n ...\",\n \"def get_object(id):\",\n \"def formulate_plan(self):\\n return NotImplemented\",\n \"def fields(self):\\n ...\",\n \"def _publish_objects(self):\\n\\n for obj in self._cozmo.world.visible_objects:\\n now = rospy.Time.now()\\n x = obj.pose.position.x * 0.001\\n y = obj.pose.position.y * 0.001\\n z = obj.pose.position.z * 0.001\\n q = (obj.pose.rotation.q1, obj.pose.rotation.q2, obj.pose.rotation.q3, obj.pose.rotation.q0)\\n self._tfb.send_transform(\\n (x, y, z), q, now, 'cube_' + str(obj.object_id), self._odom_frame\\n )\\n \\n try:\\n if obj.cube_id and self.target_cube != obj:\\n self._tfb.send_transform((x, y, z), q, now, 'cube_' + str(obj.object_id), self._odom_frame)\\n print(\\\"Found {}\\\".format(obj.cube_id))\\n if not self.cube_found and self.robots_distance_to_object(self._cozmo, obj) < 400:\\n self.target_cube = obj\\n self.cube_found = True\\n print(\\\"Locking on to {}\\\".format(obj.cube_id))\\n else:\\n if self.cube_found:\\n print(\\\"Found that one already!\\\")\\n else:\\n print(\\\"Cube too far away!\\\")\\n \\n except:\\n # print('OBJECT IS NOT A LIGHT CUBE')\\n if(obj==self._cozmo.world.charger):\\n return\\n if(obj.object_type==CustomObjectTypes.CustomType00 and (self.front_wall_pose == None or not self.front_wall_pose.is_accurate)):\\n self.front_wall_pose=obj.pose\\n self._tfb.send_transform((x, y, z), q, now, 'Front', self._odom_frame)\\n print('*** Comzmo has found the front wall! ***')\\n if(obj.object_type==CustomObjectTypes.CustomType01 and (self.ramp_bottom_pose == None or not self.ramp_bottom_pose.is_accurate)):\\n self.ramp_bottom_pose=obj.pose\\n self._tfb.send_transform((x, y, z), q, now, 'Ramp', self._odom_frame)\\n print('*** Comzmo has found the front wall! ***')\\n if(obj.object_type==CustomObjectTypes.CustomType03 and (self.drop_spot_pose == None or not self.drop_spot_pose.is_accurate)):\\n self.drop_spot_pose=obj.pose\\n self._tfb.send_transform((x, y, z), q, now, 'Drop', self._odom_frame)\\n print('*** Comzmo has found the drop Spot! ***')\\n if(obj.object_type==CustomObjectTypes.CustomType04 and (self.back_wall_pose == None or not self.back_wall_pose.is_accurate)):\\n self.back_wall_pose=obj.pose\\n self._tfb.send_transform((x, y, z), q, now, 'Back', self._odom_frame)\\n print('*** Comzmo has found the back wall! ***')\\n if(obj.object_type==CustomObjectTypes.CustomType05 and (self.drop_target_pose == None or not self.drop_target_pose.is_accurate)):\\n self.drop_target_pose=obj.pose\\n self._tfb.send_transform((x, y, z), q, now, 'Target', self._odom_frame)\\n print('*** Comzmo has found the Dropt Target! ***')\\n if(obj.object_type==CustomObjectTypes.CustomType06 and (self.drop_clue_pose == None or not self.drop_clue_pose.is_accurate)):\\n self.drop_clue_pose=obj.pose\\n self._tfb.send_transform((x, y, z), q, now, 'Clue', self._odom_frame)\\n print('*** Comzmo has found the Dropt Clue! ***')\",\n \"def representation(self) -> DrawingObjects:\\n pass\",\n \"def area(self):\\n ...\",\n \"def test_get_composition(self):\\n pass\",\n \"def __init__(self, marqueur, allele, hauteur, informatif):\\n\\n self.marqueur = marqueur\\n self.allele = allele\\n self.hauteur = hauteur\\n self.informatif = informatif\",\n \"def get_representative_data_object(self, obj):\\n if self.dim == 0:\\n # In this way, obj can be a data object and this class can be\\n # used even if the assignment is not between \\\"flattened components\\\"\\n return obj\\n else:\\n nominal_index = self.nominal_index\\n return obj[nominal_index]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6027109","0.5971558","0.58855444","0.58450836","0.5830027","0.58068246","0.5640876","0.55412936","0.55015695","0.5419981","0.53639406","0.53315765","0.5311751","0.5300423","0.5263753","0.5260159","0.52363807","0.5175996","0.51674426","0.5153223","0.5149583","0.51494414","0.50971997","0.5079156","0.50747925","0.50649875","0.505392","0.5053067","0.5029702","0.5021705","0.5011506","0.5011506","0.4998115","0.49938592","0.49812505","0.49807793","0.49649987","0.49637502","0.49522346","0.4944624","0.49399456","0.49399456","0.49399456","0.4934664","0.49281743","0.49186286","0.49087396","0.4901409","0.4888369","0.4846917","0.4846917","0.48448032","0.4843826","0.48354828","0.48310697","0.48243496","0.48227638","0.48138115","0.48136762","0.4809829","0.4806924","0.47989476","0.4796737","0.47950587","0.47945714","0.47934988","0.47900578","0.4787772","0.4786216","0.47845063","0.4779746","0.47734818","0.47689453","0.476456","0.47634026","0.4762088","0.47588068","0.47463885","0.47438294","0.4741544","0.47409165","0.47400483","0.47369465","0.4734705","0.47242036","0.47197634","0.47167602","0.4715259","0.47144356","0.47132477","0.47094613","0.47082484","0.47052252","0.4703704","0.47030944","0.47029427","0.46986896","0.4693263","0.46922907","0.4691869","0.4687016"],"string":"[\n \"0.6027109\",\n \"0.5971558\",\n \"0.58855444\",\n \"0.58450836\",\n \"0.5830027\",\n \"0.58068246\",\n \"0.5640876\",\n \"0.55412936\",\n \"0.55015695\",\n \"0.5419981\",\n \"0.53639406\",\n \"0.53315765\",\n \"0.5311751\",\n \"0.5300423\",\n \"0.5263753\",\n \"0.5260159\",\n \"0.52363807\",\n \"0.5175996\",\n \"0.51674426\",\n \"0.5153223\",\n \"0.5149583\",\n \"0.51494414\",\n \"0.50971997\",\n \"0.5079156\",\n \"0.50747925\",\n \"0.50649875\",\n \"0.505392\",\n \"0.5053067\",\n \"0.5029702\",\n \"0.5021705\",\n \"0.5011506\",\n \"0.5011506\",\n \"0.4998115\",\n \"0.49938592\",\n \"0.49812505\",\n \"0.49807793\",\n \"0.49649987\",\n \"0.49637502\",\n \"0.49522346\",\n \"0.4944624\",\n \"0.49399456\",\n \"0.49399456\",\n \"0.49399456\",\n \"0.4934664\",\n \"0.49281743\",\n \"0.49186286\",\n \"0.49087396\",\n \"0.4901409\",\n \"0.4888369\",\n \"0.4846917\",\n \"0.4846917\",\n \"0.48448032\",\n \"0.4843826\",\n \"0.48354828\",\n \"0.48310697\",\n \"0.48243496\",\n \"0.48227638\",\n \"0.48138115\",\n \"0.48136762\",\n \"0.4809829\",\n \"0.4806924\",\n \"0.47989476\",\n \"0.4796737\",\n \"0.47950587\",\n \"0.47945714\",\n \"0.47934988\",\n \"0.47900578\",\n \"0.4787772\",\n \"0.4786216\",\n \"0.47845063\",\n \"0.4779746\",\n \"0.47734818\",\n \"0.47689453\",\n \"0.476456\",\n \"0.47634026\",\n \"0.4762088\",\n \"0.47588068\",\n \"0.47463885\",\n \"0.47438294\",\n \"0.4741544\",\n \"0.47409165\",\n \"0.47400483\",\n \"0.47369465\",\n \"0.4734705\",\n \"0.47242036\",\n \"0.47197634\",\n \"0.47167602\",\n \"0.4715259\",\n \"0.47144356\",\n \"0.47132477\",\n \"0.47094613\",\n \"0.47082484\",\n \"0.47052252\",\n \"0.4703704\",\n \"0.47030944\",\n \"0.47029427\",\n \"0.46986896\",\n \"0.4693263\",\n \"0.46922907\",\n \"0.4691869\",\n \"0.4687016\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":5498,"cells":{"query":{"kind":"string","value":"Saves table's data source to given path"},"document":{"kind":"string","value":"def save(self, export_path: str):"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def save(file, table):\n pq.write_table(pa.Table.from_pandas(table), file)","def save(self):\r\n debug.write(\"[SourceRPG] Handling SQL Save\", 1)\r\n if self.path != \":memory:\":\r\n debug.write(\"Path is not in memory\", 2, False)\r\n if currentTurboMode is False:\r\n debug.write(\"We are not in turbo mode\", 2, False)\r\n self.connection.commit()\r\n debug.write(\"[SourceRPG] SQL Save handled\", 1)","def save(self, labpath: str) -> None:\n self._table.to_csv(labpath, index=False)\n print(\"# Save experimental data into {0}\".format(labpath))","def save(self, path):\n pass","def save(self, path):\n pass","def save(self, path):\n pass","def write_table(table, file_path):\n\n\twith open(file_path, 'w') as file:\n\t\tfile.write(table)","def save_table(date, table):\n if os.path.isfile(date+\".table\"):\n file_using = open(date+\".table\", \"w\")\n else:\n return False\n file_using.seek(0)\n file_using.truncate()\n for line in table:\n file_using.write(\"{},{},{},{},{}\\n\".format(line[0], line[1], line[2], line[3], line[4]))\n file_using.close()","def save(self, path: str):\n pass","def export_database(self):\n base_path = QtWidgets.QFileDialog.getSaveFileName(self, 'Save File', filter='CSV (*.csv)')\n database.export_to_csv(DB_PATH, base_path[0])","def save_dataloader(self, path: Union[str, Path]) -> None:\n if isinstance(path, str):\n path = Path(path)\n joblib.dump(self, path)","def save_table(data, out_file):\n logging.info(\"Saving table\")\n #header, data = data\n #out = pd.DataFrame(data=data, columns = header.keys())\n joblib.dump(data, out_file)","def saveData(self):\n\n\n path = QtWidgets.QFileDialog.getSaveFileName(self, 'Save File', os.getcwd())\n\n if path[0] != '':\n\n filepath, filename = os.path.split(path[0])\n\n if os.path.exists(filepath):\n\n self.getCurrentPanda().saveData(path[0])","def save(path_to_model):\n pass","def store_hive_table(data, directory, file_name):\n table_name = directory + \".\" + file_name\n data.write.saveAsTable(table_name)","def save_indicator(table, target_path, var_name, geo):\n table.to_csv(f\"{target_path}/{var_name}.{geo}.csv\", index=False)","def save_model(self, path):\n pass","def save(df, path):\n \n # Extract the directory and filename from the given path\n directory = os.path.split(path)[0]\n filename = os.path.split(path)[1]\n if directory == '':\n directory = '.'\n \n # If the directory does not exist, create it\n if not os.path.exists(directory):\n os.makedirs(directory)\n \n # The final path to save to\n savepath = os.path.join(directory, filename)\n \n # Save the dataset\n sampled_frame.to_csv(savepath, index=False)","def save_path(self):\n raise NotImplementedError","def save_path(self):\n raise NotImplementedError","def save_db(self) -> None:","def save():","def save(self):\n self.backend.save(list(self._d.items()))\n log.debug(\"save: {}\".format(self.backend.filename))","def save_table_scraperwiki(uniques,table,name):\n for row in table:\n scraperwiki.sqlite.save(\n unique_keys=uniques\n , data=row\n , table_name=name\n )","def save_datatable(datatable: ModelDatatable, folder_name):\n result = {RESULT_CODE_KEY: 0,\n RESULT_MESSAGE_KEY: \"success save datatable: \" + datatable.get_datatable_name()}\n\n # create folder if needed\n Path(folder_name).mkdir(parents=True, exist_ok=True)\n\n # check if file with datatable_name already existing and delete if existing\n path_to_file = folder_name + \"/\" + datatable.get_datatable_name()\n path = Path(path_to_file)\n if path.is_file():\n # remove file\n os.remove(path_to_file)\n\n try:\n # connect to database\n connection = sqlite3.connect(path_to_file)\n logger_log(\"established db connection. \" + \"sqlite3.version: \" + sqlite3.version)\n\n # create\n result = create_datable(connection, datatable, folder_name)\n # if not successful\n if not result[RESULT_CODE_KEY] == 0:\n return result\n\n #\n # insert data\n #\n logger_log(\"now try insert data into datatable with name: \" + datatable.get_datatable_name())\n\n # for all rows\n for row in datatable.get_rows():\n # get sql statement\n sql_statement = get_sql_statement_insert_data_for_row(row)\n # get cursor\n cursor = connection.cursor()\n # execute\n cursor.execute(sql_statement)\n logger_log(\"success insert row.\")\n\n result = {RESULT_CODE_KEY: 0,\n RESULT_MESSAGE_KEY: \"success save datatable: \" + datatable.get_datatable_name()}\n except Error as e:\n logger_log(\"failed. db operation with error: \" + e.args[0])\n result[RESULT_CODE_KEY] = -1\n result[RESULT_MESSAGE_KEY] = \"failed saving datatable. error: \" + e.args[0]\n finally:\n if connection:\n connection.commit()\n connection.close()\n logger_log(\"db connection closed: \" + datatable.get_datatable_name())\n logger_log(result[RESULT_MESSAGE_KEY])\n return result","def write (self, path):\n\t\ts=[]; add=s.append\n\t\tadd ('\\t'.join (self.schema))\n\t\tfor record in self.data:\n\t\t\tadd (record.asTabDelimitedRecord())\n\t\t\n\t\t# f = open (path, 'w')\n\t\tf = codecs.open(path, 'w', 'utf-8')\n\t\tf.write (self.linesep.join (s))\n\t\tf.close()\n\t\tprint (\"data written to \" + path)","def _save_data(self):\n self.data.to_csv('data/c&le/{}'.format(self.name))","def save_data(df, database_filename):\n engine = create_engine('sqlite:///' +database_filename)\n df.to_sql('Project2', engine, index=False)","def do_save(self, arg):\n # If no data source selected, prompt user to do so.\n try:\n self._shw.save_data ()\n except ValueError as e:\n View.info (e)\n except (OSError, AttributeError) as e:\n View.error (e)\n except Exception as e:\n View.error (e)\n else:\n View.success (\"Data is saved\")","def check_save_table_path(self, path):\r\n\r\n #check if path is empty and try to get something not empty\r\n if path == \"\":\r\n path = QFileDialog.getSaveFileName(self,caption = 'select a file to save to',\r\n directory = self.ui.saveTablePath.text(),\r\n filter=\"Text files (*.txt);;All files (*)\",\r\n options = QFileDialog.DontConfirmOverwrite)\r\n \r\n #in pyqt5 a tuple is returned, unpack it\r\n if os.environ['QT_API'] == 'pyqt5':\r\n path, _ = path\r\n \r\n if path == \"\":\r\n return \"\"\r\n else:\r\n self.ui.saveTablePath.setText(path)\r\n \r\n #do nothing if path already checked\r\n if self.saveTablePath == path:\r\n return path\r\n \r\n #if it already exists ask to overwrite or append\r\n if os.path.isfile(path):\r\n title = \"path already exists\"\r\n text = (path+\" already exists. Should it be overwritten? \\n\"\r\n + \"No will append to the file. \"\r\n + \"Choose Abort to select another file\")\r\n overwriteAnswer = QMessageBox.question(self,title,text,\r\n QMessageBox.Yes | QMessageBox.No | QMessageBox.Abort,\r\n QMessageBox.No)\r\n #if selected no, append to the file, i.e. return the path as checked\r\n if overwriteAnswer == QMessageBox.No:\r\n return path\r\n #empty path return on abort\r\n elif overwriteAnswer == QMessageBox.Abort:\r\n return \"\"\r\n #with yes the method continues and will overwrite the file\r\n \r\n #should not be a dir\r\n elif os.path.isdir(path):\r\n logging.error(\"specified path is a directory\")\r\n return \"\"\r\n \r\n #in all other cases, open it for writing and write a header to it\r\n headerString = (\"film no\\t\" \"filename\\t\" \"x0\\ty0\\tx1\\ty1\\t\"\r\n \"number of pixels\\t\" \r\n \"R_avg\\tR_std\\t\" \"G_avg\\tG_std\\t\" \"B_avg\\tB_std\\n\")\r\n with open(path,\"w\") as saveTableFile:\r\n saveTableFile.write(headerString)\r\n \r\n return path","def save(self,path=\"qtable.npy\"):\n np.save(path, self.Q)","def save_data(df, database_filename):\n engine = create_engine(f\"sqlite:///{database_filename}\")\n df.to_sql(\"YourTableName\", engine, index=False, if_exists=\"replace\")","def save(\n self,\n modelSavePath\n ):\n pass","def save_data(self):\n pass","def _save(self, dataset, path, files, copy_files=False):\n raise NotImplementedError('Loader {} does not support saving datasets.'.format(self.type()))","def save_values(self):\n # TODO: Add self.prefix and extension\n NetworkTables.saveEntries(self.file.get_filename(), prefix='/vision/' + self.name + '_')","def save_to_file(self, file_path):\n if file_path:\n f = open(file_path, 'w')\n for row in range(self.rows):\n f.write(''.join(self.data[row]) + '\\n')\n f.close()","def save_to_file(self, file_path):\n if file_path:\n f = open(file_path, 'w')\n for row in range(self.rows):\n f.write(''.join(self.data[row]) + '\\n')\n f.close()","def save(self, file_path):\n self.model.save(file_path)","def save(self, file_path):\n self.model.save(file_path)","def save(self, file_path):\n self.model.save(file_path)","def update_database():\n\n # We obtain the data from the official database\n df = getData.extractData()\n\n # We save the dataframe for later use in the API\n auxiliary.saveToCsv(df, 'app/resources')","def load_data_to_db(self, path):\n table_names = ['train_transaction', 'train_identity', 'test_transaction', 'test_identity']\n for table_name in table_names:\n pat = self.TRANSACTION_NON_NUMBER_PATTERN if 'transaction' in table_name else self.IDENTITY_NON_NUMBER_PATTERN\n print(\"Loading table: \" + table_name)\n fn = os.path.join(path, table_name + '.csv')\n self.dbinstance.build_table_from_csv(fn, pat, table_name)\n print(\"Loaded table \" + table_name)","def _load_table(table: Model, directory: Path, format_: str):\n\n if directory is not None:\n print(f\" Loading {table.table_name()}...\")\n in_file = Path(directory) / f\"{table.table_name()}.{format_}\"\n dataset = tablib.Dataset(headers=table.fields()).load(in_file.read_text())\n print(f\" Importing {table.table_name()} into the database...\")\n table.insert_many(dataset.dict).execute()\n print(\" Done.\")\n print(\"=====================\")\n else:\n pass\n # print(dataset.export(\"csv\"))","def changeDataPath(self,path):\n self.dataPath = path","def _save_to_file_ctrl(self):\n fname, _ = QtWidgets.QFileDialog.getSaveFileName(\n parent=self,\n caption=\"Save proxies to file\",\n filter=\"csv file (*.csv)\"\n )\n if fname:\n with open(fname, 'w', newline='') as csvfile:\n writer = csv.writer(csvfile, delimiter=',',\n quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n writer.writerow([\"Address\", \"Port\", \"Protocol\", \"Anonymity\"])\n for proxy in self._get_table():\n writer.writerow([\n proxy.address,\n proxy.port,\n proxy.protocol,\n proxy.anonymity\n ])","def save_dataset_csv(self, path):\n cols = list(self.data_dict.keys())\n df = pd.DataFrame(self.data_dict, index=None, columns=cols)\n df.to_csv(path, index=True)","def store(self, filename):","def save_to_database(filename,key, df, metadata = {}):\n\t# Opening the dataframe\n\tstore = pd.HDFStore(filename)\n\t# Feeding the dataframe, 't' means table format (slightly slower but can be modified)\n\tstore.put(key, df, format=\"t\")\n\t# feeding the metadata\n\tstore.get_storer(key).attrs.metadata = metadata\n\t# /!\\ Important to properly close the file\n\tstore.close()","def save_dataframe(state: State):\n\n try:\n state.games.df.to_csv(ROOT_PATH + \"/results/data/raw_data.csv\")\n LOGGER.debug(\"Successfully saved data in ../results/data/\")\n\n except Exception as e:\n LOGGER.error(f\"Could not save dataframe file - {e}\")","def save(self, fname):\n pass","def save(self, path):\n for i, m in enumerate(self.model_save):\n m.save(os.path.join(path, str(i) + \"-\" + m.name))","def save(self, path_to_save):\n for item in self.data_array:\n item.save(path_to_save+item.file_name)","def save():\n pass","def save(self, *args, **kwargs):\n self.full_accession = self.set_full_accession()\n self.dbgap_link = self.set_dbgap_link()\n super(SourceDataset, self).save(*args, **kwargs)","def saveData(self):\n pass","def export_table (self,_w):\n try:\n _data = \"\"\n maxRow = _w.rowCount()\n maxColumn = _w.columnCount()\n for hc in range(0,maxColumn):\n try: _hci = str(_w.horizontalHeaderItem(hc).text())\n except:_hci=\"None\";pass\n if hc == (maxColumn-1) :_data += _hci\n elif hc < maxColumn:_data += \"%s,\" % _hci\n _data += \"\\n\"\n for r in range(0, maxRow):\n for c in range(0, maxColumn):\n _d = str(_w.item(r, c).text())\n if c == (maxColumn-1):_data += _d\n elif c < maxColumn:_data += \"%s,\" % _d\n _data += \"\\n\"\n options = QFileDialog.Options()\n saved_file, _ = QFileDialog.getSaveFileName(self, \"Save Table to file \", \"data\", \"Plain Text (*.txt);;CSV (*.csv);;All Files (*)\", options=options)\n _file = open(saved_file, 'w')\n _file.write(_data)\n _file.close()\n except FileNotFoundError:pass","def save_inventory(file_name, table):\r\n with open(file_name, 'w') as objFile:\r\n for cd in table:\r\n objFile.write(cd.saveFormat())\r\n return table","def save(self, data, outpath):\n data.to_csv(outpath)","def execute(cls, path: Path) -> None:\n file_csv_convert = FileCsvConvert.create_by_path_csv_convert(path)\n list_convert_table = cls._load_csv(file_csv_convert, path)\n file_csv_convert.value.convert_table_type.value.model.save_all(list_convert_table)","def save(self, path):\n torch.save(\n {\n \"input_dimension\": self.input_dimension,\n \"quantiles\": self.quantiles,\n \"width\": self.width,\n \"depth\": self.depth,\n \"activation\": self.activation,\n \"network_state\": self.state_dict(),\n \"optimizer_state\": self.optimizer.state_dict(),\n },\n path,\n )","def save_data(df: pd.DataFrame, database_filename: str) -> None:\n engine = create_engine(f\"sqlite:///{database_filename}\")\n df.to_sql(Path(database_filename).stem, engine, index=False, if_exists=\"replace\")","def save_json_file():\n global output_on_display, import_lst, column_names, data, new_data\n if data_base == '':\n mistake_load_table()\n else:\n column_names = new_data\n step = len(column_names)\n save_name = asksaveasfilename(title=\"Select file\", filetypes=((\"JSON\", \"*.json\"), (\"all files\", \"*.*\")),\n confirmoverwrite=True, defaultextension='.json')\n data = import_lst\n\n if len(data[0]) == step:\n pass\n else:\n data = import_lst[step::]\n\n data2 = list(map(list, zip(*data)))\n\n data3 = {key: value for key, value in zip(column_names, data2)}\n\n column = list(data3.keys())\n\n df = pd.DataFrame(data3, columns=column)\n\n data_dict = df.to_dict(orient=\"records\")\n with open(save_name, \"w+\") as f:\n json.dump(data_dict, f, indent=4)\n\n data.clear()\n data2.clear()\n data3.clear()","def on_save_as(self, event):\n data = self._get_data_selection(event)\n # path = None\n default_name = data.name\n if default_name.count('.') > 0:\n default_name = default_name.split('.')[0]\n default_name += \"_out\"\n if self.parent is not None:\n if issubclass(data.__class__, Data1D):\n self.parent.save_data1d(data, default_name)\n elif issubclass(data.__class__, Data2D):\n self.parent.save_data2d(data, default_name)\n else:\n print(\"unable to save this type of data\")","def save(self, path):\n torch.save(self, path)","def save(self, path):\n torch.save(self, path)","def onGrid(self, event):\n dlg = wx.FileDialog(self, wildcard=\"*.csv\", style=wx.SAVE)\n if dlg.ShowModal() == wx.ID_OK:\n path = dlg.GetPath()\n self.model.exportToGrid(path)\n dlg.Destroy()","def __write_source(self, handle, nbr):\n try:\n source = self.database.get_source_from_handle(handle)\n self.__write_row(nbr, handle, source)\n except:\n source = \"NOT FOUND\"\n self.__write_row(nbr, handle, source)","def SaveData(self, conn):\n t = time.process_time()\n log = Logger()\n cursor = conn.cursor()\n sqlQuery = \"insert into old_data \" \\\n \"select * from new_data\"\n cursor.execute(sqlQuery)\n conn.commit()\n conn.close()\n elapsed_t = time.process_time() - t\n log.log('Datos de cambios copiados a tabla', elapsed_t)","def store_to_file(self, file_type, path):\n if not isinstance(self.dataframe, pd.DataFrame):\n raise ValueError('dataframe argument is not a Pandas.DataFrame')\n elif file_type.lower() not in ['csv', 'pickle']:\n raise ValueError('File_type arg must be either pickle or csv.')\n elif file_type.lower() == 'pickle':\n self.sort_df()\n self.dataframe.to_pickle(path=path)\n else:\n self.sort_df()\n self.dataframe.to_csv(path_or_buf=path)\n self.path = path\n return self.path","def save_csv_file():\n global output_on_display, import_lst, column_names, data\n if data_base == '':\n mistake_load_table()\n else:\n column_names = data[0]\n save_name = asksaveasfilename(title=\"Select file\", filetypes=((\"CSV\", \"*.csv\"), (\"all files\", \"*.*\")),\n confirmoverwrite=True, defaultextension='.csv')\n step = len(column_names)\n data_csv = import_lst\n if len(data_csv[0]) == step:\n pass\n else:\n data_csv = import_lst[step::]\n\n with open(save_name, 'w+') as csv_file:\n csv_writer = csv.writer(csv_file)\n csv_writer.writerow(column_names)\n csv_writer.writerows(data_csv)","def save_model(self, model_path: str):","def changeModelSavePath(self,path):\n self.modelPath = path","def save(self):\r\n self.df_app_data = self.df_app_data.to_csv(\"app_data.csv\", index=False)","def save_data(df, database_filepath):\n # create a database connect\n conn = sqlite3.connect(database_filepath)\n # replace .db with empty space for new table name\n table_name = database_filepath.replace('.db', '')\n \n return df.to_sql(table_name, con=conn, if_exists='replace', index=False)","def save(self):\n\n if (self._save != '0'):\n p = self._save+self._path[-3:-1]+'_'+str(self._qn)+'.dat'\n np.savetxt(p, self._gf)\n else:\n sys.exit(\"Wrong path to save\")","def save(self):\n assert self.data is not None\n with open(self._csv_path, mode=\"w\", encoding=\"utf-8\") as spp_file:\n # We don't want to save the index, as it's not especially meaningful, and makes life harder when trying to\n # restore the binary version from the csv (the index column would be imported and then need to be dropped).\n self.data.to_csv(spp_file, index=False)","def changeResultsSavePath(self,path):\n self.resultsPath = path","def write_df_to_db(df, db_path):\n print \"Writing to 'results' table in db: \", db_path\n conn = sqlite3.connect(db_path)\n df.to_sql(\"results\", con=conn,if_exists='replace')","def save_GRID( self , filename ):\n self._fwrite_GRID( filename )","def write_to(self, fname, **kwargs):\n data = self.to_Table()\n data.write(fname, **kwargs)","def save(self, directory):\n pass # pragma: no cover","def save(self, path: str):\n torch.save(self, path)","def set_master_table(filepath):\n my_globals['master_table_path'] = filepath\n my_globals['master_table_data'] = None","def save_table_cache(table, tracer_id, model, table_name, verbose=True):\n check_cache_path(model, verbose=verbose)\n filepath = paths.tracer_cache_filepath(tracer_id, model, table_name=table_name)\n printv(f'Saving table to cache: {filepath}', verbose)\n table.to_pickle(filepath)","def save_model(self, output_path):\n joblib.dump(self.dtr, output_path)","def save(self, filename):\n pass","def save(self, file_prefix, first_colname=\"\", **kwargs):\n\n write_refset(self, file_prefix, first_colname=first_colname, **kwargs)","def save(self, **kwargs):\n if len(self.path) > 0:\n self.path = self.path.strip().rstrip()\n super(TargetPath, self).save(**kwargs)","def save_model(self, filename):\r\n pass","def save(self, path: str):\n torch.save(self.model.state_dict(), path)","def save(self, path: str):\n torch.save(self.model.state_dict(), path)","def save_dataset(self):\n if self.res_dataset is None:\n return\n if self.write_path is None:\n raise Exception(\"Error: Attempted to save result dataset without ever specifiying a path to write to\")\n\n if self.format == \"arrow\":\n self.res_dataset.save_to_disk(self.write_path)\n elif self.format == \"csv\":\n self.res_dataset.to_csv(self.write_path, index = False)","def psql_saver(spark, df, tbname, savemode='error'):\n df.createOrReplaceTempView(\"view\")\n spark.sql('''SELECT * FROM view''').write \\\n .format('jdbc') \\\n .option('url', 'jdbc:postgresql://%s' % __credential__.jdbc_accessible_host_psql) \\\n .option('dbtable', tbname) \\\n .option('user', __credential__.user_psql) \\\n .option('password', __credential__.password_psql) \\\n .mode(savemode) \\\n .save()","def save_dst_to_file(dst, dir_file):\n dst = dst.sort_values('event')\n store = pd.HDFStore(dir_file, \"w\", complib=str(\"zlib\"), complevel=4)\n store.put('dataframe', dst, format='table', data_columns=True)\n store.close()","def save(self):\n # TODO (Pierre): code","def save_data(df, database_filename):\n engine = create_engine('sqlite:///'+database_filename)\n df.to_sql('disasterdata', engine, index=False)","def save(self):\n\t\t# save self.dfAnalysis\n\t\tcsvPath = self._getSavePath()\n\t\tprint('saving:', csvPath)\n\t\tself.dfAnalysis.to_csv(csvPath)","def save(self):\n self.index.saveIndex(c.index_path('hnsw.index'))\n joblib.dump(self.ys, \"%s.ys\" % self.index_file_prefix)","def saveData(self):\n pdIds = pd.DataFrame.from_dict(self.pathIds, orient='index')\n pdCrr = pd.DataFrame.from_dict(self.pathCrr, orient='index', columns=['cid'])\n mergedData = pd.concat([pdIds, pdCrr['cid']], axis=1, ignore_index=False)\n\n # Create the save dialog box\n name, _ = QtWidgets.QFileDialog.getSaveFileName(self, 'Save File',\n '', 'csv files (*.csv)', 'csv file (*.csv)')\n\n if not name:\n return\n # Check the extension when saving\n if self.csvExt in name:\n mergedData.to_csv(name, header=False, index=True)\n else:\n message = 'Error saving file {}.'.format(name)\n self.messageBox(message)"],"string":"[\n \"def save(file, table):\\n pq.write_table(pa.Table.from_pandas(table), file)\",\n \"def save(self):\\r\\n debug.write(\\\"[SourceRPG] Handling SQL Save\\\", 1)\\r\\n if self.path != \\\":memory:\\\":\\r\\n debug.write(\\\"Path is not in memory\\\", 2, False)\\r\\n if currentTurboMode is False:\\r\\n debug.write(\\\"We are not in turbo mode\\\", 2, False)\\r\\n self.connection.commit()\\r\\n debug.write(\\\"[SourceRPG] SQL Save handled\\\", 1)\",\n \"def save(self, labpath: str) -> None:\\n self._table.to_csv(labpath, index=False)\\n print(\\\"# Save experimental data into {0}\\\".format(labpath))\",\n \"def save(self, path):\\n pass\",\n \"def save(self, path):\\n pass\",\n \"def save(self, path):\\n pass\",\n \"def write_table(table, file_path):\\n\\n\\twith open(file_path, 'w') as file:\\n\\t\\tfile.write(table)\",\n \"def save_table(date, table):\\n if os.path.isfile(date+\\\".table\\\"):\\n file_using = open(date+\\\".table\\\", \\\"w\\\")\\n else:\\n return False\\n file_using.seek(0)\\n file_using.truncate()\\n for line in table:\\n file_using.write(\\\"{},{},{},{},{}\\\\n\\\".format(line[0], line[1], line[2], line[3], line[4]))\\n file_using.close()\",\n \"def save(self, path: str):\\n pass\",\n \"def export_database(self):\\n base_path = QtWidgets.QFileDialog.getSaveFileName(self, 'Save File', filter='CSV (*.csv)')\\n database.export_to_csv(DB_PATH, base_path[0])\",\n \"def save_dataloader(self, path: Union[str, Path]) -> None:\\n if isinstance(path, str):\\n path = Path(path)\\n joblib.dump(self, path)\",\n \"def save_table(data, out_file):\\n logging.info(\\\"Saving table\\\")\\n #header, data = data\\n #out = pd.DataFrame(data=data, columns = header.keys())\\n joblib.dump(data, out_file)\",\n \"def saveData(self):\\n\\n\\n path = QtWidgets.QFileDialog.getSaveFileName(self, 'Save File', os.getcwd())\\n\\n if path[0] != '':\\n\\n filepath, filename = os.path.split(path[0])\\n\\n if os.path.exists(filepath):\\n\\n self.getCurrentPanda().saveData(path[0])\",\n \"def save(path_to_model):\\n pass\",\n \"def store_hive_table(data, directory, file_name):\\n table_name = directory + \\\".\\\" + file_name\\n data.write.saveAsTable(table_name)\",\n \"def save_indicator(table, target_path, var_name, geo):\\n table.to_csv(f\\\"{target_path}/{var_name}.{geo}.csv\\\", index=False)\",\n \"def save_model(self, path):\\n pass\",\n \"def save(df, path):\\n \\n # Extract the directory and filename from the given path\\n directory = os.path.split(path)[0]\\n filename = os.path.split(path)[1]\\n if directory == '':\\n directory = '.'\\n \\n # If the directory does not exist, create it\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n \\n # The final path to save to\\n savepath = os.path.join(directory, filename)\\n \\n # Save the dataset\\n sampled_frame.to_csv(savepath, index=False)\",\n \"def save_path(self):\\n raise NotImplementedError\",\n \"def save_path(self):\\n raise NotImplementedError\",\n \"def save_db(self) -> None:\",\n \"def save():\",\n \"def save(self):\\n self.backend.save(list(self._d.items()))\\n log.debug(\\\"save: {}\\\".format(self.backend.filename))\",\n \"def save_table_scraperwiki(uniques,table,name):\\n for row in table:\\n scraperwiki.sqlite.save(\\n unique_keys=uniques\\n , data=row\\n , table_name=name\\n )\",\n \"def save_datatable(datatable: ModelDatatable, folder_name):\\n result = {RESULT_CODE_KEY: 0,\\n RESULT_MESSAGE_KEY: \\\"success save datatable: \\\" + datatable.get_datatable_name()}\\n\\n # create folder if needed\\n Path(folder_name).mkdir(parents=True, exist_ok=True)\\n\\n # check if file with datatable_name already existing and delete if existing\\n path_to_file = folder_name + \\\"/\\\" + datatable.get_datatable_name()\\n path = Path(path_to_file)\\n if path.is_file():\\n # remove file\\n os.remove(path_to_file)\\n\\n try:\\n # connect to database\\n connection = sqlite3.connect(path_to_file)\\n logger_log(\\\"established db connection. \\\" + \\\"sqlite3.version: \\\" + sqlite3.version)\\n\\n # create\\n result = create_datable(connection, datatable, folder_name)\\n # if not successful\\n if not result[RESULT_CODE_KEY] == 0:\\n return result\\n\\n #\\n # insert data\\n #\\n logger_log(\\\"now try insert data into datatable with name: \\\" + datatable.get_datatable_name())\\n\\n # for all rows\\n for row in datatable.get_rows():\\n # get sql statement\\n sql_statement = get_sql_statement_insert_data_for_row(row)\\n # get cursor\\n cursor = connection.cursor()\\n # execute\\n cursor.execute(sql_statement)\\n logger_log(\\\"success insert row.\\\")\\n\\n result = {RESULT_CODE_KEY: 0,\\n RESULT_MESSAGE_KEY: \\\"success save datatable: \\\" + datatable.get_datatable_name()}\\n except Error as e:\\n logger_log(\\\"failed. db operation with error: \\\" + e.args[0])\\n result[RESULT_CODE_KEY] = -1\\n result[RESULT_MESSAGE_KEY] = \\\"failed saving datatable. error: \\\" + e.args[0]\\n finally:\\n if connection:\\n connection.commit()\\n connection.close()\\n logger_log(\\\"db connection closed: \\\" + datatable.get_datatable_name())\\n logger_log(result[RESULT_MESSAGE_KEY])\\n return result\",\n \"def write (self, path):\\n\\t\\ts=[]; add=s.append\\n\\t\\tadd ('\\\\t'.join (self.schema))\\n\\t\\tfor record in self.data:\\n\\t\\t\\tadd (record.asTabDelimitedRecord())\\n\\t\\t\\n\\t\\t# f = open (path, 'w')\\n\\t\\tf = codecs.open(path, 'w', 'utf-8')\\n\\t\\tf.write (self.linesep.join (s))\\n\\t\\tf.close()\\n\\t\\tprint (\\\"data written to \\\" + path)\",\n \"def _save_data(self):\\n self.data.to_csv('data/c&le/{}'.format(self.name))\",\n \"def save_data(df, database_filename):\\n engine = create_engine('sqlite:///' +database_filename)\\n df.to_sql('Project2', engine, index=False)\",\n \"def do_save(self, arg):\\n # If no data source selected, prompt user to do so.\\n try:\\n self._shw.save_data ()\\n except ValueError as e:\\n View.info (e)\\n except (OSError, AttributeError) as e:\\n View.error (e)\\n except Exception as e:\\n View.error (e)\\n else:\\n View.success (\\\"Data is saved\\\")\",\n \"def check_save_table_path(self, path):\\r\\n\\r\\n #check if path is empty and try to get something not empty\\r\\n if path == \\\"\\\":\\r\\n path = QFileDialog.getSaveFileName(self,caption = 'select a file to save to',\\r\\n directory = self.ui.saveTablePath.text(),\\r\\n filter=\\\"Text files (*.txt);;All files (*)\\\",\\r\\n options = QFileDialog.DontConfirmOverwrite)\\r\\n \\r\\n #in pyqt5 a tuple is returned, unpack it\\r\\n if os.environ['QT_API'] == 'pyqt5':\\r\\n path, _ = path\\r\\n \\r\\n if path == \\\"\\\":\\r\\n return \\\"\\\"\\r\\n else:\\r\\n self.ui.saveTablePath.setText(path)\\r\\n \\r\\n #do nothing if path already checked\\r\\n if self.saveTablePath == path:\\r\\n return path\\r\\n \\r\\n #if it already exists ask to overwrite or append\\r\\n if os.path.isfile(path):\\r\\n title = \\\"path already exists\\\"\\r\\n text = (path+\\\" already exists. Should it be overwritten? \\\\n\\\"\\r\\n + \\\"No will append to the file. \\\"\\r\\n + \\\"Choose Abort to select another file\\\")\\r\\n overwriteAnswer = QMessageBox.question(self,title,text,\\r\\n QMessageBox.Yes | QMessageBox.No | QMessageBox.Abort,\\r\\n QMessageBox.No)\\r\\n #if selected no, append to the file, i.e. return the path as checked\\r\\n if overwriteAnswer == QMessageBox.No:\\r\\n return path\\r\\n #empty path return on abort\\r\\n elif overwriteAnswer == QMessageBox.Abort:\\r\\n return \\\"\\\"\\r\\n #with yes the method continues and will overwrite the file\\r\\n \\r\\n #should not be a dir\\r\\n elif os.path.isdir(path):\\r\\n logging.error(\\\"specified path is a directory\\\")\\r\\n return \\\"\\\"\\r\\n \\r\\n #in all other cases, open it for writing and write a header to it\\r\\n headerString = (\\\"film no\\\\t\\\" \\\"filename\\\\t\\\" \\\"x0\\\\ty0\\\\tx1\\\\ty1\\\\t\\\"\\r\\n \\\"number of pixels\\\\t\\\" \\r\\n \\\"R_avg\\\\tR_std\\\\t\\\" \\\"G_avg\\\\tG_std\\\\t\\\" \\\"B_avg\\\\tB_std\\\\n\\\")\\r\\n with open(path,\\\"w\\\") as saveTableFile:\\r\\n saveTableFile.write(headerString)\\r\\n \\r\\n return path\",\n \"def save(self,path=\\\"qtable.npy\\\"):\\n np.save(path, self.Q)\",\n \"def save_data(df, database_filename):\\n engine = create_engine(f\\\"sqlite:///{database_filename}\\\")\\n df.to_sql(\\\"YourTableName\\\", engine, index=False, if_exists=\\\"replace\\\")\",\n \"def save(\\n self,\\n modelSavePath\\n ):\\n pass\",\n \"def save_data(self):\\n pass\",\n \"def _save(self, dataset, path, files, copy_files=False):\\n raise NotImplementedError('Loader {} does not support saving datasets.'.format(self.type()))\",\n \"def save_values(self):\\n # TODO: Add self.prefix and extension\\n NetworkTables.saveEntries(self.file.get_filename(), prefix='/vision/' + self.name + '_')\",\n \"def save_to_file(self, file_path):\\n if file_path:\\n f = open(file_path, 'w')\\n for row in range(self.rows):\\n f.write(''.join(self.data[row]) + '\\\\n')\\n f.close()\",\n \"def save_to_file(self, file_path):\\n if file_path:\\n f = open(file_path, 'w')\\n for row in range(self.rows):\\n f.write(''.join(self.data[row]) + '\\\\n')\\n f.close()\",\n \"def save(self, file_path):\\n self.model.save(file_path)\",\n \"def save(self, file_path):\\n self.model.save(file_path)\",\n \"def save(self, file_path):\\n self.model.save(file_path)\",\n \"def update_database():\\n\\n # We obtain the data from the official database\\n df = getData.extractData()\\n\\n # We save the dataframe for later use in the API\\n auxiliary.saveToCsv(df, 'app/resources')\",\n \"def load_data_to_db(self, path):\\n table_names = ['train_transaction', 'train_identity', 'test_transaction', 'test_identity']\\n for table_name in table_names:\\n pat = self.TRANSACTION_NON_NUMBER_PATTERN if 'transaction' in table_name else self.IDENTITY_NON_NUMBER_PATTERN\\n print(\\\"Loading table: \\\" + table_name)\\n fn = os.path.join(path, table_name + '.csv')\\n self.dbinstance.build_table_from_csv(fn, pat, table_name)\\n print(\\\"Loaded table \\\" + table_name)\",\n \"def _load_table(table: Model, directory: Path, format_: str):\\n\\n if directory is not None:\\n print(f\\\" Loading {table.table_name()}...\\\")\\n in_file = Path(directory) / f\\\"{table.table_name()}.{format_}\\\"\\n dataset = tablib.Dataset(headers=table.fields()).load(in_file.read_text())\\n print(f\\\" Importing {table.table_name()} into the database...\\\")\\n table.insert_many(dataset.dict).execute()\\n print(\\\" Done.\\\")\\n print(\\\"=====================\\\")\\n else:\\n pass\\n # print(dataset.export(\\\"csv\\\"))\",\n \"def changeDataPath(self,path):\\n self.dataPath = path\",\n \"def _save_to_file_ctrl(self):\\n fname, _ = QtWidgets.QFileDialog.getSaveFileName(\\n parent=self,\\n caption=\\\"Save proxies to file\\\",\\n filter=\\\"csv file (*.csv)\\\"\\n )\\n if fname:\\n with open(fname, 'w', newline='') as csvfile:\\n writer = csv.writer(csvfile, delimiter=',',\\n quotechar='\\\"', quoting=csv.QUOTE_MINIMAL)\\n writer.writerow([\\\"Address\\\", \\\"Port\\\", \\\"Protocol\\\", \\\"Anonymity\\\"])\\n for proxy in self._get_table():\\n writer.writerow([\\n proxy.address,\\n proxy.port,\\n proxy.protocol,\\n proxy.anonymity\\n ])\",\n \"def save_dataset_csv(self, path):\\n cols = list(self.data_dict.keys())\\n df = pd.DataFrame(self.data_dict, index=None, columns=cols)\\n df.to_csv(path, index=True)\",\n \"def store(self, filename):\",\n \"def save_to_database(filename,key, df, metadata = {}):\\n\\t# Opening the dataframe\\n\\tstore = pd.HDFStore(filename)\\n\\t# Feeding the dataframe, 't' means table format (slightly slower but can be modified)\\n\\tstore.put(key, df, format=\\\"t\\\")\\n\\t# feeding the metadata\\n\\tstore.get_storer(key).attrs.metadata = metadata\\n\\t# /!\\\\ Important to properly close the file\\n\\tstore.close()\",\n \"def save_dataframe(state: State):\\n\\n try:\\n state.games.df.to_csv(ROOT_PATH + \\\"/results/data/raw_data.csv\\\")\\n LOGGER.debug(\\\"Successfully saved data in ../results/data/\\\")\\n\\n except Exception as e:\\n LOGGER.error(f\\\"Could not save dataframe file - {e}\\\")\",\n \"def save(self, fname):\\n pass\",\n \"def save(self, path):\\n for i, m in enumerate(self.model_save):\\n m.save(os.path.join(path, str(i) + \\\"-\\\" + m.name))\",\n \"def save(self, path_to_save):\\n for item in self.data_array:\\n item.save(path_to_save+item.file_name)\",\n \"def save():\\n pass\",\n \"def save(self, *args, **kwargs):\\n self.full_accession = self.set_full_accession()\\n self.dbgap_link = self.set_dbgap_link()\\n super(SourceDataset, self).save(*args, **kwargs)\",\n \"def saveData(self):\\n pass\",\n \"def export_table (self,_w):\\n try:\\n _data = \\\"\\\"\\n maxRow = _w.rowCount()\\n maxColumn = _w.columnCount()\\n for hc in range(0,maxColumn):\\n try: _hci = str(_w.horizontalHeaderItem(hc).text())\\n except:_hci=\\\"None\\\";pass\\n if hc == (maxColumn-1) :_data += _hci\\n elif hc < maxColumn:_data += \\\"%s,\\\" % _hci\\n _data += \\\"\\\\n\\\"\\n for r in range(0, maxRow):\\n for c in range(0, maxColumn):\\n _d = str(_w.item(r, c).text())\\n if c == (maxColumn-1):_data += _d\\n elif c < maxColumn:_data += \\\"%s,\\\" % _d\\n _data += \\\"\\\\n\\\"\\n options = QFileDialog.Options()\\n saved_file, _ = QFileDialog.getSaveFileName(self, \\\"Save Table to file \\\", \\\"data\\\", \\\"Plain Text (*.txt);;CSV (*.csv);;All Files (*)\\\", options=options)\\n _file = open(saved_file, 'w')\\n _file.write(_data)\\n _file.close()\\n except FileNotFoundError:pass\",\n \"def save_inventory(file_name, table):\\r\\n with open(file_name, 'w') as objFile:\\r\\n for cd in table:\\r\\n objFile.write(cd.saveFormat())\\r\\n return table\",\n \"def save(self, data, outpath):\\n data.to_csv(outpath)\",\n \"def execute(cls, path: Path) -> None:\\n file_csv_convert = FileCsvConvert.create_by_path_csv_convert(path)\\n list_convert_table = cls._load_csv(file_csv_convert, path)\\n file_csv_convert.value.convert_table_type.value.model.save_all(list_convert_table)\",\n \"def save(self, path):\\n torch.save(\\n {\\n \\\"input_dimension\\\": self.input_dimension,\\n \\\"quantiles\\\": self.quantiles,\\n \\\"width\\\": self.width,\\n \\\"depth\\\": self.depth,\\n \\\"activation\\\": self.activation,\\n \\\"network_state\\\": self.state_dict(),\\n \\\"optimizer_state\\\": self.optimizer.state_dict(),\\n },\\n path,\\n )\",\n \"def save_data(df: pd.DataFrame, database_filename: str) -> None:\\n engine = create_engine(f\\\"sqlite:///{database_filename}\\\")\\n df.to_sql(Path(database_filename).stem, engine, index=False, if_exists=\\\"replace\\\")\",\n \"def save_json_file():\\n global output_on_display, import_lst, column_names, data, new_data\\n if data_base == '':\\n mistake_load_table()\\n else:\\n column_names = new_data\\n step = len(column_names)\\n save_name = asksaveasfilename(title=\\\"Select file\\\", filetypes=((\\\"JSON\\\", \\\"*.json\\\"), (\\\"all files\\\", \\\"*.*\\\")),\\n confirmoverwrite=True, defaultextension='.json')\\n data = import_lst\\n\\n if len(data[0]) == step:\\n pass\\n else:\\n data = import_lst[step::]\\n\\n data2 = list(map(list, zip(*data)))\\n\\n data3 = {key: value for key, value in zip(column_names, data2)}\\n\\n column = list(data3.keys())\\n\\n df = pd.DataFrame(data3, columns=column)\\n\\n data_dict = df.to_dict(orient=\\\"records\\\")\\n with open(save_name, \\\"w+\\\") as f:\\n json.dump(data_dict, f, indent=4)\\n\\n data.clear()\\n data2.clear()\\n data3.clear()\",\n \"def on_save_as(self, event):\\n data = self._get_data_selection(event)\\n # path = None\\n default_name = data.name\\n if default_name.count('.') > 0:\\n default_name = default_name.split('.')[0]\\n default_name += \\\"_out\\\"\\n if self.parent is not None:\\n if issubclass(data.__class__, Data1D):\\n self.parent.save_data1d(data, default_name)\\n elif issubclass(data.__class__, Data2D):\\n self.parent.save_data2d(data, default_name)\\n else:\\n print(\\\"unable to save this type of data\\\")\",\n \"def save(self, path):\\n torch.save(self, path)\",\n \"def save(self, path):\\n torch.save(self, path)\",\n \"def onGrid(self, event):\\n dlg = wx.FileDialog(self, wildcard=\\\"*.csv\\\", style=wx.SAVE)\\n if dlg.ShowModal() == wx.ID_OK:\\n path = dlg.GetPath()\\n self.model.exportToGrid(path)\\n dlg.Destroy()\",\n \"def __write_source(self, handle, nbr):\\n try:\\n source = self.database.get_source_from_handle(handle)\\n self.__write_row(nbr, handle, source)\\n except:\\n source = \\\"NOT FOUND\\\"\\n self.__write_row(nbr, handle, source)\",\n \"def SaveData(self, conn):\\n t = time.process_time()\\n log = Logger()\\n cursor = conn.cursor()\\n sqlQuery = \\\"insert into old_data \\\" \\\\\\n \\\"select * from new_data\\\"\\n cursor.execute(sqlQuery)\\n conn.commit()\\n conn.close()\\n elapsed_t = time.process_time() - t\\n log.log('Datos de cambios copiados a tabla', elapsed_t)\",\n \"def store_to_file(self, file_type, path):\\n if not isinstance(self.dataframe, pd.DataFrame):\\n raise ValueError('dataframe argument is not a Pandas.DataFrame')\\n elif file_type.lower() not in ['csv', 'pickle']:\\n raise ValueError('File_type arg must be either pickle or csv.')\\n elif file_type.lower() == 'pickle':\\n self.sort_df()\\n self.dataframe.to_pickle(path=path)\\n else:\\n self.sort_df()\\n self.dataframe.to_csv(path_or_buf=path)\\n self.path = path\\n return self.path\",\n \"def save_csv_file():\\n global output_on_display, import_lst, column_names, data\\n if data_base == '':\\n mistake_load_table()\\n else:\\n column_names = data[0]\\n save_name = asksaveasfilename(title=\\\"Select file\\\", filetypes=((\\\"CSV\\\", \\\"*.csv\\\"), (\\\"all files\\\", \\\"*.*\\\")),\\n confirmoverwrite=True, defaultextension='.csv')\\n step = len(column_names)\\n data_csv = import_lst\\n if len(data_csv[0]) == step:\\n pass\\n else:\\n data_csv = import_lst[step::]\\n\\n with open(save_name, 'w+') as csv_file:\\n csv_writer = csv.writer(csv_file)\\n csv_writer.writerow(column_names)\\n csv_writer.writerows(data_csv)\",\n \"def save_model(self, model_path: str):\",\n \"def changeModelSavePath(self,path):\\n self.modelPath = path\",\n \"def save(self):\\r\\n self.df_app_data = self.df_app_data.to_csv(\\\"app_data.csv\\\", index=False)\",\n \"def save_data(df, database_filepath):\\n # create a database connect\\n conn = sqlite3.connect(database_filepath)\\n # replace .db with empty space for new table name\\n table_name = database_filepath.replace('.db', '')\\n \\n return df.to_sql(table_name, con=conn, if_exists='replace', index=False)\",\n \"def save(self):\\n\\n if (self._save != '0'):\\n p = self._save+self._path[-3:-1]+'_'+str(self._qn)+'.dat'\\n np.savetxt(p, self._gf)\\n else:\\n sys.exit(\\\"Wrong path to save\\\")\",\n \"def save(self):\\n assert self.data is not None\\n with open(self._csv_path, mode=\\\"w\\\", encoding=\\\"utf-8\\\") as spp_file:\\n # We don't want to save the index, as it's not especially meaningful, and makes life harder when trying to\\n # restore the binary version from the csv (the index column would be imported and then need to be dropped).\\n self.data.to_csv(spp_file, index=False)\",\n \"def changeResultsSavePath(self,path):\\n self.resultsPath = path\",\n \"def write_df_to_db(df, db_path):\\n print \\\"Writing to 'results' table in db: \\\", db_path\\n conn = sqlite3.connect(db_path)\\n df.to_sql(\\\"results\\\", con=conn,if_exists='replace')\",\n \"def save_GRID( self , filename ):\\n self._fwrite_GRID( filename )\",\n \"def write_to(self, fname, **kwargs):\\n data = self.to_Table()\\n data.write(fname, **kwargs)\",\n \"def save(self, directory):\\n pass # pragma: no cover\",\n \"def save(self, path: str):\\n torch.save(self, path)\",\n \"def set_master_table(filepath):\\n my_globals['master_table_path'] = filepath\\n my_globals['master_table_data'] = None\",\n \"def save_table_cache(table, tracer_id, model, table_name, verbose=True):\\n check_cache_path(model, verbose=verbose)\\n filepath = paths.tracer_cache_filepath(tracer_id, model, table_name=table_name)\\n printv(f'Saving table to cache: {filepath}', verbose)\\n table.to_pickle(filepath)\",\n \"def save_model(self, output_path):\\n joblib.dump(self.dtr, output_path)\",\n \"def save(self, filename):\\n pass\",\n \"def save(self, file_prefix, first_colname=\\\"\\\", **kwargs):\\n\\n write_refset(self, file_prefix, first_colname=first_colname, **kwargs)\",\n \"def save(self, **kwargs):\\n if len(self.path) > 0:\\n self.path = self.path.strip().rstrip()\\n super(TargetPath, self).save(**kwargs)\",\n \"def save_model(self, filename):\\r\\n pass\",\n \"def save(self, path: str):\\n torch.save(self.model.state_dict(), path)\",\n \"def save(self, path: str):\\n torch.save(self.model.state_dict(), path)\",\n \"def save_dataset(self):\\n if self.res_dataset is None:\\n return\\n if self.write_path is None:\\n raise Exception(\\\"Error: Attempted to save result dataset without ever specifiying a path to write to\\\")\\n\\n if self.format == \\\"arrow\\\":\\n self.res_dataset.save_to_disk(self.write_path)\\n elif self.format == \\\"csv\\\":\\n self.res_dataset.to_csv(self.write_path, index = False)\",\n \"def psql_saver(spark, df, tbname, savemode='error'):\\n df.createOrReplaceTempView(\\\"view\\\")\\n spark.sql('''SELECT * FROM view''').write \\\\\\n .format('jdbc') \\\\\\n .option('url', 'jdbc:postgresql://%s' % __credential__.jdbc_accessible_host_psql) \\\\\\n .option('dbtable', tbname) \\\\\\n .option('user', __credential__.user_psql) \\\\\\n .option('password', __credential__.password_psql) \\\\\\n .mode(savemode) \\\\\\n .save()\",\n \"def save_dst_to_file(dst, dir_file):\\n dst = dst.sort_values('event')\\n store = pd.HDFStore(dir_file, \\\"w\\\", complib=str(\\\"zlib\\\"), complevel=4)\\n store.put('dataframe', dst, format='table', data_columns=True)\\n store.close()\",\n \"def save(self):\\n # TODO (Pierre): code\",\n \"def save_data(df, database_filename):\\n engine = create_engine('sqlite:///'+database_filename)\\n df.to_sql('disasterdata', engine, index=False)\",\n \"def save(self):\\n\\t\\t# save self.dfAnalysis\\n\\t\\tcsvPath = self._getSavePath()\\n\\t\\tprint('saving:', csvPath)\\n\\t\\tself.dfAnalysis.to_csv(csvPath)\",\n \"def save(self):\\n self.index.saveIndex(c.index_path('hnsw.index'))\\n joblib.dump(self.ys, \\\"%s.ys\\\" % self.index_file_prefix)\",\n \"def saveData(self):\\n pdIds = pd.DataFrame.from_dict(self.pathIds, orient='index')\\n pdCrr = pd.DataFrame.from_dict(self.pathCrr, orient='index', columns=['cid'])\\n mergedData = pd.concat([pdIds, pdCrr['cid']], axis=1, ignore_index=False)\\n\\n # Create the save dialog box\\n name, _ = QtWidgets.QFileDialog.getSaveFileName(self, 'Save File',\\n '', 'csv files (*.csv)', 'csv file (*.csv)')\\n\\n if not name:\\n return\\n # Check the extension when saving\\n if self.csvExt in name:\\n mergedData.to_csv(name, header=False, index=True)\\n else:\\n message = 'Error saving file {}.'.format(name)\\n self.messageBox(message)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6399908","0.6323182","0.61869615","0.6044013","0.6044013","0.6044013","0.59645635","0.59101415","0.58439785","0.5820229","0.58036727","0.57980114","0.5796495","0.5790788","0.57840085","0.57607806","0.57270277","0.57178634","0.570963","0.570963","0.5641698","0.5637297","0.56280494","0.5623022","0.5577594","0.55647856","0.55595964","0.55562663","0.5553746","0.5539131","0.5529425","0.5517633","0.55151975","0.55137146","0.5491308","0.54810786","0.547215","0.547215","0.5460846","0.5460846","0.5460846","0.5436471","0.54340816","0.54191285","0.541744","0.54078764","0.54058915","0.5402148","0.53996557","0.53964","0.53905416","0.53892034","0.53838253","0.53797483","0.5368994","0.5364034","0.5360471","0.53522855","0.5351695","0.53492045","0.53395855","0.5336542","0.53206795","0.5319575","0.5312305","0.5312305","0.5311189","0.5306667","0.53061885","0.5306033","0.5303555","0.5292792","0.5288321","0.5287092","0.5284326","0.5282226","0.52807826","0.52762705","0.5267869","0.5265901","0.5259637","0.5251488","0.524989","0.5248832","0.52403295","0.5240121","0.52327687","0.5232159","0.52303874","0.5228213","0.52279085","0.52279085","0.52265894","0.521129","0.5210448","0.52072227","0.5202649","0.5201983","0.5198104","0.5197644"],"string":"[\n \"0.6399908\",\n \"0.6323182\",\n \"0.61869615\",\n \"0.6044013\",\n \"0.6044013\",\n \"0.6044013\",\n \"0.59645635\",\n \"0.59101415\",\n \"0.58439785\",\n \"0.5820229\",\n \"0.58036727\",\n \"0.57980114\",\n \"0.5796495\",\n \"0.5790788\",\n \"0.57840085\",\n \"0.57607806\",\n \"0.57270277\",\n \"0.57178634\",\n \"0.570963\",\n \"0.570963\",\n \"0.5641698\",\n \"0.5637297\",\n \"0.56280494\",\n \"0.5623022\",\n \"0.5577594\",\n \"0.55647856\",\n \"0.55595964\",\n \"0.55562663\",\n \"0.5553746\",\n \"0.5539131\",\n \"0.5529425\",\n \"0.5517633\",\n \"0.55151975\",\n \"0.55137146\",\n \"0.5491308\",\n \"0.54810786\",\n \"0.547215\",\n \"0.547215\",\n \"0.5460846\",\n \"0.5460846\",\n \"0.5460846\",\n \"0.5436471\",\n \"0.54340816\",\n \"0.54191285\",\n \"0.541744\",\n \"0.54078764\",\n \"0.54058915\",\n \"0.5402148\",\n \"0.53996557\",\n \"0.53964\",\n \"0.53905416\",\n \"0.53892034\",\n \"0.53838253\",\n \"0.53797483\",\n \"0.5368994\",\n \"0.5364034\",\n \"0.5360471\",\n \"0.53522855\",\n \"0.5351695\",\n \"0.53492045\",\n \"0.53395855\",\n \"0.5336542\",\n \"0.53206795\",\n \"0.5319575\",\n \"0.5312305\",\n \"0.5312305\",\n \"0.5311189\",\n \"0.5306667\",\n \"0.53061885\",\n \"0.5306033\",\n \"0.5303555\",\n \"0.5292792\",\n \"0.5288321\",\n \"0.5287092\",\n \"0.5284326\",\n \"0.5282226\",\n \"0.52807826\",\n \"0.52762705\",\n \"0.5267869\",\n \"0.5265901\",\n \"0.5259637\",\n \"0.5251488\",\n \"0.524989\",\n \"0.5248832\",\n \"0.52403295\",\n \"0.5240121\",\n \"0.52327687\",\n \"0.5232159\",\n \"0.52303874\",\n \"0.5228213\",\n \"0.52279085\",\n \"0.52279085\",\n \"0.52265894\",\n \"0.521129\",\n \"0.5210448\",\n \"0.52072227\",\n \"0.5202649\",\n \"0.5201983\",\n \"0.5198104\",\n \"0.5197644\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.582292"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":5499,"cells":{"query":{"kind":"string","value":"Registers all the JRPC overloaders in the jrpc server"},"document":{"kind":"string","value":"def register_overloaders(jrpc_server: JRPCServer, receiver) -> None:\n jrpc_server.register_overloader(\n 'Application.GetProperties', lambda server: GetPropertiesOverloader(server, receiver))\n jrpc_server.register_overloader(\n 'Application.SetMute', lambda server: SetMuteOverloader(receiver))\n jrpc_server.register_overloader(\n 'Application.SetVolume', lambda server: SetVolumeOverloader(receiver))\n jrpc_server.register_overloader(\n 'Application.Quit', lambda server: ApplicationQuitOverloader(receiver))\n jrpc_server.register_overloader(\n 'System.Hibernate', lambda server: ApplicationQuitOverloader(receiver))\n jrpc_server.register_overloader(\n 'System.Shutdown', lambda server: ApplicationQuitOverloader(receiver))\n jrpc_server.register_overloader(\n 'System.Suspend', lambda server: ApplicationQuitOverloader(receiver))\n jrpc_server.register_overloader(\n 'System.GetProperties', lambda server: SystemPropertiesOverloader())"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["async def register_rpc_proxies(self):\n for rpc_name in self.rpc_proxy_list:\n logger.debug('Registering RPC to Proxy: {}'.format(rpc_name))\n\n class RPCProxy:\n\n def __init__(self, local_session, rpc_name):\n self._local_session = local_session\n self._rpc_name = rpc_name\n\n async def __call__(self, *args, **kwargs):\n logger.debug('Proxying RPC {}, with args {}, kwargs {}'.format(self._rpc_name, args, kwargs))\n return await self._local_session.call(self._rpc_name, *args, **kwargs)\n\n await self.remote_session.register(RPCProxy(self.local_session, rpc_name), rpc_name)","def _registerOnServer(self, daemon, nameserver,vclock):\n uri = daemon.register(self)\n nameserver.register(self._name, uri)\n self.updateVectorClock(vclock)\n print(\"Gateway registered. Name {} and uri {} \".format(self._name,uri))","def _setup_rpc(self):\n pass","def xmlrpc_methods():","def register_peer(self):\n try:\n self.get_file_list()\n num_files = len(self.file_list)\n total_ops = self.key_end - self.key_start\n run_ops = total_ops/num_files\n print \"Staring Benchmark Register Peer with Server...\"\n t1 = time.time()\n for i in range(run_ops):\n for file in self.file_list:\n self.service.put(file, self.peer_id)\n t2 = time.time()\n total = run_ops * num_files\n print \"%s Register operations = %s sec\" % (total,t2-t1)\n print \"per Register operation = %s sec\" % ((t2-t1)/total)\n print \"per Register operation = %s msec\" % (((t2-t1)/total)*1000)\n except Exception as e:\n print \"Registering Peer Error, %s\" % e\n sys.exit(1)","def registerRPC(self, call, args = None):\n\n rpc = RemoteProcedureCall(self, len(self.rpc), args)\n self.rpc.append(call)\n return rpc","def register_extensions(app):\n grpc_channel = grpc.insecure_channel(\n f\"{app.config['GRPC_SERVICE']}:{app.config['GRPC_PORT']}\",\n )\n grpc_client = GrpcClient(grpc_channel)\n grpc_client.init_app(app)","def make_json_handler(rpc):\n\n class JSONRPCHandler(BaseHTTPRequestHandler):\n \"\"\"\n A request handler for http.server that speaks JSON-RPC.\n \"\"\"\n def _validate_http_request(self):\n \"\"\"\n Ensures that we understand the HTTP portion of the request.\n \"\"\"\n if self.path != '/':\n print('Invalid request path:', self.path)\n self.send_error(HTTPStatus.NOT_FOUND, 'Request Must Have Path Of /')\n raise ValueError\n\n content_type = self.headers.get('Content-Type', None)\n if content_type != 'application/json':\n print('Invalid request Content-Type:', self.path)\n self.send_error(HTTPStatus.BAD_REQUEST, 'Content-Type Must Be application/json')\n raise ValueError\n\n def _validate_rpc_request(self, request):\n \"\"\"\n Ensures that we understand the JSON-RPC portion of the request.\n \"\"\"\n if request.get('jsonrpc', None) != '2.0':\n raise ValueError('Invalid jsonrpc: must be \"2.0\"')\n\n id = request.get('id', None)\n if not (id is None or isinstance(id, (str, int, float))):\n raise ValueError('Invalid id: must be null, string or number')\n\n method = request.get('method', None)\n if not isinstance(method, str):\n raise ValueError('Invalid method: must be string')\n\n params = request.get('params', [])\n if not isinstance(params, (dict, list)):\n raise ValueError('Invalid params: must be array or object')\n\n def _build_rpc_error(self, id, error, exception, keep_null_id=False):\n \"\"\"\n Returns an error response that can be encoded to JSON.\n\n By default this respects the ID of the request, and returns None if the\n ID is also None. To override this behavior, set keep_null_id=True.\n \"\"\"\n if id is None and not keep_null_id:\n return None\n\n message = RPC_ERROR_MESSAGES.get(error, str(exception))\n\n return {\n 'jsonrpc': '2.0',\n 'id': id,\n 'error': {\n 'code': error.value,\n 'message': message,\n 'data': {\n 'stacktrace': str(exception) + '\\n' + '\\n'.join(traceback.format_tb(exception.__traceback__))\n }\n }\n }\n\n def _build_rpc_result(self, id, result):\n \"\"\"\n Returns a result response that can be encoded to JSON.\n \"\"\"\n if id is None:\n return None\n\n return {\n 'jsonrpc': '2.0',\n 'id': id,\n 'result': result\n }\n\n def _process_request(self, request):\n \"\"\"\n Calls a single RPC function and returns the result.\n \"\"\"\n try:\n self._validate_rpc_request(request)\n except ValueError as err:\n return self._build_rpc_error(None, RpcErrors.INVALID_REQUEST, err, keep_null_id=True)\n\n id = request.get('id', None)\n\n try:\n method = getattr(rpc, request['method'])\n except AttributeError as err:\n return self._build_rpc_error(id, RpcErrors.METHOD_NOT_FOUND, err)\n\n try:\n params = request.get('params', None)\n if params is None:\n result = method()\n elif isinstance(params, list):\n result = method(*params)\n elif isinstance(params, dict):\n result = method(**params)\n\n return self._build_rpc_result(id, result)\n\n except TypeError as err:\n return self._build_rpc_error(id, RpcErrors.INVALID_PARAMS, err)\n except Exception as err:\n return self._build_rpc_error(id, RpcErrors.INTERNAL_ERROR, err)\n\n def _send_json(self, value):\n \"\"\"\n Dumps the value to a JSON string, and sets the appropriate headers to\n return it\n \"\"\"\n raw_value = json.dumps(value).encode('utf-8')\n\n self.send_response(200, 'OK')\n for header, value in CORS_HEADERS.items():\n self.send_header(header, value)\n\n self.send_header('Content-Type', 'application/json')\n self.send_header('Content-Length', str(len(raw_value)))\n self.end_headers()\n\n self.wfile.write(raw_value)\n\n def do_POST(self):\n \"\"\"\n Parses and processes a single or batch JSON-RPC request.\n \"\"\"\n try:\n self._validate_http_request()\n except ValueError:\n return\n\n content_length = int(self.headers.get('Content-Length', '0'))\n request_bytes = self.rfile.read(content_length)\n while len(request_bytes) < content_length:\n request_bytes += self.rfile.read(content_length - len(request_bytes))\n\n request_raw = request_bytes.decode('utf-8')\n try:\n request = json.loads(request_raw)\n except ValueError as err:\n error = self._build_rpc_error(None, RpcErrors.PARSE_ERROR, err, keep_null_id=True)\n self._send_json(error)\n return\n\n if isinstance(request, list):\n responses = [self._process_request(single) for single in request]\n response = [r for r in responses if r is not None]\n elif isinstance(request, dict):\n response = self._process_request(request)\n else:\n try:\n raise ValueError\n except ValueError as err:\n error = self._build_rpc_error(None, RpcErrors.INVALID_REQUEST, err)\n self._send_json(error)\n return\n\n if response is not None:\n self._send_json(response)\n else:\n self.send_response(200, 'OK')\n self.end_headers()\n\n def do_OPTIONS(self):\n \"\"\"\n Sends back the headers necessary to support CORS\n \"\"\"\n print('Processing CORS OPTIONS request')\n self.send_response(200, 'OK')\n for header, value in CORS_HEADERS.items():\n self.send_header(header, value)\n\n self.end_headers()\n\n return JSONRPCHandler","def register_resources(self):\n raise NotImplementedError","def register_options(options):\n return (\n options\n .register('jsonFilterFile',\n type_=str,\n default=None,\n description=\"Path to JSON file containing certified runs and luminosity blocks.\")\n .register('useHLTFilter',\n type_=bool,\n default=False,\n description=\"If True, only events triggered by one of the skimmed paths will be \"\n \"written out.\")\n .register('jetCollections',\n type_=str,\n default=[],\n multiplicity='list',\n description=\"The names of the jet collections to use (e.g. 'AK4PFCHS').\")\n .register('jecVersion',\n type_=str,\n default=None,\n description=\"Tag of JEC version to use for e.g. JEC uncertainties.\")\n .register('jecFromGlobalTag',\n type_=bool,\n default=False,\n description=\"If True, the JECs will be looked up in the conditions database \"\n \"(CondDB/Frontier) under the current global tag. If False, the \"\n \"text files for `jecVersion` will be used.\")\n .register('jerVersion',\n type_=str,\n default=None,\n description=\"Tag of JER version to use for e.g. jet smearing.\")\n .register('jerMethod',\n type_=str,\n default='stochastic',\n description=\"Method to use for JER smearing. One of: 'stochastic', 'hybrid'\")\n .register('jerGenMatchPtSigma',\n type_=float,\n default=3.0,\n description=\"Size of Gaussian core for 'hybrid' JER smearing.\")\n .register('jetIDSpec',\n type_=str,\n default=None,\n description=\"Version of Jet ID to use (e.g. '2016').\")\n .register('jetIDWorkingPoint',\n type_=str,\n default=None,\n description=\"Working point of Jet ID to use (e.g. 'TightLepVeto').\")\n .register('prefiringWeightFilePath',\n type_=str,\n default=\"\",\n description=\"Path to ROOT file containing prefiring weights.\")\n .register('prefiringWeightHistName',\n type_=str,\n default=\"\",\n description=\"Name of histogram inside prefiring weights file (e.g. 'L1prefiring_jetpt_2016BCD').\")\n .register('useObjectBasedJetID',\n type_=bool,\n default=False,\n description=\"If True, only jets passing the ID specified via 'jetIDSpec' and `jetIDWorkingPoint` will be considered valid.\")\n .register('checkForCompleteness',\n type_=bool,\n default=False,\n description=(\"(for testing) If True, will run some checks on the \"\n \"Ntuple output to ensure all branches are written out \"\n \"and no branch is omitted.\"))\n .register('stitchingWeight',\n type_=float,\n default=1.0,\n description=(\"(deprecated) The output branch 'stitchingWeight' \"\n \"will contain this value for each event. Can then be \"\n \"used when stitching together different samples.\"))\n .register('doJECUncertaintySources',\n type_=bool,\n default=False,\n description=\"Fill ntuple branch with JEC correction factors for individual JEC uncertainty sources.\")\n .register('doPrescales',\n type_=bool,\n default=False,\n description=\"Write out trigger prescales to Ntuple.\")\n .register('edmOut',\n type_=bool,\n default=False,\n description=\"(for testing only) Write out EDM file.\")\n )","def _register_services(self, pipeline):\n\n pipeline.register_service(self._aprs_service)","def register_server(self, ppclassname, ppclass):\n\n global rpc_pp_class\n\n def accept(cmd, data, eof, sock, address):\n \"\"\" This is called by the rpc.py's tcp listener when a remote\n client connects \"\"\"\n\n ppclass = rpc_pp_class.get(cmd)\n if ppclass == None:\n warning('No PP class found: %s\\n' %(cmd))\n return RPC_CLOSE\n\n # Instantiate the given server class\n ppclass(address=address, sock=sock, data=data)\n return RPC_RELEASE\n\n if register_rpchandler(ppclassname, accept):\n rpc_pp_class[ppclassname] = ppclass","def register_router(self, router):\n for prefix, viewset, basename in router.registry:\n self.register(prefix, viewset, base_name=basename)","def register_rpc_backend(backend_name, init_rpc_backend_handler):\n rpc_backend_registry = _get_rpc_backend_registry()\n if backend_name in rpc_backend_registry:\n raise RuntimeError(\"Rpc backend {}: already registered\".format(backend_name))\n rpc_backend_registry[backend_name] = init_rpc_backend_handler","def __init__(self):\n super(LoopbackTransport, self).__init__([_JSON_RPC_SERVER_PATH])","def configure_rpc(cls, scheme=None):\r\n scheme = scheme or cls._meta.scheme\r\n\r\n if not scheme:\r\n return\r\n\r\n if isinstance(scheme, basestring):\r\n scheme = importlib.import_module(scheme)\r\n\r\n cls.scheme_name = scheme.__name__\r\n\r\n methods = getattr(scheme, '__all__', None) \\\r\n or [m for m in dir(scheme) if not m.startswith('_')]\r\n\r\n for mname in methods:\r\n method = getattr(scheme, mname)\r\n if hasattr(method, '__call__'):\r\n cls.methods[\"{0}.{1}\".format(\r\n cls.scheme_name, method.__name__)] = method","def remotes():","def registerServer(srv):\n srv.setListenAddress(hostname)\n srv.setMachine(getMBean('/Machines/'+machineName))","def register(self):\n\n RPCObjectsRegistry.add(self)","def server_plugin():","async def test_multiple_rpc_transports(loop, server, redis_server_b, consume_rpcs):\n registry.add(ApiA())\n registry.add(ApiB())\n\n manually_set_plugins(plugins={})\n\n redis_server_a = server\n\n port_a = redis_server_a.tcp_address.port\n port_b = redis_server_b.tcp_address.port\n\n logging.warning(f'Server A port: {port_a}')\n logging.warning(f'Server B port: {port_b}')\n\n config = Config.load_dict({\n 'bus': {\n 'schema': {\n 'transport': {'redis': {'url': f'redis://localhost:{port_a}'}},\n }\n },\n 'apis': {\n 'default': {\n 'rpc_transport': {'redis': {'url': f'redis://localhost:{port_a}'}},\n 'result_transport': {'redis': {'url': f'redis://localhost:{port_a}'}},\n },\n 'api_b': {\n 'rpc_transport': {'redis': {'url': f'redis://localhost:{port_b}'}},\n 'result_transport': {'redis': {'url': f'redis://localhost:{port_b}'}},\n },\n }\n })\n\n bus = BusNode(name='', parent=None, bus_client=lightbus.BusClient(config=config, loop=loop))\n asyncio.ensure_future(consume_rpcs(bus))\n await asyncio.sleep(0.1)\n\n await bus.api_a.rpc_a.call_async()\n await bus.api_b.rpc_b.call_async()","def register_specs(self, *args):\n self._corespecs_queue.extend(*args)","def _initiate_registry_from_torchlib(\n self, torchlib_registry: registration.Registry\n ):\n for aten_name, aten_overloads_func in torchlib_registry.items():\n for func in aten_overloads_func.overloads:\n self.register(\n aten_name,\n self._opset_version,\n func,\n custom=False,\n )","def _serve(self) -> None:\n for instrument in self._config[\"instruments\"]:\n uri = self._daemon.register(instrument, objectId=str(instrument))\n self._services[instrument.id] = str(uri)\n logger.success(f\"Registered {instrument} at {uri}\")\n self.uri = self._daemon.register(self, objectId=self.servername)\n logger.success(f\"Registered self at {self.uri}\")","def __init__(self,server_list):\n self.workers=[]\n self.worker_by_name={}\n worker_id = 1\n for host,port in server_list:\n # Add the uid here can help with port conflicts, but only works\n # on Unix clusters. We really need to work out a daemon service\n # model that makes the port mess transparent.\n port = port #+ os.getuid()\n new_worker = sync_cluster.standard_sync_client(host,port,worker_id)\n self.workers.append(new_worker)\n self.worker_by_name[host] = new_worker\n worker_id = worker_id + 1","def extend(self, router):\n self.registry.extend(router.registry)","def register_classes():\n DiffuseCompChain.register_class()\n CatalogCompChain.register_class()\n DiffuseAnalysisChain.register_class()","def ListWorkers(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def server_plugin_list(ctx):\n data = ctx.obj.get_all_plugins()\n output_json_data(data)","def api_all():\n update_pvserver_instances(pvserver_instances)\n return jsonify(pvserver_instances)","def __init__(self, addr=(\"localhost\", 8000)):\n\n Thread.__init__(self)\n RPCBaseProxy.__init__(self)\n\n self.__instances = []\n\n self.__server = SimpleXMLRPCServer(addr=addr, logRequests=False, requestHandler=SimpleXMLRPCRequestHandler)\n self.__server.register_instance(self)","def RegisterPlayers(self):\n self.tcf.RegisterPlayers(self.player_handler.GetPlayers())","def _register_services(self) -> None:\n\n for isr in self.immediate_services_with_reply:\n # Create a single instance of the service to cache in the router corresponding\n # to one or more message types.\n isr_instance = isr()\n for handler_type in isr.message_handler_types():\n # for each explicitly supported type, add it to the router\n self.immediate_msg_with_reply_router[handler_type] = isr_instance\n\n # for all sub-classes of the explicitly supported type, add them\n # to the router as well.\n for handler_type_subclass in get_subclasses(obj_type=handler_type):\n self.immediate_msg_with_reply_router[\n handler_type_subclass\n ] = isr_instance\n\n for iswr in self.immediate_services_without_reply:\n # Create a single instance of the service to cache in the router corresponding\n # to one or more message types.\n iswr_instance = iswr()\n for handler_type in iswr.message_handler_types():\n\n # for each explicitly supported type, add it to the router\n self.immediate_msg_without_reply_router[handler_type] = iswr_instance\n\n # for all sub-classes of the explicitly supported type, add them\n # to the router as well.\n for handler_type_subclass in get_subclasses(obj_type=handler_type):\n self.immediate_msg_without_reply_router[\n handler_type_subclass\n ] = iswr_instance\n\n for eswr in self.eventual_services_without_reply:\n # Create a single instance of the service to cache in the router corresponding\n # to one or more message types.\n eswr_instance = eswr()\n for handler_type in eswr.message_handler_types():\n\n # for each explicitly supported type, add it to the router\n self.eventual_msg_without_reply_router[handler_type] = eswr_instance\n\n # for all sub-classes of the explicitly supported type, add them\n # to the router as well.\n for handler_type_subclass in get_subclasses(obj_type=handler_type):\n self.eventual_msg_without_reply_router[\n handler_type_subclass\n ] = eswr_instance\n\n # Set the services_registered flag to true so that we know that all services\n # have been properly registered. This mostly exists because someone might\n # accidentally delete (forget to call) this method inside the __init__ function\n # of a sub-class of Node.\n self.services_registered = True","def _register(self, comm, handler):","def StartAllProtocols(self, *args, **kwargs):\n # type: (*Any, **Any) -> None\n payload = {}\n for i in range(len(args)):\n payload[\"Arg%s\" % (i + 1)] = args[i]\n for item in kwargs.items():\n payload[item[0]] = item[1]\n return self._execute(\"startAllProtocols\", payload=payload, response_object=None)","def register_plugins(self):\n if self.plugin_whitelist:\n plugin_list = self.plugin_whitelist\n else:\n plugin_list = plugins.__all__\n\n for plugin in plugin_list:\n if plugin in plugins.__all__:\n self.register_plugin(plugin,\n self.plugin_config.get(plugin, {}))\n else:\n raise NameError(\"Plugin %s not in plugins.__all__.\" % plugin)\n\n # Resolve plugin inter-dependencies.\n for plugin in self.plugin:\n self.plugin[plugin].post_init()","def start_protocols(self, context: ResourceCommandContext) -> None:\n self.handler.start_protocols()","def GetServers(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def remote_registerEngine(self, engineReference):","def _negotiate_protocols(self, protocols, direction):\n uris = [p.uri for p in protocols]\n if direction in ['pushFromVoSpace', 'pullToVoSpace']:\n supported = list(set(uris) & set(CLIENT_PROTOCOLS))\n else:\n supported = list(set(uris) & set(SERVER_PROTOCOLS))\n if len(supported) == 0: raise VOSpaceError(500, \"The service supports none of the requested Protocols\", summary = PROTOCOL_NOT_SUPPORTED)\n selected = [p for p in protocols if p.uri in supported]\n if direction in ['pullFromVoSpace', 'pushToVoSpace']:\n for protocol in selected:\n protocol.set_endpoint(SERVER_PROTOCOLS[protocol.uri].get_endpoint())\n return selected","def connect_multiplexer(multiplexer):","def register_plugin_calls(*funcs):\n wrapped_dict = {}\n for func in funcs:\n wrapped_dict[func.__name__] = _handle_serialization(func)\n XenAPIPlugin.dispatch(wrapped_dict)","def mergeRPC(remoteETM,remoteLoca): #Status: WIP\r\n pass","def register():\n \n global _registered\n if not _registered:\n _registered = True\n sys.path_hooks.insert(0, VFSImporter)","def register_interface_magics(self):\n from sage.repl.interface_magic import InterfaceMagic\n InterfaceMagic.register_all(self.shell)","def rpc(self) -> global___Rpc:","def _register_serializers(self):\n import ray.util.serialization_addons\n from ray.util.serialization import StandaloneSerializationContext\n\n ctx = StandaloneSerializationContext()\n ray.util.serialization_addons.apply(ctx)","def registerPatches(self,pl):\n self.set('patchmesh.patches',pl)","def register_handlers(dp, di_container: di.Container):\n general.router.register_handlers(dp)\n\n di_container.wire(packages=[sys.modules[__name__]])","def register_response_receivers(self, *response_receivers):\n for response_receiver in response_receivers:\n self.translator.message_receivers.append(response_receiver)","def createSimpleXMLRPCServer(host, ports):\n\tfor port in ports:\n\t\ttry:\n\t\t\tres = xserver.SimpleXMLRPCServer((host,port))\n\t\texcept Exception as e:\n\t\t\tprint(\"Retrying:%s\"%(e))\n\t\telse:\n\t\t\tres.logRequests = 0 # hint from newsgroup to disable the - - [13/Apr/2007 13:33:57] \"POST /RPC2 HTTP/1.0\" 200 - output with every request\n\t\t\treturn res","def rpc_call_to_all(client, call, prefix=DOCK_CONTAINER_NAME_PREFIX_BTC, arguments=None,\n rpc_user=BTC_RPC_USER, rpc_password=BTC_RPC_PASSWD, rpc_port=BTC_RPC_PORT):\n try:\n containers = get_containers_names(client, prefix)\n r = []\n for c in containers:\n rpc_server = get_ip_by_unknown(client, c)\n rpc_connection = AuthServiceProxy(\"http://%s:%s@%s:%s\" % (rpc_user, rpc_password, rpc_server, rpc_port))\n args = \"(\" + arguments + \")\" if arguments else \"()\"\n r.append(eval(\"rpc_connection.\" + call + args))\n return r\n except JSONRPCException as err:\n return False","def _register_methods(self, registry, instance_type):\n to_register = list(instance_type.jit_methods) + \\\n list(instance_type.jit_static_methods)\n for meth in to_register:\n\n # There's no way to retrieve the particular method name\n # inside the implementation function, so we have to register a\n # specific closure for each different name\n if meth not in self.implemented_methods:\n self._implement_method(registry, meth)\n self.implemented_methods.add(meth)","def install_serve_encoders_to_fastapi():\n # https://stackoverflow.com/questions/62311401/override-default-encoders-for-jsonable-encoder-in-fastapi # noqa\n pydantic.json.ENCODERS_BY_TYPE.update(serve_encoders)\n # FastAPI cache these encoders at import time, so we also needs to refresh it.\n fastapi.encoders.encoders_by_class_tuples = (\n fastapi.encoders.generate_encoders_by_class_tuples(\n pydantic.json.ENCODERS_BY_TYPE\n )\n )","def _register_pycoin_networks() -> None:\n import os\n\n global _registered_pycoin\n if _registered_pycoin:\n return\n _registered_pycoin = True\n\n paths = os.environ.get('PYCOIN_NETWORK_PATHS', '').split()\n if 'hathor.pycoin' not in paths:\n paths.append('hathor.pycoin')\n os.environ['PYCOIN_NETWORK_PATHS'] = ' '.join(paths)","def rpcmethod(func):\n func.rpcmethod = True\n return func","def _register_handlers(self):\n self.jm.register_handler(\"move_node\", self.move_node)\n self.jm.register_handler(\"copy_node\", self.copy_node)\n self.jm.register_handler(\"push_to_vospace\", self.push_to_vospace)\n self.jm.register_handler(\"push_from_vospace\", self.push_from_vospace)\n self.jm.register_handler(\"pull_to_vospace\", self.pull_to_vospace)\n self.jm.register_handler(\"pull_from_vospace\", self.pull_from_vospace)","def registerWebsocketProtocol(connection, protocol): #@NoSelf","def makeHandlers(self):\n\n yield self.loadGrids.start(funcSelf=self)\n yield self.updateClientWatchedGrids.start(funcSelf=self)\n logger.debug(\"RPCs started\")","def __init__(self, rpc, encoder):\n super(EncoderModule, self).__init__(rpc, 'encoder', encoder)","def register_resources(self, resources):\n for resource in resources:\n self.register_resource(resource)","def rpc_method(func):\n func.rpc_callable = True\n return func","def add_servers(self, servers: List[Server]):\n pass","def add_ip_cores(self, scfg, ip_dir):\r\n\r\n return []","def register_opts():\n _register_api_opts()\n _register_db_opts()","def registerXMLRPC(self, unique_service_name, instance, endpoint):\n # TODO only set the ClientCert Handler if configured\n handler = XMLRPCHandler(unique_service_name)\n handler.connect(self._flaskapp.app, endpoint)\n handler.register_instance(instance)","def register_blueprints(api):\n for module in MODULES:\n api.register_blueprint(module.blp)","def beta_create_CoreRPC_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):\n request_deserializers = {\n ('pb.CoreRPC', 'AddNode'): AddNodeOptions.FromString,\n ('pb.CoreRPC', 'AddPod'): AddPodOptions.FromString,\n ('pb.CoreRPC', 'Backup'): BackupOptions.FromString,\n ('pb.CoreRPC', 'BuildImage'): BuildImageOptions.FromString,\n ('pb.CoreRPC', 'CreateContainer'): DeployOptions.FromString,\n ('pb.CoreRPC', 'GetContainer'): ContainerID.FromString,\n ('pb.CoreRPC', 'GetContainers'): ContainerIDs.FromString,\n ('pb.CoreRPC', 'GetNode'): GetNodeOptions.FromString,\n ('pb.CoreRPC', 'GetPod'): GetPodOptions.FromString,\n ('pb.CoreRPC', 'ListNetworks'): GetPodOptions.FromString,\n ('pb.CoreRPC', 'ListPodNodes'): ListNodesOptions.FromString,\n ('pb.CoreRPC', 'ListPods'): Empty.FromString,\n ('pb.CoreRPC', 'ReallocResource'): ReallocOptions.FromString,\n ('pb.CoreRPC', 'RemoveContainer'): ContainerIDs.FromString,\n ('pb.CoreRPC', 'RemoveImage'): RemoveImageOptions.FromString,\n ('pb.CoreRPC', 'RemoveNode'): RemoveNodeOptions.FromString,\n ('pb.CoreRPC', 'RemovePod'): RemovePodOptions.FromString,\n ('pb.CoreRPC', 'RunAndWait'): RunAndWaitOptions.FromString,\n ('pb.CoreRPC', 'SetNodeAvailable'): NodeAvailable.FromString,\n }\n response_serializers = {\n ('pb.CoreRPC', 'AddNode'): Node.SerializeToString,\n ('pb.CoreRPC', 'AddPod'): Pod.SerializeToString,\n ('pb.CoreRPC', 'Backup'): BackupMessage.SerializeToString,\n ('pb.CoreRPC', 'BuildImage'): BuildImageMessage.SerializeToString,\n ('pb.CoreRPC', 'CreateContainer'): CreateContainerMessage.SerializeToString,\n ('pb.CoreRPC', 'GetContainer'): Container.SerializeToString,\n ('pb.CoreRPC', 'GetContainers'): Containers.SerializeToString,\n ('pb.CoreRPC', 'GetNode'): Node.SerializeToString,\n ('pb.CoreRPC', 'GetPod'): Pod.SerializeToString,\n ('pb.CoreRPC', 'ListNetworks'): Networks.SerializeToString,\n ('pb.CoreRPC', 'ListPodNodes'): Nodes.SerializeToString,\n ('pb.CoreRPC', 'ListPods'): Pods.SerializeToString,\n ('pb.CoreRPC', 'ReallocResource'): ReallocResourceMessage.SerializeToString,\n ('pb.CoreRPC', 'RemoveContainer'): RemoveContainerMessage.SerializeToString,\n ('pb.CoreRPC', 'RemoveImage'): RemoveImageMessage.SerializeToString,\n ('pb.CoreRPC', 'RemoveNode'): Pod.SerializeToString,\n ('pb.CoreRPC', 'RemovePod'): Empty.SerializeToString,\n ('pb.CoreRPC', 'RunAndWait'): RunAndWaitMessage.SerializeToString,\n ('pb.CoreRPC', 'SetNodeAvailable'): Node.SerializeToString,\n }\n method_implementations = {\n ('pb.CoreRPC', 'AddNode'): face_utilities.unary_unary_inline(servicer.AddNode),\n ('pb.CoreRPC', 'AddPod'): face_utilities.unary_unary_inline(servicer.AddPod),\n ('pb.CoreRPC', 'Backup'): face_utilities.unary_unary_inline(servicer.Backup),\n ('pb.CoreRPC', 'BuildImage'): face_utilities.unary_stream_inline(servicer.BuildImage),\n ('pb.CoreRPC', 'CreateContainer'): face_utilities.unary_stream_inline(servicer.CreateContainer),\n ('pb.CoreRPC', 'GetContainer'): face_utilities.unary_unary_inline(servicer.GetContainer),\n ('pb.CoreRPC', 'GetContainers'): face_utilities.unary_unary_inline(servicer.GetContainers),\n ('pb.CoreRPC', 'GetNode'): face_utilities.unary_unary_inline(servicer.GetNode),\n ('pb.CoreRPC', 'GetPod'): face_utilities.unary_unary_inline(servicer.GetPod),\n ('pb.CoreRPC', 'ListNetworks'): face_utilities.unary_unary_inline(servicer.ListNetworks),\n ('pb.CoreRPC', 'ListPodNodes'): face_utilities.unary_unary_inline(servicer.ListPodNodes),\n ('pb.CoreRPC', 'ListPods'): face_utilities.unary_unary_inline(servicer.ListPods),\n ('pb.CoreRPC', 'ReallocResource'): face_utilities.unary_stream_inline(servicer.ReallocResource),\n ('pb.CoreRPC', 'RemoveContainer'): face_utilities.unary_stream_inline(servicer.RemoveContainer),\n ('pb.CoreRPC', 'RemoveImage'): face_utilities.unary_stream_inline(servicer.RemoveImage),\n ('pb.CoreRPC', 'RemoveNode'): face_utilities.unary_unary_inline(servicer.RemoveNode),\n ('pb.CoreRPC', 'RemovePod'): face_utilities.unary_unary_inline(servicer.RemovePod),\n ('pb.CoreRPC', 'RunAndWait'): face_utilities.stream_stream_inline(servicer.RunAndWait),\n ('pb.CoreRPC', 'SetNodeAvailable'): face_utilities.unary_unary_inline(servicer.SetNodeAvailable),\n }\n server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout)\n return beta_implementations.server(method_implementations, options=server_options)","def _bind_method_serializers(self, meth_serializers):\n\n # We can't use update because that would be the wrong\n # precedence\n for mtype, serializer in meth_serializers.items():\n self.serializers.setdefault(mtype, serializer)","def pedrpc_connect(self):\n # If the process monitor is alive, set it's options\n if self.procmon:\n while 1:\n if self.procmon.alive():\n break\n\n time.sleep(1)\n\n # connection established.\n for key, value in self.procmon_options.items():\n getattr(self.procmon, 'set_{0}'.format(key))(value)\n\n # If the network monitor is alive, set it's options\n if self.netmon:\n while 1:\n if self.netmon.alive():\n break\n\n time.sleep(1)\n\n # connection established.\n for key in self.netmon_options.keys():\n eval('self.netmon.set_%s(self.netmon_options[\"%s\"])' % (key, key))","def rpc_match():","def main(server):\n config_parser = ConfigParser()\n config_parser.read('resources/conf/config.ini')\n\n log_level = log_levels.get(config_parser.get('core', 'log.level'))\n log_filename = config_parser.get('core', 'log.path')\n logging.basicConfig(level=log_level,\n format='%(levelname)s:%(asctime)s:%(message)s',\n filename=log_filename)\n replicator = Replicator(config_parser)\n executor = ThreadPoolExecutor(max_workers=2)\n executor.submit(replicator.start)\n logger = logging.getLogger('replicator')\n if log_level == 'DEBUG':\n handler = logging.StreamHandler()\n handler.setLevel(logging.DEBUG)\n logger.addHandler(handler)\n if server:\n if config_parser.has_section('server'):\n check_server_configuration(config_parser, logger)\n server_config = {\n 'server.socket_host' : config_parser.get('server', 'socket_host'),\n 'server.socket_port' : config_parser.getint('server', 'socket_port'),\n 'log.access_file' : config_parser.get('server', 'log.access_file'),\n 'log.error_file' : config_parser.get('server', 'log.error_file')\n }\n cherrypy.config.update(server_config)\n logger.info('Server will be started at %s:%d' % (server_config['server.socket_host'],\n server_config['server.socket_port']))\n else:\n logger.info('No settings found, using the default one. (localhost:8080)')\n executor.submit(cherrypy.quickstart(ReplicatorServer(replicator)))","def register_routes(self):\n @inlineCallbacks\n def registered(response):\n if response.code != 200:\n text = yield response.text()\n self._env.logger.error('{} {}'.format(response.code, text))\n\n try:\n api_register = '{}://{}:{}/api/1.0.0/register'.format(\n self._env.api_protocol,\n self._env.api_host,\n self._env.api_port\n )\n remote_ms = self._env.get('remote_ms', None)\n\n for path in self._env.swagger.paths:\n uri = self._env.swagger.base + path.split('{')[0].rstrip('/')\n if remote_ms:\n route = {\n 'protocol': 'https',\n 'host': remote_ms,\n 'port': 443,\n }\n else:\n if self._env.get('flask_private'):\n route = {\n 'protocol': self._env.get('flask_protocol'),\n 'host': self._env.get('flask_host'),\n 'port': self._env.get('flask_port'),\n }\n else:\n route = {\n 'protocol': self._env.flask_protocol,\n 'host': self._env.flask_host,\n 'port': self._env.flask_port,\n }\n route = dict(route, **{'uri': uri, 'key': self._key})\n #self._env.logger.info('Route> {}'.format(str(route)))\n treq.post(api_register, data={'details': dumps(route)}).addCallback(registered)\n\n swagger_paths = ['/ui/css', '/ui/lib', '/ui/images', '/swagger.json']\n ui = '/' + self._env.get('swagger_ui', 'ui')+'/'\n swagger_paths.append(ui)\n\n for path in swagger_paths:\n uri = self._env.swagger.base\n if len(uri):\n if uri[-1] == '/':\n uri = uri[:-1]\n uri += path\n if self._env.get('flask_private'):\n route = {\n 'protocol': self._env.get('flask_protocol'),\n 'host': self._env.get('flask_host'),\n 'port': self._env.get('flask_port'),\n 'uri': uri,\n 'key': self._key,\n 'ui': path == ui,\n 'name': self._env.get('my_name', 'no local name', 'microservice')\n }\n else:\n route = {\n 'protocol': self._env.flask_protocol,\n 'host': self._env.flask_host,\n 'port': self._env.flask_port,\n 'uri': uri,\n 'key': self._key,\n 'ui': path == ui,\n 'name': self._env.get('my_name', 'no local name', 'microservice')\n }\n treq.post(api_register, data={'details': dumps(route)}).addCallback(registered)\n\n return True\n except Exception as e:\n self._env.logger.error('error registering routes \"{}\"'.format(str(e)))","def register_classes():\n CollectLimits.register_class()\n CollectLimits_SG.register_class()\n CollectStackedLimits_SG.register_class()","def registerBlueprints(module_name):\n module = importlib.import_module(\n \"app.modules.\" + module_name, package=None)\n bp = getattr(module, module_name)\n server_logger.info(\"Registering module: \" + module_name)\n if bp.name == \"index\":\n server.register_blueprint(bp)\n else:\n server.register_blueprint(bp, url_prefix='/' + bp.name)","def _setup_rpc(self):\n\n endpoints = RpcCallBacks(self)\n self.server = rpc.DfaRpcServer(self.ser_q, self._host,\n self.cfg.dfa_rpc.transport_url,\n endpoints,\n exchange=constants.DFA_EXCHANGE)","def RegisterProtoRPCServiceToFlaskApp(app_inst, path, service_inst,\n service_name=None):\n service_name = service_name or service_inst.SERVICE_DESCRIPTOR.name\n endpoint_name = '__protorpc_service_view_func_' + str(uuid.uuid1())\n view_func = _ProtoRPCServiceFlaskAppViewFunc(service_inst)\n app_inst.add_url_rule('%s/%s.<method_name>' % (path, service_name),\n endpoint=endpoint_name, view_func=view_func,\n methods=['POST'])","def _register_with_cluster(self, cpu_count):\n try:\n reply = cluster.send_command({\n \"op\": \"register\",\n \"address\": self.address,\n \"port_number\": port_number,\n \"cpu_count\": cpu_count\n }, wait_for_reply=True)\n\n if reply[\"op\"] == \"reply\":\n # print cluster information\n cluster_info = cluster.cluster_info\n print(\"Worker server at\", self.address, \"port number\", port_number)\n print(\"Joined cluster at\", cluster_info[0][\"address\"],\n \"port number\", cluster_info[0][\"port_number\"])\n return True\n\n else: return False\n\n except Exception as ex:\n print(\"Error:\", ex)\n return False","def restart_all():\n\n restart_nginx()\n restart_supervisor()","def register(self):\n self._register_dockyard()\n self._register_docker()","def register_server():\n (code, message) = rest_api.register_server(request)\n if (code == 200):\n return message\n else:\n abort(code)","def register(name, func):\n WebSocketRouter.funcmap[name] = func","def __init__(self) :\n self.remoteConnections = {}","def serve_forever(self, poll_interval=0.5):\n logging.info('RPC server starting')\n self._idle_thread.start()\n SimpleJSONRPCServer.SimpleJSONRPCServer.serve_forever(self, poll_interval)","def __init__(self, rpc):\n self.rpc = rpc","def config_server_buffer_cb(data, option):\n\n for server in SERVERS.values():\n server.buffer_merge()\n return 1","def register(self):\n raise NotImplementedError","def register(self):\n raise NotImplementedError","def registerExistingServer():\n cd('/')\n cd('/Servers/'+managedServername)\n registerServer(cmo)","async def register_schemas(\n self, *, compatibility: str | None = None\n ) -> None:\n for subject_name, schema in self.schemas.items():\n await self._registry.register_schema(\n schema=schema,\n subject=subject_name,\n compatibility=compatibility,\n )","def start_servers(self, **kwargs):\n self.cleanup()\n\n # Start up the API and default conductor server\n\n # We start the conductor server first, as the API server config\n # depends on the conductor port - this ordering allows for\n # retrying the launch on a port clash\n self.start_with_retry(self.conductor_server, 'conductor_port', 3,\n **kwargs)\n kwargs['conductor_port'] = self.conductor_server.bind_port\n\n self.start_with_retry(self.api_server, 'api_port', 3, **kwargs)","def interfaces(self):","def interfaces(self):","def register_blueprints(self):\n # Local import due to flask/blueprint circular imports.\n from mmapi.views import api_bp\n self.app.register_blueprint(api_bp, url_prefix='/api')","def __init__(self, sc, conf):\n\n super(LBaaSv2RpcManager, self).__init__(sc, conf)","def _extend_replays(self, num_per_problem: int):\n # fire off extension methods\n results = []\n for problem in tqdm.tqdm(self.problems, desc='spawn extend'):\n get_action = self._make_get_action(problem)\n extend_replay = rpyc.async(problem.problem_service.extend_replay)\n result = extend_replay(get_action, num_per_problem)\n # apparently I need to keep hold of async ref according to RPyC\n # docs (it's weak or s.th). Also, I need a background thread to\n # serve each environment's requests (...this may break things\n # slightly).\n bg_thread = rpyc.utils.helpers.BgServingThread(\n problem.problem_server.conn)\n results.append((extend_replay, result, bg_thread))\n\n # Now we wait for results to come back. This is horribly inefficient\n # when some environments are much harder than others; oh well.\n succ_rates = []\n for _, result, bg_thread in tqdm.tqdm(results, desc='wait extend'):\n succ_rates.append(to_local(result.value))\n # always shut down cleanly\n bg_thread.stop()\n\n return succ_rates","def run(self):\n self.logger.info(\"start consuming api calls\")\n while not self.shutdown:\n self.rpc.listen()","def register_service(service, iface, name):","def register(self):\n # self.register_route(\"GET\", self.__route, lambda req, res: self.status(req, res))\n self.register_route(\"GET\", self.__route, None, self.status)","def intercept_server(server, *interceptors):\n from grpc_opentracing.grpcext import _interceptor\n return _interceptor.intercept_server(server, *interceptors)"],"string":"[\n \"async def register_rpc_proxies(self):\\n for rpc_name in self.rpc_proxy_list:\\n logger.debug('Registering RPC to Proxy: {}'.format(rpc_name))\\n\\n class RPCProxy:\\n\\n def __init__(self, local_session, rpc_name):\\n self._local_session = local_session\\n self._rpc_name = rpc_name\\n\\n async def __call__(self, *args, **kwargs):\\n logger.debug('Proxying RPC {}, with args {}, kwargs {}'.format(self._rpc_name, args, kwargs))\\n return await self._local_session.call(self._rpc_name, *args, **kwargs)\\n\\n await self.remote_session.register(RPCProxy(self.local_session, rpc_name), rpc_name)\",\n \"def _registerOnServer(self, daemon, nameserver,vclock):\\n uri = daemon.register(self)\\n nameserver.register(self._name, uri)\\n self.updateVectorClock(vclock)\\n print(\\\"Gateway registered. Name {} and uri {} \\\".format(self._name,uri))\",\n \"def _setup_rpc(self):\\n pass\",\n \"def xmlrpc_methods():\",\n \"def register_peer(self):\\n try:\\n self.get_file_list()\\n num_files = len(self.file_list)\\n total_ops = self.key_end - self.key_start\\n run_ops = total_ops/num_files\\n print \\\"Staring Benchmark Register Peer with Server...\\\"\\n t1 = time.time()\\n for i in range(run_ops):\\n for file in self.file_list:\\n self.service.put(file, self.peer_id)\\n t2 = time.time()\\n total = run_ops * num_files\\n print \\\"%s Register operations = %s sec\\\" % (total,t2-t1)\\n print \\\"per Register operation = %s sec\\\" % ((t2-t1)/total)\\n print \\\"per Register operation = %s msec\\\" % (((t2-t1)/total)*1000)\\n except Exception as e:\\n print \\\"Registering Peer Error, %s\\\" % e\\n sys.exit(1)\",\n \"def registerRPC(self, call, args = None):\\n\\n rpc = RemoteProcedureCall(self, len(self.rpc), args)\\n self.rpc.append(call)\\n return rpc\",\n \"def register_extensions(app):\\n grpc_channel = grpc.insecure_channel(\\n f\\\"{app.config['GRPC_SERVICE']}:{app.config['GRPC_PORT']}\\\",\\n )\\n grpc_client = GrpcClient(grpc_channel)\\n grpc_client.init_app(app)\",\n \"def make_json_handler(rpc):\\n\\n class JSONRPCHandler(BaseHTTPRequestHandler):\\n \\\"\\\"\\\"\\n A request handler for http.server that speaks JSON-RPC.\\n \\\"\\\"\\\"\\n def _validate_http_request(self):\\n \\\"\\\"\\\"\\n Ensures that we understand the HTTP portion of the request.\\n \\\"\\\"\\\"\\n if self.path != '/':\\n print('Invalid request path:', self.path)\\n self.send_error(HTTPStatus.NOT_FOUND, 'Request Must Have Path Of /')\\n raise ValueError\\n\\n content_type = self.headers.get('Content-Type', None)\\n if content_type != 'application/json':\\n print('Invalid request Content-Type:', self.path)\\n self.send_error(HTTPStatus.BAD_REQUEST, 'Content-Type Must Be application/json')\\n raise ValueError\\n\\n def _validate_rpc_request(self, request):\\n \\\"\\\"\\\"\\n Ensures that we understand the JSON-RPC portion of the request.\\n \\\"\\\"\\\"\\n if request.get('jsonrpc', None) != '2.0':\\n raise ValueError('Invalid jsonrpc: must be \\\"2.0\\\"')\\n\\n id = request.get('id', None)\\n if not (id is None or isinstance(id, (str, int, float))):\\n raise ValueError('Invalid id: must be null, string or number')\\n\\n method = request.get('method', None)\\n if not isinstance(method, str):\\n raise ValueError('Invalid method: must be string')\\n\\n params = request.get('params', [])\\n if not isinstance(params, (dict, list)):\\n raise ValueError('Invalid params: must be array or object')\\n\\n def _build_rpc_error(self, id, error, exception, keep_null_id=False):\\n \\\"\\\"\\\"\\n Returns an error response that can be encoded to JSON.\\n\\n By default this respects the ID of the request, and returns None if the\\n ID is also None. To override this behavior, set keep_null_id=True.\\n \\\"\\\"\\\"\\n if id is None and not keep_null_id:\\n return None\\n\\n message = RPC_ERROR_MESSAGES.get(error, str(exception))\\n\\n return {\\n 'jsonrpc': '2.0',\\n 'id': id,\\n 'error': {\\n 'code': error.value,\\n 'message': message,\\n 'data': {\\n 'stacktrace': str(exception) + '\\\\n' + '\\\\n'.join(traceback.format_tb(exception.__traceback__))\\n }\\n }\\n }\\n\\n def _build_rpc_result(self, id, result):\\n \\\"\\\"\\\"\\n Returns a result response that can be encoded to JSON.\\n \\\"\\\"\\\"\\n if id is None:\\n return None\\n\\n return {\\n 'jsonrpc': '2.0',\\n 'id': id,\\n 'result': result\\n }\\n\\n def _process_request(self, request):\\n \\\"\\\"\\\"\\n Calls a single RPC function and returns the result.\\n \\\"\\\"\\\"\\n try:\\n self._validate_rpc_request(request)\\n except ValueError as err:\\n return self._build_rpc_error(None, RpcErrors.INVALID_REQUEST, err, keep_null_id=True)\\n\\n id = request.get('id', None)\\n\\n try:\\n method = getattr(rpc, request['method'])\\n except AttributeError as err:\\n return self._build_rpc_error(id, RpcErrors.METHOD_NOT_FOUND, err)\\n\\n try:\\n params = request.get('params', None)\\n if params is None:\\n result = method()\\n elif isinstance(params, list):\\n result = method(*params)\\n elif isinstance(params, dict):\\n result = method(**params)\\n\\n return self._build_rpc_result(id, result)\\n\\n except TypeError as err:\\n return self._build_rpc_error(id, RpcErrors.INVALID_PARAMS, err)\\n except Exception as err:\\n return self._build_rpc_error(id, RpcErrors.INTERNAL_ERROR, err)\\n\\n def _send_json(self, value):\\n \\\"\\\"\\\"\\n Dumps the value to a JSON string, and sets the appropriate headers to\\n return it\\n \\\"\\\"\\\"\\n raw_value = json.dumps(value).encode('utf-8')\\n\\n self.send_response(200, 'OK')\\n for header, value in CORS_HEADERS.items():\\n self.send_header(header, value)\\n\\n self.send_header('Content-Type', 'application/json')\\n self.send_header('Content-Length', str(len(raw_value)))\\n self.end_headers()\\n\\n self.wfile.write(raw_value)\\n\\n def do_POST(self):\\n \\\"\\\"\\\"\\n Parses and processes a single or batch JSON-RPC request.\\n \\\"\\\"\\\"\\n try:\\n self._validate_http_request()\\n except ValueError:\\n return\\n\\n content_length = int(self.headers.get('Content-Length', '0'))\\n request_bytes = self.rfile.read(content_length)\\n while len(request_bytes) < content_length:\\n request_bytes += self.rfile.read(content_length - len(request_bytes))\\n\\n request_raw = request_bytes.decode('utf-8')\\n try:\\n request = json.loads(request_raw)\\n except ValueError as err:\\n error = self._build_rpc_error(None, RpcErrors.PARSE_ERROR, err, keep_null_id=True)\\n self._send_json(error)\\n return\\n\\n if isinstance(request, list):\\n responses = [self._process_request(single) for single in request]\\n response = [r for r in responses if r is not None]\\n elif isinstance(request, dict):\\n response = self._process_request(request)\\n else:\\n try:\\n raise ValueError\\n except ValueError as err:\\n error = self._build_rpc_error(None, RpcErrors.INVALID_REQUEST, err)\\n self._send_json(error)\\n return\\n\\n if response is not None:\\n self._send_json(response)\\n else:\\n self.send_response(200, 'OK')\\n self.end_headers()\\n\\n def do_OPTIONS(self):\\n \\\"\\\"\\\"\\n Sends back the headers necessary to support CORS\\n \\\"\\\"\\\"\\n print('Processing CORS OPTIONS request')\\n self.send_response(200, 'OK')\\n for header, value in CORS_HEADERS.items():\\n self.send_header(header, value)\\n\\n self.end_headers()\\n\\n return JSONRPCHandler\",\n \"def register_resources(self):\\n raise NotImplementedError\",\n \"def register_options(options):\\n return (\\n options\\n .register('jsonFilterFile',\\n type_=str,\\n default=None,\\n description=\\\"Path to JSON file containing certified runs and luminosity blocks.\\\")\\n .register('useHLTFilter',\\n type_=bool,\\n default=False,\\n description=\\\"If True, only events triggered by one of the skimmed paths will be \\\"\\n \\\"written out.\\\")\\n .register('jetCollections',\\n type_=str,\\n default=[],\\n multiplicity='list',\\n description=\\\"The names of the jet collections to use (e.g. 'AK4PFCHS').\\\")\\n .register('jecVersion',\\n type_=str,\\n default=None,\\n description=\\\"Tag of JEC version to use for e.g. JEC uncertainties.\\\")\\n .register('jecFromGlobalTag',\\n type_=bool,\\n default=False,\\n description=\\\"If True, the JECs will be looked up in the conditions database \\\"\\n \\\"(CondDB/Frontier) under the current global tag. If False, the \\\"\\n \\\"text files for `jecVersion` will be used.\\\")\\n .register('jerVersion',\\n type_=str,\\n default=None,\\n description=\\\"Tag of JER version to use for e.g. jet smearing.\\\")\\n .register('jerMethod',\\n type_=str,\\n default='stochastic',\\n description=\\\"Method to use for JER smearing. One of: 'stochastic', 'hybrid'\\\")\\n .register('jerGenMatchPtSigma',\\n type_=float,\\n default=3.0,\\n description=\\\"Size of Gaussian core for 'hybrid' JER smearing.\\\")\\n .register('jetIDSpec',\\n type_=str,\\n default=None,\\n description=\\\"Version of Jet ID to use (e.g. '2016').\\\")\\n .register('jetIDWorkingPoint',\\n type_=str,\\n default=None,\\n description=\\\"Working point of Jet ID to use (e.g. 'TightLepVeto').\\\")\\n .register('prefiringWeightFilePath',\\n type_=str,\\n default=\\\"\\\",\\n description=\\\"Path to ROOT file containing prefiring weights.\\\")\\n .register('prefiringWeightHistName',\\n type_=str,\\n default=\\\"\\\",\\n description=\\\"Name of histogram inside prefiring weights file (e.g. 'L1prefiring_jetpt_2016BCD').\\\")\\n .register('useObjectBasedJetID',\\n type_=bool,\\n default=False,\\n description=\\\"If True, only jets passing the ID specified via 'jetIDSpec' and `jetIDWorkingPoint` will be considered valid.\\\")\\n .register('checkForCompleteness',\\n type_=bool,\\n default=False,\\n description=(\\\"(for testing) If True, will run some checks on the \\\"\\n \\\"Ntuple output to ensure all branches are written out \\\"\\n \\\"and no branch is omitted.\\\"))\\n .register('stitchingWeight',\\n type_=float,\\n default=1.0,\\n description=(\\\"(deprecated) The output branch 'stitchingWeight' \\\"\\n \\\"will contain this value for each event. Can then be \\\"\\n \\\"used when stitching together different samples.\\\"))\\n .register('doJECUncertaintySources',\\n type_=bool,\\n default=False,\\n description=\\\"Fill ntuple branch with JEC correction factors for individual JEC uncertainty sources.\\\")\\n .register('doPrescales',\\n type_=bool,\\n default=False,\\n description=\\\"Write out trigger prescales to Ntuple.\\\")\\n .register('edmOut',\\n type_=bool,\\n default=False,\\n description=\\\"(for testing only) Write out EDM file.\\\")\\n )\",\n \"def _register_services(self, pipeline):\\n\\n pipeline.register_service(self._aprs_service)\",\n \"def register_server(self, ppclassname, ppclass):\\n\\n global rpc_pp_class\\n\\n def accept(cmd, data, eof, sock, address):\\n \\\"\\\"\\\" This is called by the rpc.py's tcp listener when a remote\\n client connects \\\"\\\"\\\"\\n\\n ppclass = rpc_pp_class.get(cmd)\\n if ppclass == None:\\n warning('No PP class found: %s\\\\n' %(cmd))\\n return RPC_CLOSE\\n\\n # Instantiate the given server class\\n ppclass(address=address, sock=sock, data=data)\\n return RPC_RELEASE\\n\\n if register_rpchandler(ppclassname, accept):\\n rpc_pp_class[ppclassname] = ppclass\",\n \"def register_router(self, router):\\n for prefix, viewset, basename in router.registry:\\n self.register(prefix, viewset, base_name=basename)\",\n \"def register_rpc_backend(backend_name, init_rpc_backend_handler):\\n rpc_backend_registry = _get_rpc_backend_registry()\\n if backend_name in rpc_backend_registry:\\n raise RuntimeError(\\\"Rpc backend {}: already registered\\\".format(backend_name))\\n rpc_backend_registry[backend_name] = init_rpc_backend_handler\",\n \"def __init__(self):\\n super(LoopbackTransport, self).__init__([_JSON_RPC_SERVER_PATH])\",\n \"def configure_rpc(cls, scheme=None):\\r\\n scheme = scheme or cls._meta.scheme\\r\\n\\r\\n if not scheme:\\r\\n return\\r\\n\\r\\n if isinstance(scheme, basestring):\\r\\n scheme = importlib.import_module(scheme)\\r\\n\\r\\n cls.scheme_name = scheme.__name__\\r\\n\\r\\n methods = getattr(scheme, '__all__', None) \\\\\\r\\n or [m for m in dir(scheme) if not m.startswith('_')]\\r\\n\\r\\n for mname in methods:\\r\\n method = getattr(scheme, mname)\\r\\n if hasattr(method, '__call__'):\\r\\n cls.methods[\\\"{0}.{1}\\\".format(\\r\\n cls.scheme_name, method.__name__)] = method\",\n \"def remotes():\",\n \"def registerServer(srv):\\n srv.setListenAddress(hostname)\\n srv.setMachine(getMBean('/Machines/'+machineName))\",\n \"def register(self):\\n\\n RPCObjectsRegistry.add(self)\",\n \"def server_plugin():\",\n \"async def test_multiple_rpc_transports(loop, server, redis_server_b, consume_rpcs):\\n registry.add(ApiA())\\n registry.add(ApiB())\\n\\n manually_set_plugins(plugins={})\\n\\n redis_server_a = server\\n\\n port_a = redis_server_a.tcp_address.port\\n port_b = redis_server_b.tcp_address.port\\n\\n logging.warning(f'Server A port: {port_a}')\\n logging.warning(f'Server B port: {port_b}')\\n\\n config = Config.load_dict({\\n 'bus': {\\n 'schema': {\\n 'transport': {'redis': {'url': f'redis://localhost:{port_a}'}},\\n }\\n },\\n 'apis': {\\n 'default': {\\n 'rpc_transport': {'redis': {'url': f'redis://localhost:{port_a}'}},\\n 'result_transport': {'redis': {'url': f'redis://localhost:{port_a}'}},\\n },\\n 'api_b': {\\n 'rpc_transport': {'redis': {'url': f'redis://localhost:{port_b}'}},\\n 'result_transport': {'redis': {'url': f'redis://localhost:{port_b}'}},\\n },\\n }\\n })\\n\\n bus = BusNode(name='', parent=None, bus_client=lightbus.BusClient(config=config, loop=loop))\\n asyncio.ensure_future(consume_rpcs(bus))\\n await asyncio.sleep(0.1)\\n\\n await bus.api_a.rpc_a.call_async()\\n await bus.api_b.rpc_b.call_async()\",\n \"def register_specs(self, *args):\\n self._corespecs_queue.extend(*args)\",\n \"def _initiate_registry_from_torchlib(\\n self, torchlib_registry: registration.Registry\\n ):\\n for aten_name, aten_overloads_func in torchlib_registry.items():\\n for func in aten_overloads_func.overloads:\\n self.register(\\n aten_name,\\n self._opset_version,\\n func,\\n custom=False,\\n )\",\n \"def _serve(self) -> None:\\n for instrument in self._config[\\\"instruments\\\"]:\\n uri = self._daemon.register(instrument, objectId=str(instrument))\\n self._services[instrument.id] = str(uri)\\n logger.success(f\\\"Registered {instrument} at {uri}\\\")\\n self.uri = self._daemon.register(self, objectId=self.servername)\\n logger.success(f\\\"Registered self at {self.uri}\\\")\",\n \"def __init__(self,server_list):\\n self.workers=[]\\n self.worker_by_name={}\\n worker_id = 1\\n for host,port in server_list:\\n # Add the uid here can help with port conflicts, but only works\\n # on Unix clusters. We really need to work out a daemon service\\n # model that makes the port mess transparent.\\n port = port #+ os.getuid()\\n new_worker = sync_cluster.standard_sync_client(host,port,worker_id)\\n self.workers.append(new_worker)\\n self.worker_by_name[host] = new_worker\\n worker_id = worker_id + 1\",\n \"def extend(self, router):\\n self.registry.extend(router.registry)\",\n \"def register_classes():\\n DiffuseCompChain.register_class()\\n CatalogCompChain.register_class()\\n DiffuseAnalysisChain.register_class()\",\n \"def ListWorkers(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def server_plugin_list(ctx):\\n data = ctx.obj.get_all_plugins()\\n output_json_data(data)\",\n \"def api_all():\\n update_pvserver_instances(pvserver_instances)\\n return jsonify(pvserver_instances)\",\n \"def __init__(self, addr=(\\\"localhost\\\", 8000)):\\n\\n Thread.__init__(self)\\n RPCBaseProxy.__init__(self)\\n\\n self.__instances = []\\n\\n self.__server = SimpleXMLRPCServer(addr=addr, logRequests=False, requestHandler=SimpleXMLRPCRequestHandler)\\n self.__server.register_instance(self)\",\n \"def RegisterPlayers(self):\\n self.tcf.RegisterPlayers(self.player_handler.GetPlayers())\",\n \"def _register_services(self) -> None:\\n\\n for isr in self.immediate_services_with_reply:\\n # Create a single instance of the service to cache in the router corresponding\\n # to one or more message types.\\n isr_instance = isr()\\n for handler_type in isr.message_handler_types():\\n # for each explicitly supported type, add it to the router\\n self.immediate_msg_with_reply_router[handler_type] = isr_instance\\n\\n # for all sub-classes of the explicitly supported type, add them\\n # to the router as well.\\n for handler_type_subclass in get_subclasses(obj_type=handler_type):\\n self.immediate_msg_with_reply_router[\\n handler_type_subclass\\n ] = isr_instance\\n\\n for iswr in self.immediate_services_without_reply:\\n # Create a single instance of the service to cache in the router corresponding\\n # to one or more message types.\\n iswr_instance = iswr()\\n for handler_type in iswr.message_handler_types():\\n\\n # for each explicitly supported type, add it to the router\\n self.immediate_msg_without_reply_router[handler_type] = iswr_instance\\n\\n # for all sub-classes of the explicitly supported type, add them\\n # to the router as well.\\n for handler_type_subclass in get_subclasses(obj_type=handler_type):\\n self.immediate_msg_without_reply_router[\\n handler_type_subclass\\n ] = iswr_instance\\n\\n for eswr in self.eventual_services_without_reply:\\n # Create a single instance of the service to cache in the router corresponding\\n # to one or more message types.\\n eswr_instance = eswr()\\n for handler_type in eswr.message_handler_types():\\n\\n # for each explicitly supported type, add it to the router\\n self.eventual_msg_without_reply_router[handler_type] = eswr_instance\\n\\n # for all sub-classes of the explicitly supported type, add them\\n # to the router as well.\\n for handler_type_subclass in get_subclasses(obj_type=handler_type):\\n self.eventual_msg_without_reply_router[\\n handler_type_subclass\\n ] = eswr_instance\\n\\n # Set the services_registered flag to true so that we know that all services\\n # have been properly registered. This mostly exists because someone might\\n # accidentally delete (forget to call) this method inside the __init__ function\\n # of a sub-class of Node.\\n self.services_registered = True\",\n \"def _register(self, comm, handler):\",\n \"def StartAllProtocols(self, *args, **kwargs):\\n # type: (*Any, **Any) -> None\\n payload = {}\\n for i in range(len(args)):\\n payload[\\\"Arg%s\\\" % (i + 1)] = args[i]\\n for item in kwargs.items():\\n payload[item[0]] = item[1]\\n return self._execute(\\\"startAllProtocols\\\", payload=payload, response_object=None)\",\n \"def register_plugins(self):\\n if self.plugin_whitelist:\\n plugin_list = self.plugin_whitelist\\n else:\\n plugin_list = plugins.__all__\\n\\n for plugin in plugin_list:\\n if plugin in plugins.__all__:\\n self.register_plugin(plugin,\\n self.plugin_config.get(plugin, {}))\\n else:\\n raise NameError(\\\"Plugin %s not in plugins.__all__.\\\" % plugin)\\n\\n # Resolve plugin inter-dependencies.\\n for plugin in self.plugin:\\n self.plugin[plugin].post_init()\",\n \"def start_protocols(self, context: ResourceCommandContext) -> None:\\n self.handler.start_protocols()\",\n \"def GetServers(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def remote_registerEngine(self, engineReference):\",\n \"def _negotiate_protocols(self, protocols, direction):\\n uris = [p.uri for p in protocols]\\n if direction in ['pushFromVoSpace', 'pullToVoSpace']:\\n supported = list(set(uris) & set(CLIENT_PROTOCOLS))\\n else:\\n supported = list(set(uris) & set(SERVER_PROTOCOLS))\\n if len(supported) == 0: raise VOSpaceError(500, \\\"The service supports none of the requested Protocols\\\", summary = PROTOCOL_NOT_SUPPORTED)\\n selected = [p for p in protocols if p.uri in supported]\\n if direction in ['pullFromVoSpace', 'pushToVoSpace']:\\n for protocol in selected:\\n protocol.set_endpoint(SERVER_PROTOCOLS[protocol.uri].get_endpoint())\\n return selected\",\n \"def connect_multiplexer(multiplexer):\",\n \"def register_plugin_calls(*funcs):\\n wrapped_dict = {}\\n for func in funcs:\\n wrapped_dict[func.__name__] = _handle_serialization(func)\\n XenAPIPlugin.dispatch(wrapped_dict)\",\n \"def mergeRPC(remoteETM,remoteLoca): #Status: WIP\\r\\n pass\",\n \"def register():\\n \\n global _registered\\n if not _registered:\\n _registered = True\\n sys.path_hooks.insert(0, VFSImporter)\",\n \"def register_interface_magics(self):\\n from sage.repl.interface_magic import InterfaceMagic\\n InterfaceMagic.register_all(self.shell)\",\n \"def rpc(self) -> global___Rpc:\",\n \"def _register_serializers(self):\\n import ray.util.serialization_addons\\n from ray.util.serialization import StandaloneSerializationContext\\n\\n ctx = StandaloneSerializationContext()\\n ray.util.serialization_addons.apply(ctx)\",\n \"def registerPatches(self,pl):\\n self.set('patchmesh.patches',pl)\",\n \"def register_handlers(dp, di_container: di.Container):\\n general.router.register_handlers(dp)\\n\\n di_container.wire(packages=[sys.modules[__name__]])\",\n \"def register_response_receivers(self, *response_receivers):\\n for response_receiver in response_receivers:\\n self.translator.message_receivers.append(response_receiver)\",\n \"def createSimpleXMLRPCServer(host, ports):\\n\\tfor port in ports:\\n\\t\\ttry:\\n\\t\\t\\tres = xserver.SimpleXMLRPCServer((host,port))\\n\\t\\texcept Exception as e:\\n\\t\\t\\tprint(\\\"Retrying:%s\\\"%(e))\\n\\t\\telse:\\n\\t\\t\\tres.logRequests = 0 # hint from newsgroup to disable the - - [13/Apr/2007 13:33:57] \\\"POST /RPC2 HTTP/1.0\\\" 200 - output with every request\\n\\t\\t\\treturn res\",\n \"def rpc_call_to_all(client, call, prefix=DOCK_CONTAINER_NAME_PREFIX_BTC, arguments=None,\\n rpc_user=BTC_RPC_USER, rpc_password=BTC_RPC_PASSWD, rpc_port=BTC_RPC_PORT):\\n try:\\n containers = get_containers_names(client, prefix)\\n r = []\\n for c in containers:\\n rpc_server = get_ip_by_unknown(client, c)\\n rpc_connection = AuthServiceProxy(\\\"http://%s:%s@%s:%s\\\" % (rpc_user, rpc_password, rpc_server, rpc_port))\\n args = \\\"(\\\" + arguments + \\\")\\\" if arguments else \\\"()\\\"\\n r.append(eval(\\\"rpc_connection.\\\" + call + args))\\n return r\\n except JSONRPCException as err:\\n return False\",\n \"def _register_methods(self, registry, instance_type):\\n to_register = list(instance_type.jit_methods) + \\\\\\n list(instance_type.jit_static_methods)\\n for meth in to_register:\\n\\n # There's no way to retrieve the particular method name\\n # inside the implementation function, so we have to register a\\n # specific closure for each different name\\n if meth not in self.implemented_methods:\\n self._implement_method(registry, meth)\\n self.implemented_methods.add(meth)\",\n \"def install_serve_encoders_to_fastapi():\\n # https://stackoverflow.com/questions/62311401/override-default-encoders-for-jsonable-encoder-in-fastapi # noqa\\n pydantic.json.ENCODERS_BY_TYPE.update(serve_encoders)\\n # FastAPI cache these encoders at import time, so we also needs to refresh it.\\n fastapi.encoders.encoders_by_class_tuples = (\\n fastapi.encoders.generate_encoders_by_class_tuples(\\n pydantic.json.ENCODERS_BY_TYPE\\n )\\n )\",\n \"def _register_pycoin_networks() -> None:\\n import os\\n\\n global _registered_pycoin\\n if _registered_pycoin:\\n return\\n _registered_pycoin = True\\n\\n paths = os.environ.get('PYCOIN_NETWORK_PATHS', '').split()\\n if 'hathor.pycoin' not in paths:\\n paths.append('hathor.pycoin')\\n os.environ['PYCOIN_NETWORK_PATHS'] = ' '.join(paths)\",\n \"def rpcmethod(func):\\n func.rpcmethod = True\\n return func\",\n \"def _register_handlers(self):\\n self.jm.register_handler(\\\"move_node\\\", self.move_node)\\n self.jm.register_handler(\\\"copy_node\\\", self.copy_node)\\n self.jm.register_handler(\\\"push_to_vospace\\\", self.push_to_vospace)\\n self.jm.register_handler(\\\"push_from_vospace\\\", self.push_from_vospace)\\n self.jm.register_handler(\\\"pull_to_vospace\\\", self.pull_to_vospace)\\n self.jm.register_handler(\\\"pull_from_vospace\\\", self.pull_from_vospace)\",\n \"def registerWebsocketProtocol(connection, protocol): #@NoSelf\",\n \"def makeHandlers(self):\\n\\n yield self.loadGrids.start(funcSelf=self)\\n yield self.updateClientWatchedGrids.start(funcSelf=self)\\n logger.debug(\\\"RPCs started\\\")\",\n \"def __init__(self, rpc, encoder):\\n super(EncoderModule, self).__init__(rpc, 'encoder', encoder)\",\n \"def register_resources(self, resources):\\n for resource in resources:\\n self.register_resource(resource)\",\n \"def rpc_method(func):\\n func.rpc_callable = True\\n return func\",\n \"def add_servers(self, servers: List[Server]):\\n pass\",\n \"def add_ip_cores(self, scfg, ip_dir):\\r\\n\\r\\n return []\",\n \"def register_opts():\\n _register_api_opts()\\n _register_db_opts()\",\n \"def registerXMLRPC(self, unique_service_name, instance, endpoint):\\n # TODO only set the ClientCert Handler if configured\\n handler = XMLRPCHandler(unique_service_name)\\n handler.connect(self._flaskapp.app, endpoint)\\n handler.register_instance(instance)\",\n \"def register_blueprints(api):\\n for module in MODULES:\\n api.register_blueprint(module.blp)\",\n \"def beta_create_CoreRPC_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):\\n request_deserializers = {\\n ('pb.CoreRPC', 'AddNode'): AddNodeOptions.FromString,\\n ('pb.CoreRPC', 'AddPod'): AddPodOptions.FromString,\\n ('pb.CoreRPC', 'Backup'): BackupOptions.FromString,\\n ('pb.CoreRPC', 'BuildImage'): BuildImageOptions.FromString,\\n ('pb.CoreRPC', 'CreateContainer'): DeployOptions.FromString,\\n ('pb.CoreRPC', 'GetContainer'): ContainerID.FromString,\\n ('pb.CoreRPC', 'GetContainers'): ContainerIDs.FromString,\\n ('pb.CoreRPC', 'GetNode'): GetNodeOptions.FromString,\\n ('pb.CoreRPC', 'GetPod'): GetPodOptions.FromString,\\n ('pb.CoreRPC', 'ListNetworks'): GetPodOptions.FromString,\\n ('pb.CoreRPC', 'ListPodNodes'): ListNodesOptions.FromString,\\n ('pb.CoreRPC', 'ListPods'): Empty.FromString,\\n ('pb.CoreRPC', 'ReallocResource'): ReallocOptions.FromString,\\n ('pb.CoreRPC', 'RemoveContainer'): ContainerIDs.FromString,\\n ('pb.CoreRPC', 'RemoveImage'): RemoveImageOptions.FromString,\\n ('pb.CoreRPC', 'RemoveNode'): RemoveNodeOptions.FromString,\\n ('pb.CoreRPC', 'RemovePod'): RemovePodOptions.FromString,\\n ('pb.CoreRPC', 'RunAndWait'): RunAndWaitOptions.FromString,\\n ('pb.CoreRPC', 'SetNodeAvailable'): NodeAvailable.FromString,\\n }\\n response_serializers = {\\n ('pb.CoreRPC', 'AddNode'): Node.SerializeToString,\\n ('pb.CoreRPC', 'AddPod'): Pod.SerializeToString,\\n ('pb.CoreRPC', 'Backup'): BackupMessage.SerializeToString,\\n ('pb.CoreRPC', 'BuildImage'): BuildImageMessage.SerializeToString,\\n ('pb.CoreRPC', 'CreateContainer'): CreateContainerMessage.SerializeToString,\\n ('pb.CoreRPC', 'GetContainer'): Container.SerializeToString,\\n ('pb.CoreRPC', 'GetContainers'): Containers.SerializeToString,\\n ('pb.CoreRPC', 'GetNode'): Node.SerializeToString,\\n ('pb.CoreRPC', 'GetPod'): Pod.SerializeToString,\\n ('pb.CoreRPC', 'ListNetworks'): Networks.SerializeToString,\\n ('pb.CoreRPC', 'ListPodNodes'): Nodes.SerializeToString,\\n ('pb.CoreRPC', 'ListPods'): Pods.SerializeToString,\\n ('pb.CoreRPC', 'ReallocResource'): ReallocResourceMessage.SerializeToString,\\n ('pb.CoreRPC', 'RemoveContainer'): RemoveContainerMessage.SerializeToString,\\n ('pb.CoreRPC', 'RemoveImage'): RemoveImageMessage.SerializeToString,\\n ('pb.CoreRPC', 'RemoveNode'): Pod.SerializeToString,\\n ('pb.CoreRPC', 'RemovePod'): Empty.SerializeToString,\\n ('pb.CoreRPC', 'RunAndWait'): RunAndWaitMessage.SerializeToString,\\n ('pb.CoreRPC', 'SetNodeAvailable'): Node.SerializeToString,\\n }\\n method_implementations = {\\n ('pb.CoreRPC', 'AddNode'): face_utilities.unary_unary_inline(servicer.AddNode),\\n ('pb.CoreRPC', 'AddPod'): face_utilities.unary_unary_inline(servicer.AddPod),\\n ('pb.CoreRPC', 'Backup'): face_utilities.unary_unary_inline(servicer.Backup),\\n ('pb.CoreRPC', 'BuildImage'): face_utilities.unary_stream_inline(servicer.BuildImage),\\n ('pb.CoreRPC', 'CreateContainer'): face_utilities.unary_stream_inline(servicer.CreateContainer),\\n ('pb.CoreRPC', 'GetContainer'): face_utilities.unary_unary_inline(servicer.GetContainer),\\n ('pb.CoreRPC', 'GetContainers'): face_utilities.unary_unary_inline(servicer.GetContainers),\\n ('pb.CoreRPC', 'GetNode'): face_utilities.unary_unary_inline(servicer.GetNode),\\n ('pb.CoreRPC', 'GetPod'): face_utilities.unary_unary_inline(servicer.GetPod),\\n ('pb.CoreRPC', 'ListNetworks'): face_utilities.unary_unary_inline(servicer.ListNetworks),\\n ('pb.CoreRPC', 'ListPodNodes'): face_utilities.unary_unary_inline(servicer.ListPodNodes),\\n ('pb.CoreRPC', 'ListPods'): face_utilities.unary_unary_inline(servicer.ListPods),\\n ('pb.CoreRPC', 'ReallocResource'): face_utilities.unary_stream_inline(servicer.ReallocResource),\\n ('pb.CoreRPC', 'RemoveContainer'): face_utilities.unary_stream_inline(servicer.RemoveContainer),\\n ('pb.CoreRPC', 'RemoveImage'): face_utilities.unary_stream_inline(servicer.RemoveImage),\\n ('pb.CoreRPC', 'RemoveNode'): face_utilities.unary_unary_inline(servicer.RemoveNode),\\n ('pb.CoreRPC', 'RemovePod'): face_utilities.unary_unary_inline(servicer.RemovePod),\\n ('pb.CoreRPC', 'RunAndWait'): face_utilities.stream_stream_inline(servicer.RunAndWait),\\n ('pb.CoreRPC', 'SetNodeAvailable'): face_utilities.unary_unary_inline(servicer.SetNodeAvailable),\\n }\\n server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout)\\n return beta_implementations.server(method_implementations, options=server_options)\",\n \"def _bind_method_serializers(self, meth_serializers):\\n\\n # We can't use update because that would be the wrong\\n # precedence\\n for mtype, serializer in meth_serializers.items():\\n self.serializers.setdefault(mtype, serializer)\",\n \"def pedrpc_connect(self):\\n # If the process monitor is alive, set it's options\\n if self.procmon:\\n while 1:\\n if self.procmon.alive():\\n break\\n\\n time.sleep(1)\\n\\n # connection established.\\n for key, value in self.procmon_options.items():\\n getattr(self.procmon, 'set_{0}'.format(key))(value)\\n\\n # If the network monitor is alive, set it's options\\n if self.netmon:\\n while 1:\\n if self.netmon.alive():\\n break\\n\\n time.sleep(1)\\n\\n # connection established.\\n for key in self.netmon_options.keys():\\n eval('self.netmon.set_%s(self.netmon_options[\\\"%s\\\"])' % (key, key))\",\n \"def rpc_match():\",\n \"def main(server):\\n config_parser = ConfigParser()\\n config_parser.read('resources/conf/config.ini')\\n\\n log_level = log_levels.get(config_parser.get('core', 'log.level'))\\n log_filename = config_parser.get('core', 'log.path')\\n logging.basicConfig(level=log_level,\\n format='%(levelname)s:%(asctime)s:%(message)s',\\n filename=log_filename)\\n replicator = Replicator(config_parser)\\n executor = ThreadPoolExecutor(max_workers=2)\\n executor.submit(replicator.start)\\n logger = logging.getLogger('replicator')\\n if log_level == 'DEBUG':\\n handler = logging.StreamHandler()\\n handler.setLevel(logging.DEBUG)\\n logger.addHandler(handler)\\n if server:\\n if config_parser.has_section('server'):\\n check_server_configuration(config_parser, logger)\\n server_config = {\\n 'server.socket_host' : config_parser.get('server', 'socket_host'),\\n 'server.socket_port' : config_parser.getint('server', 'socket_port'),\\n 'log.access_file' : config_parser.get('server', 'log.access_file'),\\n 'log.error_file' : config_parser.get('server', 'log.error_file')\\n }\\n cherrypy.config.update(server_config)\\n logger.info('Server will be started at %s:%d' % (server_config['server.socket_host'],\\n server_config['server.socket_port']))\\n else:\\n logger.info('No settings found, using the default one. (localhost:8080)')\\n executor.submit(cherrypy.quickstart(ReplicatorServer(replicator)))\",\n \"def register_routes(self):\\n @inlineCallbacks\\n def registered(response):\\n if response.code != 200:\\n text = yield response.text()\\n self._env.logger.error('{} {}'.format(response.code, text))\\n\\n try:\\n api_register = '{}://{}:{}/api/1.0.0/register'.format(\\n self._env.api_protocol,\\n self._env.api_host,\\n self._env.api_port\\n )\\n remote_ms = self._env.get('remote_ms', None)\\n\\n for path in self._env.swagger.paths:\\n uri = self._env.swagger.base + path.split('{')[0].rstrip('/')\\n if remote_ms:\\n route = {\\n 'protocol': 'https',\\n 'host': remote_ms,\\n 'port': 443,\\n }\\n else:\\n if self._env.get('flask_private'):\\n route = {\\n 'protocol': self._env.get('flask_protocol'),\\n 'host': self._env.get('flask_host'),\\n 'port': self._env.get('flask_port'),\\n }\\n else:\\n route = {\\n 'protocol': self._env.flask_protocol,\\n 'host': self._env.flask_host,\\n 'port': self._env.flask_port,\\n }\\n route = dict(route, **{'uri': uri, 'key': self._key})\\n #self._env.logger.info('Route> {}'.format(str(route)))\\n treq.post(api_register, data={'details': dumps(route)}).addCallback(registered)\\n\\n swagger_paths = ['/ui/css', '/ui/lib', '/ui/images', '/swagger.json']\\n ui = '/' + self._env.get('swagger_ui', 'ui')+'/'\\n swagger_paths.append(ui)\\n\\n for path in swagger_paths:\\n uri = self._env.swagger.base\\n if len(uri):\\n if uri[-1] == '/':\\n uri = uri[:-1]\\n uri += path\\n if self._env.get('flask_private'):\\n route = {\\n 'protocol': self._env.get('flask_protocol'),\\n 'host': self._env.get('flask_host'),\\n 'port': self._env.get('flask_port'),\\n 'uri': uri,\\n 'key': self._key,\\n 'ui': path == ui,\\n 'name': self._env.get('my_name', 'no local name', 'microservice')\\n }\\n else:\\n route = {\\n 'protocol': self._env.flask_protocol,\\n 'host': self._env.flask_host,\\n 'port': self._env.flask_port,\\n 'uri': uri,\\n 'key': self._key,\\n 'ui': path == ui,\\n 'name': self._env.get('my_name', 'no local name', 'microservice')\\n }\\n treq.post(api_register, data={'details': dumps(route)}).addCallback(registered)\\n\\n return True\\n except Exception as e:\\n self._env.logger.error('error registering routes \\\"{}\\\"'.format(str(e)))\",\n \"def register_classes():\\n CollectLimits.register_class()\\n CollectLimits_SG.register_class()\\n CollectStackedLimits_SG.register_class()\",\n \"def registerBlueprints(module_name):\\n module = importlib.import_module(\\n \\\"app.modules.\\\" + module_name, package=None)\\n bp = getattr(module, module_name)\\n server_logger.info(\\\"Registering module: \\\" + module_name)\\n if bp.name == \\\"index\\\":\\n server.register_blueprint(bp)\\n else:\\n server.register_blueprint(bp, url_prefix='/' + bp.name)\",\n \"def _setup_rpc(self):\\n\\n endpoints = RpcCallBacks(self)\\n self.server = rpc.DfaRpcServer(self.ser_q, self._host,\\n self.cfg.dfa_rpc.transport_url,\\n endpoints,\\n exchange=constants.DFA_EXCHANGE)\",\n \"def RegisterProtoRPCServiceToFlaskApp(app_inst, path, service_inst,\\n service_name=None):\\n service_name = service_name or service_inst.SERVICE_DESCRIPTOR.name\\n endpoint_name = '__protorpc_service_view_func_' + str(uuid.uuid1())\\n view_func = _ProtoRPCServiceFlaskAppViewFunc(service_inst)\\n app_inst.add_url_rule('%s/%s.<method_name>' % (path, service_name),\\n endpoint=endpoint_name, view_func=view_func,\\n methods=['POST'])\",\n \"def _register_with_cluster(self, cpu_count):\\n try:\\n reply = cluster.send_command({\\n \\\"op\\\": \\\"register\\\",\\n \\\"address\\\": self.address,\\n \\\"port_number\\\": port_number,\\n \\\"cpu_count\\\": cpu_count\\n }, wait_for_reply=True)\\n\\n if reply[\\\"op\\\"] == \\\"reply\\\":\\n # print cluster information\\n cluster_info = cluster.cluster_info\\n print(\\\"Worker server at\\\", self.address, \\\"port number\\\", port_number)\\n print(\\\"Joined cluster at\\\", cluster_info[0][\\\"address\\\"],\\n \\\"port number\\\", cluster_info[0][\\\"port_number\\\"])\\n return True\\n\\n else: return False\\n\\n except Exception as ex:\\n print(\\\"Error:\\\", ex)\\n return False\",\n \"def restart_all():\\n\\n restart_nginx()\\n restart_supervisor()\",\n \"def register(self):\\n self._register_dockyard()\\n self._register_docker()\",\n \"def register_server():\\n (code, message) = rest_api.register_server(request)\\n if (code == 200):\\n return message\\n else:\\n abort(code)\",\n \"def register(name, func):\\n WebSocketRouter.funcmap[name] = func\",\n \"def __init__(self) :\\n self.remoteConnections = {}\",\n \"def serve_forever(self, poll_interval=0.5):\\n logging.info('RPC server starting')\\n self._idle_thread.start()\\n SimpleJSONRPCServer.SimpleJSONRPCServer.serve_forever(self, poll_interval)\",\n \"def __init__(self, rpc):\\n self.rpc = rpc\",\n \"def config_server_buffer_cb(data, option):\\n\\n for server in SERVERS.values():\\n server.buffer_merge()\\n return 1\",\n \"def register(self):\\n raise NotImplementedError\",\n \"def register(self):\\n raise NotImplementedError\",\n \"def registerExistingServer():\\n cd('/')\\n cd('/Servers/'+managedServername)\\n registerServer(cmo)\",\n \"async def register_schemas(\\n self, *, compatibility: str | None = None\\n ) -> None:\\n for subject_name, schema in self.schemas.items():\\n await self._registry.register_schema(\\n schema=schema,\\n subject=subject_name,\\n compatibility=compatibility,\\n )\",\n \"def start_servers(self, **kwargs):\\n self.cleanup()\\n\\n # Start up the API and default conductor server\\n\\n # We start the conductor server first, as the API server config\\n # depends on the conductor port - this ordering allows for\\n # retrying the launch on a port clash\\n self.start_with_retry(self.conductor_server, 'conductor_port', 3,\\n **kwargs)\\n kwargs['conductor_port'] = self.conductor_server.bind_port\\n\\n self.start_with_retry(self.api_server, 'api_port', 3, **kwargs)\",\n \"def interfaces(self):\",\n \"def interfaces(self):\",\n \"def register_blueprints(self):\\n # Local import due to flask/blueprint circular imports.\\n from mmapi.views import api_bp\\n self.app.register_blueprint(api_bp, url_prefix='/api')\",\n \"def __init__(self, sc, conf):\\n\\n super(LBaaSv2RpcManager, self).__init__(sc, conf)\",\n \"def _extend_replays(self, num_per_problem: int):\\n # fire off extension methods\\n results = []\\n for problem in tqdm.tqdm(self.problems, desc='spawn extend'):\\n get_action = self._make_get_action(problem)\\n extend_replay = rpyc.async(problem.problem_service.extend_replay)\\n result = extend_replay(get_action, num_per_problem)\\n # apparently I need to keep hold of async ref according to RPyC\\n # docs (it's weak or s.th). Also, I need a background thread to\\n # serve each environment's requests (...this may break things\\n # slightly).\\n bg_thread = rpyc.utils.helpers.BgServingThread(\\n problem.problem_server.conn)\\n results.append((extend_replay, result, bg_thread))\\n\\n # Now we wait for results to come back. This is horribly inefficient\\n # when some environments are much harder than others; oh well.\\n succ_rates = []\\n for _, result, bg_thread in tqdm.tqdm(results, desc='wait extend'):\\n succ_rates.append(to_local(result.value))\\n # always shut down cleanly\\n bg_thread.stop()\\n\\n return succ_rates\",\n \"def run(self):\\n self.logger.info(\\\"start consuming api calls\\\")\\n while not self.shutdown:\\n self.rpc.listen()\",\n \"def register_service(service, iface, name):\",\n \"def register(self):\\n # self.register_route(\\\"GET\\\", self.__route, lambda req, res: self.status(req, res))\\n self.register_route(\\\"GET\\\", self.__route, None, self.status)\",\n \"def intercept_server(server, *interceptors):\\n from grpc_opentracing.grpcext import _interceptor\\n return _interceptor.intercept_server(server, *interceptors)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5887183","0.53439647","0.5303127","0.5229928","0.5181709","0.51379925","0.5042705","0.5018712","0.50179935","0.5007511","0.50063205","0.50051254","0.49503332","0.4928616","0.4922325","0.4869519","0.4867418","0.48619875","0.4855552","0.4855092","0.48424605","0.48338652","0.48154017","0.4812718","0.47886303","0.4785449","0.47462106","0.47255152","0.47188923","0.47185788","0.4712613","0.47057647","0.4701785","0.46949998","0.46770906","0.4675679","0.46691817","0.46608844","0.46564987","0.46444878","0.4640018","0.46365026","0.46263722","0.46160498","0.4607915","0.4601826","0.45940533","0.45865545","0.458546","0.45689985","0.4566039","0.4563341","0.4554698","0.45435888","0.45314893","0.45247945","0.4516193","0.45137843","0.45019463","0.4500071","0.4488176","0.44809964","0.44768414","0.4461565","0.44516194","0.44457823","0.4443764","0.4438238","0.44329393","0.4431043","0.4418315","0.44037017","0.44012615","0.44007838","0.43958086","0.4384573","0.4382948","0.43785262","0.43757206","0.4363904","0.4361535","0.43577668","0.4354044","0.43513423","0.4348961","0.43475127","0.43447924","0.43447924","0.43445587","0.4342884","0.43405434","0.43392128","0.43392128","0.43377495","0.43376923","0.43319023","0.4330288","0.43201506","0.43200243","0.43152118"],"string":"[\n \"0.5887183\",\n \"0.53439647\",\n \"0.5303127\",\n \"0.5229928\",\n \"0.5181709\",\n \"0.51379925\",\n \"0.5042705\",\n \"0.5018712\",\n \"0.50179935\",\n \"0.5007511\",\n \"0.50063205\",\n \"0.50051254\",\n \"0.49503332\",\n \"0.4928616\",\n \"0.4922325\",\n \"0.4869519\",\n \"0.4867418\",\n \"0.48619875\",\n \"0.4855552\",\n \"0.4855092\",\n \"0.48424605\",\n \"0.48338652\",\n \"0.48154017\",\n \"0.4812718\",\n \"0.47886303\",\n \"0.4785449\",\n \"0.47462106\",\n \"0.47255152\",\n \"0.47188923\",\n \"0.47185788\",\n \"0.4712613\",\n \"0.47057647\",\n \"0.4701785\",\n \"0.46949998\",\n \"0.46770906\",\n \"0.4675679\",\n \"0.46691817\",\n \"0.46608844\",\n \"0.46564987\",\n \"0.46444878\",\n \"0.4640018\",\n \"0.46365026\",\n \"0.46263722\",\n \"0.46160498\",\n \"0.4607915\",\n \"0.4601826\",\n \"0.45940533\",\n \"0.45865545\",\n \"0.458546\",\n \"0.45689985\",\n \"0.4566039\",\n \"0.4563341\",\n \"0.4554698\",\n \"0.45435888\",\n \"0.45314893\",\n \"0.45247945\",\n \"0.4516193\",\n \"0.45137843\",\n \"0.45019463\",\n \"0.4500071\",\n \"0.4488176\",\n \"0.44809964\",\n \"0.44768414\",\n \"0.4461565\",\n \"0.44516194\",\n \"0.44457823\",\n \"0.4443764\",\n \"0.4438238\",\n \"0.44329393\",\n \"0.4431043\",\n \"0.4418315\",\n \"0.44037017\",\n \"0.44012615\",\n \"0.44007838\",\n \"0.43958086\",\n \"0.4384573\",\n \"0.4382948\",\n \"0.43785262\",\n \"0.43757206\",\n \"0.4363904\",\n \"0.4361535\",\n \"0.43577668\",\n \"0.4354044\",\n \"0.43513423\",\n \"0.4348961\",\n \"0.43475127\",\n \"0.43447924\",\n \"0.43447924\",\n \"0.43445587\",\n \"0.4342884\",\n \"0.43405434\",\n \"0.43392128\",\n \"0.43392128\",\n \"0.43377495\",\n \"0.43376923\",\n \"0.43319023\",\n \"0.4330288\",\n \"0.43201506\",\n \"0.43200243\",\n \"0.43152118\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78924644"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":54,"numItemsPerPage":100,"numTotalItems":95772,"offset":5400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3Mzg5Njg2NSwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzM5MDA0NjUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.URFzU5TQwFngrz_W_NWiDRzV9CfQfHNPceK1QdOQJZWbRfU5fCoFqcMCVFSzzuncIUYBCyUfBjco0GhrPW7TCQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
generates initial hidden states for each agent | def generate_initial_hidden_states(self, batch_size, test_mode=False, caller=None):
# Set up hidden states for all levels - and propagate through the runner!
hidden_dict = {}
hidden_dict["level1"] = th.stack([Variable(th.zeros(batch_size, 1, self.args.agents_hidden_state_size)) for _
in range(self.n_agents if self.is_obs_noise(test_mode) and caller != "learner" else 1)])
hidden_dict["level2"] = th.stack([Variable(th.zeros(batch_size, 1, self.args.agents_hidden_state_size)) for _
in range(len(sorted(combinations(list(range(self.n_agents)), 2)))*2
if self.is_obs_noise(test_mode) and caller != "learner" else
len(sorted(combinations(list(range(self.n_agents)), 2))))])
hidden_dict["level3"] = th.stack([Variable(th.zeros(batch_size, 1, self.args.agents_hidden_state_size)) for _
in range(self.n_agents)])
if self.args.use_cuda:
hidden_dict = {_k:_v.cuda() for _k, _v in hidden_dict.items()}
return hidden_dict, "?*bs*v*t" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initial_state(self):\n # Network details elided.\n return self.agent.initial_state()",
"def initial_state(self):\n # Network details elided.\n return self.agent.initial_state()",
"def initial_state(self):\n # Network details elided.\n return self.agent.initial_state()",
"def registerIni... | [
"0.6404829",
"0.6404829",
"0.6404829",
"0.6275053",
"0.62659883",
"0.62305397",
"0.6203651",
"0.6194984",
"0.61897767",
"0.6183285",
"0.60839427",
"0.6075158",
"0.6037105",
"0.6035622",
"0.60091317",
"0.59804654",
"0.59778255",
"0.59626013",
"0.5937987",
"0.5926602",
"0.59236... | 0.73379165 | 0 |
Each learner has it's own logging routine, which logs directly to the pythonwide logger if log_directly==True, and returns a logging string otherwise Logging is triggered in run.py | def log(self, test_mode=None, T_env=None, log_directly = True):
test_suffix = "" if not test_mode else "_test"
stats = self.get_stats()
try:
stats["pair_action_unavail_rate"+test_suffix] = _seq_mean(stats["pair_action_unavail_rate__runner"+test_suffix])
self._add_stat("pair_action_unavail_rate",
stats["pair_action_unavail_rate"+test_suffix],
T_env=T_env,
suffix=test_suffix,
to_sacred=True)
except:
pass
if stats == {}:
self.logging_struct.py_logger.warning("Stats is empty... are you logging too frequently?")
return "", {}
logging_dict = dict(T_env=T_env)
try:
logging_dict["pair_action_unavail_rate"+test_suffix] =stats["pair_action_unavail_rate"+test_suffix]
except:
pass
logging_str = ""
logging_str += _make_logging_str(_copy_remove_keys(logging_dict, ["T_env"+test_suffix]))
if log_directly:
self.logging_struct.py_logger.info("{} MC INFO: {}".format("TEST" if self.test_mode else "TRAIN",
logging_str))
return logging_str, logging_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log(self, log_directly = True):\n stats = self.get_stats()\n logging_dict = dict(advantage_mean = _seq_mean(stats[\"advantage_mean\"]),\n critic_grad_norm = _seq_mean(stats[\"critic_grad_norm\"]),\n critic_loss =_seq_mean(stats[\"critic_los... | [
"0.7626581",
"0.63579595",
"0.62751955",
"0.61822915",
"0.6168312",
"0.6166976",
"0.6134176",
"0.61169195",
"0.6112573",
"0.6073991",
"0.6049023",
"0.6018304",
"0.6004898",
"0.5980599",
"0.59766626",
"0.59521484",
"0.59347326",
"0.5919445",
"0.5915726",
"0.5904169",
"0.586773... | 0.5844291 | 23 |
Sends a message to TCP server | def send(self, msg):
if self.verbose:
print('<- out ' + msg)
self._socket.send_string(msg)
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_message(self, message):\r\n\t\tself.__tcpSocket.write(message.encode('utf8'))",
"def send(self, msg):\n self.__sock.send(msg)",
"def send(self, message):\n self.sock.send(message)",
"def sendMessage(self, msg):\n # Socket Object\n self.sock.connect((self.host, self.port))... | [
"0.857833",
"0.8029346",
"0.7997576",
"0.7927077",
"0.7885072",
"0.7848192",
"0.7783163",
"0.7779231",
"0.77461135",
"0.77231276",
"0.7711107",
"0.7656483",
"0.7619312",
"0.7602865",
"0.75940025",
"0.75879824",
"0.75759625",
"0.7557794",
"0.7549099",
"0.7539888",
"0.7537408",... | 0.7415012 | 27 |
Checks the ZeroMQ for data | def recv(self):
return self._socket.recv() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_invalid_data_is_empty(self, app, data_queues):\n res = self._call(app, {\"invalid\": 0}, ip=self.test_ip, status=200)\n self.check_response(data_queues, res, \"ok\")\n self.check_queue(data_queues, 0)",
"def _chk_empty(self, queue, receiver):\n try:\n msg = receive... | [
"0.6370523",
"0.6197868",
"0.61302525",
"0.6033723",
"0.5991278",
"0.59654814",
"0.58306265",
"0.58306265",
"0.57430387",
"0.57194114",
"0.567935",
"0.56438",
"0.5607466",
"0.5605082",
"0.559692",
"0.5590848",
"0.5575481",
"0.5566702",
"0.55629605",
"0.5525354",
"0.5514238",
... | 0.0 | -1 |
Initializes and returns an LSL outlet | def initializeOutlet(interface):
info = StreamInfo('OpenBCI_EEG', 'EEG', 4, 256, 'float32', 'openbci12345')
outlet = StreamOutlet(info)
return outlet | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_lamp_outlet(self, model):\r\n\r\n # Create a new CameraItem and set the model\r\n item = LampOutletItem()\r\n item.setModel(model)\r\n\r\n # Create a new CameraInfoWidget and set the model\r\n widget = LampOutletInfoWidget()\r\n widget.setModel(model)\r\n\r\n ... | [
"0.5946556",
"0.5688111",
"0.55620337",
"0.55175424",
"0.53838944",
"0.5277127",
"0.52567214",
"0.52559364",
"0.5208461",
"0.5208461",
"0.51927763",
"0.51246226",
"0.50718874",
"0.5064975",
"0.5049424",
"0.5043597",
"0.50424546",
"0.50129515",
"0.5001687",
"0.49760997",
"0.49... | 0.58739966 | 1 |
This function builds a dictionary of managers to manager nodes. | def buildHierarchy(self, test_input):
for entry in test_input:
if entry['manager']not in self.relations:
self.relations[entry['manager']] = Node(entry['manager'], entry['name'])
else:
self.relations[entry['manager']].employees.append(entry['name']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_managers():\n return {'managers': get_users('managers')}",
"def map_uses(self):\n out = {}\n for node in self.nodes.values():\n baddies = set()#track incomplete connections and relegate to attributes\n for rtype, dest in node.outgoing_relations:\n try... | [
"0.6298359",
"0.62928385",
"0.59723586",
"0.59544337",
"0.586242",
"0.58006024",
"0.57427794",
"0.5736032",
"0.56940466",
"0.56494904",
"0.5589373",
"0.5572555",
"0.5556493",
"0.5530863",
"0.55166465",
"0.5495922",
"0.5472622",
"0.5469694",
"0.5432187",
"0.54266393",
"0.54139... | 0.5909479 | 4 |
This function recursively builds a string of manager to employee relationships starting from the managers that do not have managers. | def findHierarchy(self):
def __recursiveHelper(key_name, output, indent):
if key_name in self.relations:
for employee in self.relations[key_name].employees:
output += " " * indent + str(employee) +"\n"
# return __recursiveHelper(employee, output, indent+1)
__recursiveHelper(employee, output, indent+1)
else:
print(output)
return output
#experimenting with Iter() and next() iterators/generators
#and a while loop in the recursive function:
# def __recursiveHelper(key_name, output, indent):
# if key_name in self.relations:
# employees = iter(self.relations[key_name].employees)
# employee = next(employees, "stop")
# while employees and employee != 'stop':
# output += " " * indent + str(employee) +"\n"
# __recursiveHelper(next(employees, "stop"), output, indent+1)
# else:
# employee = next(employees, "stop")
#
# else:
# return output
output = ""
indent = -1
# self.relations is a dictionary of manager-name string keys.
# The employees of None are the top-ranking managers.
# only issue:
# having trouble returning the concatenated output
# from the recursive function:
return __recursiveHelper(None, output, indent+1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def buildHierarchy(self, test_input):\n for entry in test_input:\n if entry['manager']not in self.relations:\n self.relations[entry['manager']] = Node(entry['manager'], entry['name'])\n else:\n self.relations[entry['manager']].employees.append(entry['name'... | [
"0.5634923",
"0.53542036",
"0.5284192",
"0.5087596",
"0.49705473",
"0.4939793",
"0.49350137",
"0.48989594",
"0.48973182",
"0.48740613",
"0.485191",
"0.48157832",
"0.47859207",
"0.47704506",
"0.47661456",
"0.4745172",
"0.47298232",
"0.47289705",
"0.4718572",
"0.46928048",
"0.4... | 0.6343025 | 0 |
r""" 1d nonlinear elasticity riemann solver aux is expected to contain aux[i,0] density in cell i aux[i,1] bulk modulus in cell i | def rp_nel_1d(q_l, q_r, aux_l, aux_r, aux_global):
meqn = 2
mwaves = 2
# Convenience
nrp = np.size(q_l, 0)
# Set up arrays for return values
fwave = np.empty((nrp, meqn, mwaves))
s = np.empty((nrp, mwaves))
amdq = np.empty((nrp, meqn))
apdq = np.empty((nrp, meqn))
# Linearized bulk modulus, sound speed, and impedance:
bulkl = sigmap(q_l[:, 0], aux_l[:, 1])
bulkr = sigmap(q_r[:, 0], aux_r[:, 1])
cl = np.sqrt(bulkl / aux_l[:, 0])
cr = np.sqrt(bulkr / aux_r[:, 0])
zl = cl * aux_l[:, 0]
zr = cr * aux_r[:, 0]
# Jumps:
du = q_r[:, 1] / aux_r[:, 0] - q_l[:, 1] / aux_l[:, 0]
dsig = sigma(q_r[:, 0], aux_r[:, 1]) - sigma(q_l[:, 0], aux_l[:, 1])
b1 = -(zr * du + dsig) / (zr + zl)
b2 = -(zl * du - dsig) / (zr + zl)
# Compute the f-waves
# 1-Wave
fwave[:, 0, 0] = b1
fwave[:, 1, 0] = b1 * zl
s[:, 0] = -cl
# 2-Wave
fwave[:, 0, 1] = b2
fwave[:, 1, 1] = b2 * (-zr)
s[:, 1] = cr
# Compute the left going and right going fluctuations
for m in range(meqn):
amdq[:, m] = fwave[:, m, 0]
apdq[:, m] = fwave[:, m, 1]
return fwave, s, amdq, apdq | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, cell):\n self._cell = cell\n self._residual_fn = gnmt_residual_fn",
"def auxmin_f1_part_i(x,m_ind):\n \n tmp1 = 2.0*auxminrho1(x,m_ind)-cfg.a[m_ind,cfg.nfea-1] \n tmp2 = 2.0*auxminrho2(x,m_ind)+cfg.a[m_ind,cfg.nfea-1]\n\n # checking maximum used in auxminrho1 \n if (tm... | [
"0.6120228",
"0.5804139",
"0.5638813",
"0.5638267",
"0.5628902",
"0.5628902",
"0.5626579",
"0.5618351",
"0.5618351",
"0.5618351",
"0.56004834",
"0.5596577",
"0.5594398",
"0.55738205",
"0.55608195",
"0.5557147",
"0.55332184",
"0.5526329",
"0.5496661",
"0.54944676",
"0.54727423... | 0.0 | -1 |
Extract zipfile to a directory if password is correct. | def extractfile(file, passwd):
try:
zipf = zipfile.ZipFile(file)
zipf.extractall(path=os.path.join(file[:-4]), pwd=str.encode(passwd))
print('Password: {}'.format(passwd))
except:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unzipArchives(zip_file, password):\n with ZipFile(zip_file) as archive:\n archive.extractall(pwd=bytes(password, \"utf8\"))",
"def unzip_item(source_path, destination_path, password):\n\n if not destination_path:\n destination_path = source_path.replace(\".zip\", \"\")\n if not os.path... | [
"0.73367697",
"0.68281114",
"0.6682046",
"0.66589713",
"0.6608535",
"0.65792376",
"0.65135366",
"0.65102696",
"0.6478845",
"0.64773226",
"0.64197737",
"0.6360199",
"0.6358647",
"0.6311184",
"0.62914145",
"0.6283126",
"0.6278718",
"0.62752926",
"0.62581104",
"0.62555015",
"0.6... | 0.7807078 | 0 |
Calculate Profit of Order | def calculate_profit(self): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def profit(self):\n retail_value = 0\n wholesale_value = 0\n for bike in self.sold:\n retail_value += bike.total_cost() + (\n self.retail_margin * bike.total_cost())\n wholesale_value += bike.total_cost()\n return retail_value - wholesale_value",
"... | [
"0.73407346",
"0.70521134",
"0.69925046",
"0.66937786",
"0.664156",
"0.6609153",
"0.660143",
"0.64814395",
"0.63270825",
"0.62858367",
"0.62036735",
"0.6141628",
"0.6069652",
"0.6067097",
"0.6044266",
"0.60409504",
"0.602659",
"0.6025829",
"0.6020886",
"0.6019667",
"0.6008011... | 0.79486245 | 0 |
Try to close when TakeProfit or StopLoss hits. | def try_to_close(self, candle_high, candle_low, time, pre_candle_close=0.0, pre_time=None): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def close(self):\n\t\tself.applied = 0",
"def _close(self):\n # TODO\n self.holding = False",
"def handle_close(self):\n self.active = False\n self.close()",
"def close(self):\n super(OpenCNTradeContext, self).close()",
"def close(self):\n self._normal_close = True... | [
"0.6352216",
"0.6309689",
"0.62376684",
"0.617212",
"0.6147022",
"0.6096366",
"0.6096366",
"0.6072034",
"0.6071069",
"0.60654074",
"0.6047621",
"0.6024533",
"0.6024533",
"0.60132384",
"0.6009106",
"0.6005265",
"0.6000903",
"0.59958005",
"0.5981424",
"0.5960146",
"0.595187",
... | 0.0 | -1 |
Removes a service from a list of existing services. | def RemoveServiceFromEndpoints(service_name, services):
new_services = []
if not isinstance(services, list):
return new_services
# TODO(user): Consider throwing an exception if the service is not
# already configured in the list of endpoints.
for service in services:
if not isinstance(service, dict) or 'name' not in service:
raise exceptions.ToolException(ValueError(
'Services are expected to be service dicts!'))
if service['name'] != service_name:
new_services.append(service)
return new_services | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def DeleteServices(self):\n for service in self.services.values():\n service.Delete()",
"def delete_service(self, service):\n # type: (LoadBalancerService) -> List[BoundAction]\n return self._client.delete_service(self, service)",
"def remove(self, service):\n os.remove(os.path.joi... | [
"0.7037286",
"0.675924",
"0.6610748",
"0.6590831",
"0.62848717",
"0.6255595",
"0.61463314",
"0.6130574",
"0.611379",
"0.6080032",
"0.6072836",
"0.6069888",
"0.60036",
"0.5951796",
"0.5946897",
"0.59276074",
"0.59024787",
"0.58957607",
"0.58896816",
"0.5826269",
"0.57981753",
... | 0.7142464 | 0 |
Return distance of two keys in qwerty keyboard based on manhattan or euclidean distance. | def key_distance(self, x, y, type="manhattan"):
if type == "manhattan":
return self.manhattan_dist_matrix[self.keys.index(x), self.keys.index(y)]
elif type == "euclidean":
return self.euclidean_dist_matrix[self.keys.index(x), self.keys.index(y)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def distance(self, keyOne, keyTwo):",
"def qwerty_distance():\n from collections import defaultdict\n import math\n R = defaultdict(dict)\n R['-']['-'] = 0\n zones = [\"dfghjk\", \"ertyuislcvbnm\", \"qwazxpo\"]\n keyboard = [\"qwertyuiop\", \"asdfghjkl\", \"zxcvbnm\"]\n for num, content in e... | [
"0.75387555",
"0.69056517",
"0.6859236",
"0.67510206",
"0.6659005",
"0.66116893",
"0.6603836",
"0.65740633",
"0.6566495",
"0.65459806",
"0.6529574",
"0.6490348",
"0.6489842",
"0.64859676",
"0.6471863",
"0.6434619",
"0.6432744",
"0.6414012",
"0.6411454",
"0.63999486",
"0.63896... | 0.71139956 | 1 |
Calculate matrix of number of edits to convert every subset of y to every subset of x | def distance_matrix(self, x, y, keyboard_weight=None):
# create distance matrix
size_x = len(x) + 1
size_y = len(y) + 1
dist_matrix = np.zeros((size_x, size_y))
for i in range(size_x):
dist_matrix[i, 0] = i
for j in range(size_y):
dist_matrix[0, j] = j
## fill distance matrix
# no keyboard weight
if not keyboard_weight:
for i in range(1, size_x):
for j in range(1, size_y):
# if letters are same
if x[i-1] == y[j-1]:
dist_matrix[i, j] = dist_matrix[i-1, j-1]
# if letters are different
else:
subs = dist_matrix[i-1, j-1] + 1
delete = dist_matrix[i-1, j] + 1
insert = dist_matrix[i, j-1] + 1
dist_matrix[i, j] = min(subs, delete, insert)
# manhattan keyboard weight
elif keyboard_weight == "manhattan":
for i in range(1, size_x):
for j in range(1, size_y):
# if letters are same
if x[i-1] == y[j-1]:
dist_matrix[i, j] = dist_matrix[i-1, j-1]
# if letters are different
else:
dist = self.key_distance(x[i-1], y[j-1], keyboard_weight)
subs_weight = dist * self.manhattan_coef
subs = dist_matrix[i-1, j-1] + subs_weight
delete = dist_matrix[i-1, j] + 1
insert = dist_matrix[i, j-1] + 1
dist_matrix[i, j] = min(subs, delete, insert)
# euclidean keyboard weight
elif keyboard_weight == "euclidean":
for i in range(1, size_x):
for j in range(1, size_y):
# if letters are same
if x[i-1] == y[j-1]:
dist_matrix[i, j] = dist_matrix[i-1, j-1]
# if letters are different
else:
dist = self.key_distance(x[i-1], y[j-1], keyboard_weight)
subs_weight = dist * self.euclidean_coef
subs = dist_matrix[i-1, j-1] + subs_weight
delete = dist_matrix[i-1, j] + 1
insert = dist_matrix[i, j-1] + 1
dist_matrix[i, j] = min(subs, delete, insert)
return dist_matrix | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def topsolutions(self):\n answers = []\n for y in xrange(0, self.y):\n answer = self.retrieve(y,self.y)\n i = 0\n for x in xrange(0,y):\n answer -= self.retrieve(y,x)*answers[i]\n i += 1\n answers.append(answer)\n return... | [
"0.5772924",
"0.573736",
"0.57085884",
"0.5653021",
"0.56054556",
"0.54707366",
"0.5380854",
"0.53584445",
"0.5358038",
"0.53385925",
"0.5314144",
"0.5285138",
"0.52835494",
"0.52652776",
"0.52577674",
"0.5253505",
"0.5253083",
"0.524562",
"0.5237841",
"0.52344394",
"0.521122... | 0.0 | -1 |
Calculate number of edits to convert y to x | def distance(self, x, y, keyboard_weight=None):
dist_matrix = self.distance_matrix(x, y, keyboard_weight)
return dist_matrix[-1, -1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_num_applies(self):\n ops = 0\n for _, remainder, _ in self:\n ops += len(remainder)\n return ops",
"def countNeighbors(oldgen, x, y):\n temp = 1\n\n count = 0\n for i in range(-1, 2):\n for j in range(-1, 2):\n\n # TODO: this needs rewritin to be... | [
"0.6166617",
"0.591628",
"0.58021086",
"0.57318366",
"0.5673574",
"0.5647557",
"0.5594943",
"0.5514994",
"0.550421",
"0.5470522",
"0.54313797",
"0.54289174",
"0.542215",
"0.53802377",
"0.5366139",
"0.5360295",
"0.53558695",
"0.53518134",
"0.5347793",
"0.53407663",
"0.5332358"... | 0.0 | -1 |
Return a dataframe of distance matrix of x and y. Indexes are letters of x and columns are letters of y. | def distance_dataframe(self, x, y, keyboard_weight=None):
dist_matrix = self.distance_matrix(x, y, keyboard_weight)
dist_df = pd.DataFrame(dist_matrix, index=["", *list(x)],
columns=["", *list(y)])
return dist_df | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_dist_matrix(self):\n\n self.dist_matrix = spatial.distance.squareform(spatial.distance.pdist(self.data_vector,metric=\"hamming\"))\n\n self.dist_frame = pd.DataFrame(self.dist_matrix,\n index = self.seq_strings,\n co... | [
"0.69271284",
"0.67564255",
"0.6533258",
"0.6516786",
"0.6428106",
"0.63869244",
"0.6351963",
"0.6319464",
"0.63100487",
"0.62420344",
"0.62378067",
"0.62373847",
"0.62171084",
"0.62104243",
"0.62080455",
"0.6201593",
"0.61032706",
"0.6101561",
"0.60353494",
"0.6023481",
"0.5... | 0.8356927 | 0 |
Calculate similarity of two words Return a number between 0 and 1 (1 means same and 0 means fully different) | def similarity(self, x, y, keyboard_weight=None):
dist = self.distance(x, y, keyboard_weight)
max_len = max(len(x), len(y))
max_dissimilarity = max_len * self.scale_coef
similarity = 1 - dist / max_dissimilarity
return similarity | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wordSimilarityRatio(sent_1,sent_2):",
"def similarity(a, b):\n distance = Levenshtein.distance(a, b)\n return 1 - (distance / max((len(a), len(b))))",
"def similar_text(word1, word2) -> float:\n\n return textdistance.overlap.similarity(word1, word2)",
"def text_similarity(self, text_1: str, text... | [
"0.84911114",
"0.8240029",
"0.8203488",
"0.80538607",
"0.7916579",
"0.78859663",
"0.78573513",
"0.78237593",
"0.78181165",
"0.7802038",
"0.7788888",
"0.77773386",
"0.7673199",
"0.76593477",
"0.760347",
"0.7594198",
"0.7564784",
"0.7561484",
"0.7549728",
"0.7532246",
"0.750004... | 0.71260786 | 44 |
Updates this Role instance | def update(self, permission, **kwargs):
kwargs['permission'] = permission
return self.update_instance(**kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, role):\n model = models.load('Role', role)\n model.account_id = self.account_id\n\n return self.client.update_role(model)",
"def update(self, role):\n self._router_request(\n self._make_request_data(\n 'updateAdminRole',\n data... | [
"0.75100726",
"0.73120785",
"0.6926027",
"0.6725893",
"0.6725881",
"0.66784096",
"0.6674918",
"0.6656022",
"0.65352",
"0.6417849",
"0.64106894",
"0.62678677",
"0.62678677",
"0.6230835",
"0.6226089",
"0.6220385",
"0.6199606",
"0.6199606",
"0.6199606",
"0.6171208",
"0.6162495",... | 0.53856415 | 93 |
Delete a given Role | def delete(self, sid):
return self.delete_instance(sid) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_role(role):\n fallback = Role.load_cli_user()\n\n def _del(cls, col):\n pq = db.session.query(cls)\n pq = pq.filter(col == role.id)\n\n def _repo(cls, col):\n pq = db.session.query(cls).filter(col == role.id)\n pq.update({col: fallback.id}, synchronize_session=False)... | [
"0.82603055",
"0.8098692",
"0.80856603",
"0.80064636",
"0.79942334",
"0.79914016",
"0.791367",
"0.7900632",
"0.78198117",
"0.779961",
"0.778778",
"0.7761136",
"0.77352875",
"0.76953554",
"0.76781493",
"0.76682544",
"0.76425016",
"0.7444573",
"0.7420755",
"0.7399109",
"0.73983... | 0.0 | -1 |
Updates the Role instance identified by sid | def update(self, sid, permission, **kwargs):
kwargs['permission'] = permission
return self.update_instance(sid, kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, role):\n model = models.load('Role', role)\n model.account_id = self.account_id\n\n return self.client.update_role(model)",
"def update_role(self, role_id, role):\n raise exception.NotImplemented() # pragma: no cover",
"def updateRole(self, role_id, title, descript... | [
"0.6914042",
"0.68597794",
"0.6641208",
"0.6528812",
"0.6419764",
"0.6366573",
"0.6216717",
"0.620263",
"0.61314535",
"0.60046023",
"0.59110934",
"0.5883643",
"0.58780575",
"0.5868561",
"0.58423275",
"0.57909155",
"0.5775993",
"0.5757083",
"0.5700232",
"0.5646141",
"0.5625624... | 0.6374615 | 5 |
Returns the token and dsn from a key Generate a simple SHA1 hash of the key key is a 64bits integer Token is a 32bits integer, dsn is a 64bits integer | def key2tokenAndDSN(self, key):
import binascii
import struct
import hashlib
self.keystr = struct.pack("!Q", key)
self.h = hashlib.sha1(self.keystr.rjust(8,'\00'))
self.shastr=self.h.digest() # binary
#shastr = struct.pack("!IIIII", *struct.unpack("@IIIII",shastr)) #to net
self.token, self.dsn = self.shastr[0:4], self.shastr[-8:]
#print "raw: %s (len=%i)"%(shastr,len(shastr))
#print "hex: %s"% binascii.hexlify(token), "%s"%binascii.hexlify(dsn)
self.d1, self.d2 = struct.unpack("!II",self.dsn)
self.token, self.dsn = (struct.unpack("!I",self.token)[0], (long(self.d2)<<32)+self.d1)
#print "token: %x"% token
#print "dsn: %x" % dsn
return (self.token, self.dsn) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fnv1(self, key):\n # hash = 0xff\n hash = 0xcbf29ce484222325\n for n in key.encode():\n # print(n)\n hash = hash ^ n\n hash = hash * 0x100000001b3\n\n # print(hash)\n return hash",
"def _hash(self, key):\n\n return long(hashlib.md5(ke... | [
"0.59551054",
"0.59115833",
"0.59115833",
"0.58881515",
"0.5808499",
"0.5731819",
"0.5719893",
"0.57018846",
"0.569349",
"0.5679318",
"0.5663129",
"0.5659303",
"0.561188",
"0.5586423",
"0.5538995",
"0.55299336",
"0.54740316",
"0.5471576",
"0.5457066",
"0.5430525",
"0.54092103... | 0.8006403 | 0 |
Identify distinct MPTCP Connections that reached Successful handshake Look for Ack packets with MPTCP option Header For each MPTCP connection report Receiver's token value which acts as the connectionID | def mptcp_connections(self, pkts):
count = 0
#MPTCP_Capable = 0x0
#MPTCP_CapableACK ---> successful handshake
print "======================================================================"
print "Successful Handshake --- Look for Ack packets with MPTCP option Header"
print """Token = connectionID = SHA1(key)[0-32] of Other party's key. (Capture from
either step 2 or 3 in the first handshake)"""
print "Total packets: %s" % len(pkts)
print "======================================================================"
print "Identifying MPTCP Connections...."
for i in range(len(pkts)):
if(MPTCP_CapableACK in pkts[i] and pkts[i][TCPOption_MP].mptcp.subtype == 0):
count +=1 #Count the number of distinct MPTCP connections
#Compute the receiver's token
self.key_rcv = pkts[i][TCPOption_MP].mptcp.rcv_key
self.rcv_token, self.rcv_dsn = self.key2tokenAndDSN(self.key_rcv)
#Compute the sender's token
self.key_snd = pkts[i][TCPOption_MP].mptcp.snd_key
self.snd_token, self.snd_dsn = self.key2tokenAndDSN(self.key_snd)
print ("%i. New MPTCP Connection (Successful Handshake) src: %s; dest: %s; Sender's key: %s; Receiver's key: %s; Receivers Token (connectionID): %s; Sender's Token: %s" % (count, pkts[i][IP].src, pkts[i][IP].dst, pkts[i][TCPOption_MP].mptcp.snd_key, pkts[i][TCPOption_MP].mptcp.rcv_key, self.rcv_token, self.snd_token))
print "Total MPTCP Connections: %i" % count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_mptcp_pkt_from_client(ts_delta, acks, conn_acks, mptcp_connections, tcp, ip, saddr, daddr, sport, dport):\n dss, dack, dss_is_8_bytes = get_dss_and_data_ack(tcp)\n conn_id = acks[saddr, sport, daddr, dport][co.CONN_ID]\n flow_id = acks[saddr, sport, daddr, dport][co.FLOW_ID]\n if conn_acks[... | [
"0.5511609",
"0.5456236",
"0.5397558",
"0.53674424",
"0.5341668",
"0.5300616",
"0.52610534",
"0.5249031",
"0.5168756",
"0.5108904",
"0.5044106",
"0.5025528",
"0.50196034",
"0.49723715",
"0.4895106",
"0.48823294",
"0.4870531",
"0.48611027",
"0.4818591",
"0.4818538",
"0.4802288... | 0.7726427 | 0 |
Report the number of payload bytes cumulatively exchanged over each MPTCP connection | def payload_data(self, pkts):
#Get all the payload bytes exchanged over MPTCP connections
payload_bytes = 0
print "Determining the number of payload bytes excluding headers...."
#DSS = 0x2
for i in range(len(pkts)):
if(TCPOption_MP in pkts[i] and pkts[i][TCPOption_MP].mptcp.subtype == 2 and Raw in pkts[i]):
payload_bytes += len(pkts[i][Raw].load)
#print("DSN: %s; subflow_seqnum: %s; Data(bytes): %s" % (pkts[i][TCPOption_MP].mptcp.dsn, pkts[i][TCPOption_MP].mptcp.subflow_seqnum, len(pkts[i][Raw].load)))
print "Total Number of payload bytes in the file (entire MPTCP connections) excluding headers): %s" % (payload_bytes)
#MPTCP WITH SUBFLOW CONNECTIONS
#MPTCP_JOINs = 0x1
print "============================================================"
print "SUBFLOW Connections with their respective MPTCP connection (identified by connectionID)"
for i in range(len(pkts)):
#Initial Join Message
#rcv_token Identifies the connection to which the subflow belongs: connectionID
if(MPTCP_JoinSYN in pkts[i] and pkts[i][TCPOption_MP].mptcp.subtype == 1):
print("New subflow: connectionID: %s; src: %s; dest: %s; snd_nonce: %s" % (pkts[i][TCPOption_MP].mptcp.rcv_token, pkts[i][IP].src, pkts[i][IP].dst, pkts[i][TCPOption_MP].mptcp.snd_nonce))
#TODO: Now Need to track per-connection and per-subflow state | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def BytesTransferred(self) -> int:",
"def SendPacketsSendSize(self) -> int:",
"def delta_bytes(self):\n return sum(self.fcip_doc['packet_lengths'])",
"def getPacketCount(self):\n return 1",
"def mptcp_connections(self, pkts):\n\t\tcount = 0\n\t\t#MPTCP_Capable = 0x0\n\t\t#MPTCP_CapableACK ---... | [
"0.66460896",
"0.64858186",
"0.6429485",
"0.63838947",
"0.6298005",
"0.6263551",
"0.60947376",
"0.6089673",
"0.6043087",
"0.6028377",
"0.6015029",
"0.5988581",
"0.5972827",
"0.590944",
"0.5890168",
"0.5861066",
"0.5850881",
"0.5805821",
"0.5804993",
"0.5774528",
"0.5753648",
... | 0.64004153 | 3 |
Adds an input value to the averaging filter. | def Input(self, value):
print("Input: {}".format(value))
# Add the new value to the filter values.
self.Values.append(value)
# If the filter has reached its maximum Depth,
# pop the last item from the filter values.
if len(self.Values) > self.Depth:
s = 0
self.Values.pop(s)
print("Filter ({}): {}".format(len(self.Values), self.Values)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_value(self, value):\n if (value - self.avg) ** 2 > \\\n self.deviation_scale * (self.std + self.deviation_offset):\n BaseFilter.add_value(self, self.avg)\n else:\n BaseFilter.add_value(self, value)",
"def add_value(self, value):\n if len(self.hist... | [
"0.74540794",
"0.71780056",
"0.6814798",
"0.6716383",
"0.6649134",
"0.63110775",
"0.6276187",
"0.6150249",
"0.6108856",
"0.6071165",
"0.60466886",
"0.60204285",
"0.6016385",
"0.5957288",
"0.5926967",
"0.59223187",
"0.5921518",
"0.591883",
"0.5895319",
"0.57737994",
"0.5753940... | 0.6106456 | 9 |
Calculates the average of the current filter values. | def Output(self):
filter_sum = 0
# Calculate the sum of all filter values.
for s in self.Values:
filter_sum += s
print("Sum: {}".format(filter_sum))
# The average is the sum divided by the current amount of
# samples.
avg = filter_sum / len(self.Values)
print("Average: {}".format(avg))
if self.Round is True:
# Round the average to the nearest integer.
avg = round(avg)
print("Output: {}".format(avg))
return avg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def average(self):\n return self.summation() / self.count()",
"def average(self):\n return (self.current + self.last) / 2.0",
"def average(self):\n s = self.sum()\n flat_shape = self.flatten_shape(self.shape)\n num_of_elements = fct.reduce(opr.mul, flat_shape, 1)\n ave... | [
"0.75439095",
"0.73029804",
"0.7202501",
"0.7086935",
"0.7005572",
"0.6967038",
"0.6947147",
"0.6872095",
"0.68588364",
"0.6849239",
"0.6839921",
"0.6821161",
"0.6814509",
"0.6814509",
"0.6768326",
"0.6744722",
"0.6728115",
"0.67118907",
"0.6687017",
"0.6667109",
"0.66239166"... | 0.7149273 | 3 |
Resets the filter values. | def Reset(self):
n = len(self.Values)
for i in range(0, n):
self.Values.pop(i) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset_filter(self):\n arlen = len(self.variant_list)\n self.filter = np.zeros((arlen, arlen)) == 0",
"def reset_filters():\n logger.info(\"reset filters\")\n global filter_item\n filter_item = -1\n filter_topics_table.view.filters = [IndexFilter()]\n filter_custom_table.view.filt... | [
"0.7977834",
"0.7429131",
"0.74247444",
"0.7300497",
"0.7222309",
"0.72031015",
"0.7117929",
"0.7102414",
"0.7066342",
"0.70600677",
"0.6972775",
"0.68997204",
"0.68905616",
"0.68335426",
"0.6815627",
"0.6741218",
"0.66964805",
"0.66880286",
"0.66741985",
"0.66408324",
"0.662... | 0.64528835 | 43 |
return the current schema_org schema version | def get_schema_org_version():
return _get_schemaorg_version() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_schemaorg_version():\n try:\n version = get_latest_schemaorg_version()\n except ValueError:\n version = SCHEMAORG_DEFAULT_VERSION\n return version",
"def schema_version(self):\n # return self._parsed[\"schemaVersion\"]\n # does not exist in manifest reference\n ... | [
"0.84921485",
"0.82677555",
"0.8089187",
"0.7736187",
"0.74551374",
"0.7435045",
"0.73047084",
"0.6960835",
"0.68983686",
"0.68766624",
"0.68467546",
"0.68244046",
"0.6751349",
"0.67256296",
"0.6715355",
"0.6658414",
"0.6645252",
"0.6636151",
"0.6614081",
"0.66119516",
"0.658... | 0.89709204 | 0 |
Return a list of schema namespaces registered in DDE | def registered_dde_schemas(self):
return [s["_id"] for s in schemas.get_all(size=100)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def registered_dde_schemas(self):\n url = DDE_SCHEMA_BASE_URL + \"?field=_id&size=20\"\n if self.verbose:\n print(f'Loading registered DDE schema list from \"{url}\"')\n data = load_json_or_yaml(url)\n return [s[\"namespace\"] for s in data[\"hits\"]]",
"def namespaces(self... | [
"0.82582337",
"0.8003308",
"0.7945194",
"0.77889043",
"0.74570817",
"0.7238755",
"0.7172259",
"0.71680105",
"0.7109484",
"0.70704514",
"0.70290285",
"0.7007423",
"0.68698627",
"0.6844944",
"0.6776967",
"0.6739239",
"0.6705429",
"0.6666555",
"0.65324306",
"0.6531712",
"0.65198... | 0.7246093 | 5 |
Load a registered schema | def load_dde_schemas(self, schema):
if self.verbose:
print(f'Loading registered DDE schema "{schema}"')
schema_source = schemas.get(schema)
schema_source.pop("_id")
return schema_source | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_validator_schema():\n logger.info('Loading validator schemas')\n SchemaLoader.load_all_from_path(validator_config_path)",
"def load_schema(schema_path):\n with open(schema_path) as schema_file:\n return Utils.parse(schema_file.read())",
"def schema_load(filename):\n print(uc... | [
"0.71533245",
"0.7038362",
"0.70110863",
"0.6746675",
"0.6709357",
"0.6656535",
"0.6612241",
"0.66008633",
"0.65909773",
"0.65366113",
"0.64810675",
"0.6431707",
"0.6424626",
"0.64035326",
"0.63424355",
"0.63148296",
"0.63040596",
"0.62571245",
"0.6245016",
"0.62211007",
"0.6... | 0.6969959 | 3 |
get only classes defined in this schema | def get_class_defs(self):
return list(self._get_class_defs().values()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_all_classes(self):\n classes = list(self.extended_class_only_graph.nodes())\n classes = [SchemaClass(_cls, self) for _cls in classes]\n return classes",
"def get_classes(self):\n return",
"def return_classes(self):\n\n\t\t \n\t\t \n\t\treturn self.classes",
"def get_c... | [
"0.78731024",
"0.71519256",
"0.7128944",
"0.7102175",
"0.7069883",
"0.6910617",
"0.67119366",
"0.66961735",
"0.6668723",
"0.6640557",
"0.66171163",
"0.6541783",
"0.6539696",
"0.65327054",
"0.65109813",
"0.64602256",
"0.6432275",
"0.64070165",
"0.63955426",
"0.6380493",
"0.637... | 0.65426725 | 11 |
get only classes referenced outside this schema | def get_class_refs(self):
return list(self._get_class_refs().values()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_all_classes(self):\n classes = list(self.extended_class_only_graph.nodes())\n classes = [SchemaClass(_cls, self) for _cls in classes]\n return classes",
"def parent_classes(self):\n response = check_defined(self, inspect.stack()[0][3])\n if not response:\n r... | [
"0.6365546",
"0.62089795",
"0.6205446",
"0.6171531",
"0.60406595",
"0.59149647",
"0.5896615",
"0.58919096",
"0.5831818",
"0.57982343",
"0.5780626",
"0.5756438",
"0.57559365",
"0.5708741",
"0.5698709",
"0.5691668",
"0.5679516",
"0.56510174",
"0.56453377",
"0.5609935",
"0.55802... | 0.6016841 | 5 |
get all classes and label them if they are referenced if include_ref is False, only "defined" classes are included. | def get_classes(self, include_ref=True):
defs = self._get_class_defs()
ans = {}
ans.update(defs)
if include_ref:
refs = self._get_class_refs()
ans.update(refs)
return list(ans.values()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_class_refs(self):\n return list(self._get_class_refs().values())",
"def process_class_list(self, module, classes):",
"def _load_classes(self):\n classdocs = self._docset.get_classes()\n for classdoc in classdocs:\n files = [self._docmap[filedoc] for filedoc in classdoc.g... | [
"0.6035254",
"0.58814853",
"0.5880051",
"0.5856091",
"0.57512456",
"0.5681698",
"0.5672593",
"0.5591788",
"0.5589396",
"0.55738693",
"0.55246097",
"0.55189526",
"0.5512281",
"0.5482113",
"0.54583037",
"0.5448857",
"0.54194885",
"0.5409159",
"0.53911316",
"0.5388025",
"0.53866... | 0.7381208 | 0 |
return True if there is at least one validation error. | def has_validation_error(self):
for err in self._schema.validator.validation_errors:
if not err.warning:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isValid(self):\n errorList = self.getErrors()\n\n return not errorList",
"def is_valid(self):\n return not self.errors",
"def is_valid(self):\n self.clean()\n return not bool(self.errors)",
"def has_errors(self):\n return len(self.get_errors()) > 0",
"def has_e... | [
"0.79174244",
"0.7894807",
"0.7860656",
"0.7844026",
"0.78179806",
"0.78001493",
"0.77460116",
"0.76075137",
"0.7494825",
"0.7405556",
"0.7374498",
"0.73029155",
"0.7184244",
"0.714132",
"0.7135738",
"0.7081772",
"0.7046217",
"0.7024928",
"0.69485885",
"0.6942181",
"0.6913216... | 0.78778917 | 2 |
return validation errors as a list of dictionaries | def get_validation_errors(self):
return [err.to_dict() for err in self._schema.validator.validation_errors] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def error_wrapper(x):\n errors = list()\n for error_key, error_list in list(x.items()):\n for error in error_list:\n if error_key == 'non_field_errors':\n errors.append(error)\n else:\n errors.append(\"%s: %s\" % (error_key, error))\n return error... | [
"0.7443273",
"0.7419965",
"0.7331665",
"0.7269884",
"0.7269884",
"0.7269884",
"0.7269884",
"0.7269884",
"0.72689366",
"0.72655326",
"0.7202294",
"0.7177334",
"0.7172576",
"0.7163961",
"0.7127716",
"0.6941691",
"0.6911603",
"0.6893204",
"0.6834352",
"0.6751597",
"0.6711623",
... | 0.84701467 | 0 |
Faster Wavelenght selector If passed lists it will return lists. If passed np arrays it will return arrays Fastest is using np.ndarrays fast_wav_selector ~10002000 quicker than wav_selector | def fast_wav_selector(wav, flux, wav_min, wav_max):
if isinstance(wav, list): # if passed lists
wav_sel = [value for value in wav if(wav_min < value < wav_max)]
flux_sel = [value[1] for value in zip(wav,flux) if(wav_min < value[0] < wav_max)]
elif isinstance(wav, np.ndarray):
# Super Fast masking with numpy
mask = (wav > wav_min) & (wav < wav_max)
wav_sel = wav[mask]
flux_sel = flux[mask]
else:
raise TypeError("Unsupported input wav type")
return [wav_sel, flux_sel] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wav_selector(wav, flux, wav_min, wav_max, verbose=False):\n if isinstance(wav, list): # if passed lists\n wav_sel = [wav_val for wav_val in wav if (wav_min < wav_val < wav_max)]\n flux_sel = [flux_val for wav_val, flux_val in zip(wav,flux) if (wav_min < wav_val < wav_max)]\n elif isinst... | [
"0.7074208",
"0.54926926",
"0.543694",
"0.5338126",
"0.5282017",
"0.5270855",
"0.51453614",
"0.5138771",
"0.5112849",
"0.5108346",
"0.5105792",
"0.5059946",
"0.5033493",
"0.5002626",
"0.49823514",
"0.49728918",
"0.4955809",
"0.4946704",
"0.49403378",
"0.49394882",
"0.48933354... | 0.70528 | 1 |
Gaussian_function of area=1 p[0] = A; p[1] = mean; p[2] = FWHM; | def unitary_Gauss(x, center, FWHM):
sigma = np.abs(FWHM) /( 2 * np.sqrt(2 * np.log(2)) );
Amp = 1.0 / (sigma*np.sqrt(2*np.pi))
tau = -((x - center)**2) / (2*(sigma**2))
result = Amp * np.exp( tau );
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gaussian(amp, fwhm, mean):\n return lambda x: amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)",
"def gaussian(amp, fwhm, mean, x):\n return amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)",
"def Gaussian(x, mu=0, sigma=26.4, A=1, y0=0):\r\n #width = sigma*(2*np.sqrt(2*np.log(2)))\r\n ... | [
"0.7608028",
"0.75165457",
"0.6953791",
"0.69522965",
"0.6922625",
"0.6717248",
"0.6687247",
"0.6661979",
"0.66529137",
"0.66487074",
"0.6572644",
"0.65556943",
"0.65399146",
"0.6530924",
"0.6530924",
"0.6530924",
"0.6530346",
"0.6524894",
"0.65182394",
"0.64871186",
"0.64804... | 0.59211177 | 70 |
IP convolution multiplication step for a single wavelength value | def fast_convolve(wav_val, R, wav_extended, flux_extended, FWHM_lim):
FWHM = wav_val/R
index_mask = (wav_extended > (wav_val - FWHM_lim*FWHM)) & (wav_extended < (wav_val + FWHM_lim*FWHM))
flux_2convolve = flux_extended[index_mask]
IP = unitary_Gauss(wav_extended[index_mask], wav_val, FWHM)
sum_val = np.sum(IP*flux_2convolve)
unitary_val = np.sum(IP*np.ones_like(flux_2convolve)) # Effect of convolution onUnitary. For changing number of points
return sum_val/unitary_val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, x):\n if self.signal_length is None:\n self.signal_length = x.shape[-1]\n self.channels = x.shape[-2]\n self._scales = self.compute_optimal_scales()\n self._kernel = self._build_wavelet_bank()\n\n if self._kernel.is_complex():\n ... | [
"0.6042097",
"0.5845206",
"0.5728535",
"0.57079965",
"0.5538608",
"0.5477923",
"0.54210114",
"0.5398492",
"0.53849536",
"0.5383139",
"0.5380405",
"0.5379147",
"0.5379049",
"0.5376933",
"0.53721017",
"0.535263",
"0.5341408",
"0.53101605",
"0.5305929",
"0.5297572",
"0.5297235",... | 0.0 | -1 |
Convolution code adapted from pedros code and speed up with np mask logic | def convolution_nir(wav, flux, chip, R, FWHM_lim=5.0, plot=True):
wav_chip, flux_chip = chip_selector(wav, flux, chip)
#we need to calculate the FWHM at this value in order to set the starting point for the convolution
FWHM_min = wav_chip[0]/R #FWHM at the extremes of vector
FWHM_max = wav_chip[-1]/R
#wide wavelength bin for the resolution_convolution
wav_extended, flux_extended = fast_wav_selector(wav, flux, wav_chip[0]-FWHM_lim*FWHM_min, wav_chip[-1]+FWHM_lim*FWHM_max)
print("wav_extended type", type(wav_extended))
wav_extended = np.array(wav_extended, dtype="float64")
print("wav_extended type after arrayed", type(wav_extended)) # should be the same.
flux_extended = np.array(flux_extended, dtype="float64")
print("Starting the Resolution convolution...")
# Predefine np array space
flux_conv_res = np.empty_like(wav_chip, dtype="float64")
counter = 0
base_val = len(wav_chip)//20 # Adjust here to change % between reports
for n, wav in enumerate(wav_chip):
# put value directly into the array
flux_conv_res[n] = fast_convolve(wav, R, wav_extended, flux_extended, FWHM_lim)
if(n%base_val== 0):
counter = counter+5
print("Resolution Convolution at {}%%...".format(counter))
print("flux conv res type after loop", type(flux_conv_res))
flux_conv_res = np.array(flux_conv_res, dtype="float64")
print("flux conv res type after np.array", type(flux_conv_res))
print("Done.\n")
if(plot):
fig=plt.figure(1)
plt.xlabel(r"wavelength [ $\mu$m ])")
plt.ylabel(r"flux [counts] ")
plt.plot(wav_chip, flux_chip/np.max(flux_chip), color ='k', linestyle="-", label="Original spectra")
plt.plot(wav_chip, flux_conv_res/np.max(flux_conv_res), color ='b', linestyle="-", label="Spectrum observed at and R=%d ." % (R))
plt.legend(loc='best')
plt.show()
return wav_chip, flux_conv_res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clConvolution(self, size, mask):",
"def compute(self, node, input_vals):\r\n #assert len(input_vals) == 2\r\n #start = time.time()\r\n strides = node.const_attr\r\n ish = list(input_vals[0].shape)\r\n fsh = list(input_vals[1].shape)\r\n filter = input_vals[1].astype(... | [
"0.85066",
"0.7019092",
"0.68060744",
"0.6763622",
"0.6690711",
"0.6668837",
"0.6661964",
"0.6645885",
"0.65938205",
"0.6570192",
"0.65078753",
"0.6501851",
"0.6485171",
"0.6481288",
"0.64750814",
"0.64741033",
"0.64626104",
"0.64103127",
"0.63968295",
"0.63761157",
"0.635630... | 0.0 | -1 |
Interpolate Wavelengths of spectra to common WL Most likely convert telluric to observed spectra wl after wl mapping performed | def match_wl(wl, spec, ref_wl, method="scipy", kind="linear"):
starttime = time.time()
if method == "scipy":
#print(kind + " scipy interpolation")
linear_interp = interp1d(wl, spec, kind=kind)
new_spec = linear_interp(ref_wl)
elif method == "numpy":
if kind.lower() is not "linear":
print("Warning: Cannot do " + kind + " interpolation with numpy, switching to linear" )
#print("Linear numpy interpolation")
new_spec = np.interp(ref_wl, wl, spec) # 1-d peicewise linear interpolat
else:
print("Method was given as " + method)
raise("Not correct interpolation method specified")
#print("Interpolation Time = " + str(time.time() - starttime) + " seconds")
return new_spec # test inperpolations | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_spectral_bandpass_interpol(interpol_wavelen, interpol_rad, center_wvl,\n save_dir):\n\n save_dir = os.path.join(save_dir, r'look_up_table')\n if not os.path.exists(save_dir):\n os.makedirs(save_dir)\n\n\n center_wvl1 = np.arange(min(center_wvl), max(c... | [
"0.6577591",
"0.6556523",
"0.6496855",
"0.64009374",
"0.6335774",
"0.62576574",
"0.6154168",
"0.60373366",
"0.5991376",
"0.5960921",
"0.59510165",
"0.5908147",
"0.5871862",
"0.58661956",
"0.58438027",
"0.5817838",
"0.5814624",
"0.5808811",
"0.58038354",
"0.5801125",
"0.579968... | 0.59196925 | 11 |
Takes two files in a list as input eg. data = [path1,path2] | def _input_as_string(self,data):
inputFiles = ' '.join(data)
self._input_filename = data
return inputFiles | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_content(file1, file2):\n with open(file1, 'r') as f1, open(file2, 'r') as f2:\n return [line for line in f1], [line for line in f2]",
"def load_files_to_compare(self):\n self.first_source_data = load_path(self.path1)\n self.second_source_data = load_path(self.path2)",
"def load_... | [
"0.6610108",
"0.6356825",
"0.635545",
"0.6338313",
"0.62560904",
"0.61758494",
"0.6088548",
"0.6032201",
"0.598844",
"0.5927247",
"0.58987236",
"0.5861115",
"0.5815601",
"0.5770374",
"0.57467705",
"0.57203543",
"0.57123935",
"0.57011217",
"0.56484956",
"0.56306076",
"0.560777... | 0.0 | -1 |
Writes to first sequences(fasta) in a list to two temp files | def _input_as_lines(self,data):
inputFiles = ''
self._input_filename = []
for i in range(2):
filename = self.getTmpFilename(self.WorkingDir)
self._input_filename.append(filename)
data_file = open(filename,'w')
if i == 0:
data_to_file = '\n'.join(data[:2])
tmp1 = filename
else:
data_to_file = '\n'.join(data[2:])
tmp2 = filename
data_file.write(data_to_file)
data_file.close()
inputFiles = ' '.join([tmp1,tmp2])
return inputFiles | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def combine_fasta_files(fastas_paths, out_file):\n with open(out_file, 'w') as out:\n for filename in fastas_paths:\n for seq_record in SeqIO.parse(filename, \"fasta\"):\n out.write('>' + str(seq_record.id) + '\\n' + str(seq_record.seq) + '\\n')",
"def test_write_seqs_to_fasta... | [
"0.7115534",
"0.6977876",
"0.6929793",
"0.66960967",
"0.66449195",
"0.6635358",
"0.6599218",
"0.6559618",
"0.6408864",
"0.6341006",
"0.6326734",
"0.6306929",
"0.629032",
"0.62058866",
"0.6190285",
"0.612359",
"0.611101",
"0.6104494",
"0.60735565",
"0.6060679",
"0.60134447",
... | 0.0 | -1 |
Run the application with the specified kwargs on data | def __call__(self,data=None, remove_tmp=True):
input_handler = self.InputHandler
suppress_stdout = self.SuppressStdout
suppress_stderr = self.SuppressStderr
if suppress_stdout:
outfile = FilePath('/dev/null')
else:
outfile = self.getTmpFilename(self.TmpDir)
if suppress_stderr:
errfile = FilePath('/dev/null')
else:
errfile = FilePath(self.getTmpFilename(self.TmpDir))
if data is None:
input_arg = ''
else:
input_arg = getattr(self,input_handler)(data)
# Build up the command, consisting of a BaseCommand followed by
# input and output (file) specifications
command = self._command_delimiter.join(filter(None,\
[self.BaseCommand,str(input_arg),'>',str(outfile),'2>',\
str(errfile)]))
if self.HaltExec:
raise AssertionError, "Halted exec with command:\n" + command
# The return value of system is a 16-bit number containing the signal
# number that killed the process, and then the exit status.
# We only want to keep the exit status so do a right bitwise shift to
# get rid of the signal number byte
tmp_dir = ''.join([self.WorkingDir, 'tmp'])
mkdir(tmp_dir)
exit_status = system(command) >> 8
rmdir(tmp_dir)
# Determine if error should be raised due to exit status of
# appliciation
if not self._accept_exit_status(exit_status):
raise ApplicationError, \
'Unacceptable application exit status: %s, command: %s'\
% (str(exit_status),command)
# open the stdout and stderr if not being suppressed
out = None
if not suppress_stdout:
out = open(outfile,"r")
err = None
if not suppress_stderr:
err = open(errfile,"r")
result = CommandLineAppResult(out,err,exit_status,\
result_paths=self._get_result_paths(data))
# Clean up the input file if one was created
if remove_tmp:
if self._input_filename:
for f in self._input_filename:
remove(f)
self._input_filename = None
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self, **kwargs):\n app = self.create_app()\n\n app.run(host=self.host, port=self.port, **kwargs)",
"def run(self, **kwargs):",
"def run(self, **kwargs):\n pass",
"def run(self, *args, **kwargs):\n pass",
"def run(self, args, **kwargs):\n raise NotImplementedError(... | [
"0.6900019",
"0.6881134",
"0.68657255",
"0.68310666",
"0.6701029",
"0.66893464",
"0.65126204",
"0.64587903",
"0.64343816",
"0.64343816",
"0.6430925",
"0.64042205",
"0.6383089",
"0.6359522",
"0.63256764",
"0.6306275",
"0.62514395",
"0.62414396",
"0.61845434",
"0.6160434",
"0.6... | 0.0 | -1 |
Retry calling the decorated function using an exponential backoff. | def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):
def deco_retry(f):
@wraps(f)
def f_retry(*args, **kwargs):
mtries, mdelay = tries, delay
while mtries > 1:
try:
return f(*args, **kwargs)
except ExceptionToCheck, e:
msg = "%s, Retrying in %d seconds..." % (str(e), mdelay)
if logger:
logger.warning(msg)
else:
print msg
time.sleep(mdelay)
mtries -= 1
mdelay *= backoff
return f(*args, **kwargs)
return f_retry # true decorator
return deco_retry | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def retry(tries, delay=3, backoff=2, except_on=(Exception, )):\n\n tries = math.floor(tries)\n\n def decorator(f):\n def f_retry(*args, **kwargs):\n return function_retry(\n tries, delay, backoff, except_on, f, *args, **kwargs)\n return f_retry # true decorator -> dec... | [
"0.78631854",
"0.7701622",
"0.7667836",
"0.7597426",
"0.7546011",
"0.75036615",
"0.7499006",
"0.74785614",
"0.7439682",
"0.74343145",
"0.7429641",
"0.74183977",
"0.7401052",
"0.73962057",
"0.7395584",
"0.73916775",
"0.7338477",
"0.7319612",
"0.7313288",
"0.7284679",
"0.716480... | 0.6932827 | 36 |
Downloads a FASTA file for the proteome by organism ID | def get_fasta_by_id(proteome_id, output_file):
taxid_pattern = re.compile('^\d{1,7}$')
# if not taxid_pattern.match(proteome_id): # fetch file from Uniprot
# raise ValueError(str(proteome_id) + ' is not a valid proteome identifier')
url = UNIPROT_BASE_URL + proteome_id
attempts = 0
while attempts < 3:
try:
response = requests.get(url)
if response.status_code > 399 or response.status_code < 200:
raise requests.HTTPError(response.status_code + ': ' + response.content)
content = response.content
if len(content) < 10:
raise FastaNotFoundError()
with open(output_file, 'w') as f:
f.write(content)
break
except requests.HTTPError as e:
attempts += 1
if attempts >= 3:
raise FastaNotFoundError('Failed to download fasta: ' + response.status_code + ' response.content')
return output_file | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def seq_download(name, organism=\"Homo sapiens\", gaba=False):\n\n subunits = {\n \"Alpha-1\": \"Gabra1\",\n \"Alpha-2\": \"Gabra2\",\n \"Alpha-3\": \"Gabra3\",\n \"Alpha-4\": \"Gabra4\",\n \"Alpha-5\": \"Gabra5\",\n \"Alpha-6\": \"Gabra6\",\n \"Beta-1\": \"Gabrb... | [
"0.72803736",
"0.64713925",
"0.622999",
"0.6218201",
"0.6060453",
"0.59448034",
"0.57914644",
"0.5711981",
"0.5588932",
"0.5571663",
"0.556189",
"0.5560884",
"0.55341786",
"0.553164",
"0.55225044",
"0.5511088",
"0.5500932",
"0.54671043",
"0.54671043",
"0.54506993",
"0.5367374... | 0.71304876 | 1 |
A function for generating reaction likelihoods for a given genome according to the Probabilistic Annotation algorithm as | def generate_reaction_probabilities(fasta_file, template_model_file, genome_id=None):
if genome_id is None:
# Use fasta_file name minus extension. worker uses only for file names and logging
genome_id = '.'.join(fasta_file.split('.')[0:-1])
# Create a worker for running the algorithm.
worker = ProbAnnotationWorker(genome_id)
try:
template_model = _load_template_file(template_model_file)
# Run blast using the fasta file.
blast_result_file = worker.runBlast(fasta_file)
# Calculate roleset probabilities.
rolestring_tuples = worker.rolesetProbabilitiesMarble(blast_result_file)
# Calculate per-gene role probabilities.
role_probs = worker.rolesetProbabilitiesToRoleProbabilities(rolestring_tuples)
# Calculate whole cell role probabilities.
total_role_probs = worker.totalRoleProbabilities(role_probs)
# Calculate complex probabilities.
complex_probs = worker.complexProbabilities(total_role_probs, complexesToRequiredRoles=_complex_to_roles_dict(template_model))
# Calculate reaction probabilities.
rxn_probs = worker.reactionProbabilities(complex_probs, rxnsToComplexes=_reactions_to_complexes_dict(template_model))
# Store in dictionary for better serialization
return ReactionProbabilities([{'reaction': r[0], 'probability': r[1], 'type': r[2], 'complexes': _deserialize_cplx(r[3], worker.config['separator']), 'gpr': r[4]} for r in rxn_probs])
finally:
worker.cleanup() # worker creates lots of temporary and intermediate files. Allow it to clean up | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculateLogJointProbabilities(self, datum):\n logJoint = util.Counter()\n \n \"*** YOUR CODE HERE ***\"\n \n # -- OUR CODE HERE\n \n \n import math\n for label in self.legalLabels:\n sumThing = 0.0\n for pixel in self.conditionalProb[label]:\n if datum[pixel] is 1:\... | [
"0.64158255",
"0.61762154",
"0.6171898",
"0.61255485",
"0.6108559",
"0.60751355",
"0.5888883",
"0.581115",
"0.57994837",
"0.5773769",
"0.57539636",
"0.5743196",
"0.57412934",
"0.57062215",
"0.5637121",
"0.5604803",
"0.56041193",
"0.55022335",
"0.5498393",
"0.543617",
"0.53924... | 0.6003137 | 6 |
Gapfill a model using probabilistic weights | def probabilistic_gapfill(model, universal_model, reaction_probabilities, clean_exchange_rxns=True, default_penalties=None, dm_rxns=False, ex_rxns=False, **solver_parameters):
universal_model = universal_model.copy()
model = clean_exchange_reactions(model) if clean_exchange_rxns else model.copy()
if default_penalties is None:
default_penalties = {'Universal': 1, 'Exchange': 100, 'Demand': 1, 'Reverse': 75}
penalties = default_penalties
reactions_to_remove = []
for r in universal_model.reactions:
if model.reactions.has_id(r.id):
reactions_to_remove.append(r)
penalties[r.id] = 0 # In the model
elif r.id in reaction_probabilities:
penalties[r.id] = max(0, 1 - reaction_probabilities[r.id]) * (penalties[r.id] if r.id in penalties else 1)
universal_model.remove_reactions(reactions_to_remove)
return cobra.flux_analysis.gapfill(model, universal_model, penalties=penalties, demand_reactions=dm_rxns, exchange_reactions=ex_rxns, **solver_parameters) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_weights(model):\n ...",
"def gap2d(_w_in):\n return nn.AdaptiveAvgPool2d((1, 1))",
"def weightGenerate(self):\n\t\tfor i in range(0, self.numberOfInput):\n\t\t\tself.weight.append(random.random()-0.5)",
"def update_weights(self):\n\n self.weights -= self.loss_grads\n self.los... | [
"0.59936357",
"0.5899231",
"0.5710139",
"0.5680814",
"0.5665641",
"0.565304",
"0.56094337",
"0.56018",
"0.55877113",
"0.55586326",
"0.5552374",
"0.5551015",
"0.5542684",
"0.5506722",
"0.5504694",
"0.5479312",
"0.54784465",
"0.5458892",
"0.54003364",
"0.5388704",
"0.5387438",
... | 0.5979327 | 1 |
Exports the given reaction probabilities into a JSON formatted file, saved at filename | def export_json(rxn_probs, filename):
with open(filename, 'w') as f:
f.write(json.dumps(rxn_probs))
return filename | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_json(self, filename):\n with open(filename, 'a+') as f:\n f.write(json.dumps(self.weights))\n f.write(\"\\n\")",
"def save(statistic_entries):\n with open('learn.json', 'w') as file:\n json.dump(statistic_entries, file, indent=2)",
"def dump(pred_out_path, xyz_p... | [
"0.6705845",
"0.641551",
"0.6144338",
"0.6136017",
"0.6124605",
"0.612017",
"0.61101353",
"0.60968125",
"0.60849845",
"0.5977744",
"0.59029186",
"0.587066",
"0.5857155",
"0.5841988",
"0.5835876",
"0.5835178",
"0.5819759",
"0.5813063",
"0.5810192",
"0.57985073",
"0.5744357",
... | 0.8034322 | 0 |
return the probability of a given reaction | def get_probability(self, reaction):
return self.__getitem__(reaction) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def probability(self, item):\n count = self.counter.get(item, 0)\n if self.smoothing_dict:\n smooth_count = self.smoothing_dict.get(count, count)\n assert smooth_count > 0\n return smooth_count / self.smooth_total\n else:\n return count / self.total"... | [
"0.6590192",
"0.6571907",
"0.647744",
"0.64491594",
"0.6418756",
"0.63888365",
"0.63714635",
"0.6371433",
"0.6367964",
"0.63313365",
"0.6296423",
"0.62912256",
"0.62699294",
"0.62629133",
"0.62573755",
"0.6252374",
"0.62146765",
"0.6207749",
"0.62025577",
"0.6187049",
"0.6182... | 0.8662731 | 0 |
Serializes this object as a JSON stringrxn | def to_json_file(self, path):
with open(path, 'w') as f:
f.write(self.to_json()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def serialize(self):\n return json.dumps(self.as_dict())",
"def _toJSON(self):\n\n return json.encode(self.__toJSON())",
"def to_json(self) -> str:\n return json.dumps(asdict(self))",
"def to_json(self) -> str:\n return json.dumps(self.to_dict())",
"def to_json(self) -> str:\n ... | [
"0.85692286",
"0.85322154",
"0.84612757",
"0.84603655",
"0.84603655",
"0.84603655",
"0.84603655",
"0.84603655",
"0.84603655",
"0.84603655",
"0.84603655",
"0.84603655",
"0.84569603",
"0.8437394",
"0.84211195",
"0.8399535",
"0.83540624",
"0.83540624",
"0.83424884",
"0.83178025",
... | 0.0 | -1 |
Deserialize a ReactionProbabilities from a JSON file | def from_json_file(path):
with open(path, 'r') as f:
return ReactionProbabilities.from_json(f.read()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_priors(file_name):\n with open(file_name, \"r\") as fp:\n priors = json.load(fp)\n return priors",
"def read_classification_json(fn):\n with open(fn) as f:\n classification_data = json.load(f)\n f.close()\n \n return classification_data",
"def load_priors(self, ... | [
"0.6095132",
"0.60795057",
"0.5984798",
"0.59495234",
"0.57160014",
"0.56639713",
"0.5619954",
"0.5497838",
"0.5492578",
"0.53609985",
"0.5356933",
"0.53483236",
"0.5318638",
"0.53132015",
"0.52867985",
"0.52783847",
"0.5249616",
"0.52431166",
"0.5227828",
"0.5201468",
"0.519... | 0.85232556 | 0 |
Updates the Reaction Probabilities | def update(self, rxn_probs):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prob_update(self):\n pass",
"def update_probabilities(self):\n self.probabilities = self.pheromones**self.EXP_PH * self.mcv**self.EXP_MCV",
"def update(probabilities, one_gene, two_genes, have_trait, p):\n for person in probabilities:\n\n # count the genes for the person\n ge... | [
"0.7125513",
"0.7022864",
"0.6515388",
"0.64963096",
"0.64798397",
"0.64248484",
"0.64184403",
"0.63899285",
"0.6279894",
"0.6097903",
"0.6097903",
"0.6088608",
"0.6073833",
"0.6068825",
"0.60576266",
"0.6045901",
"0.6018484",
"0.60050225",
"0.5990919",
"0.5990202",
"0.598924... | 0.6925041 | 2 |
Takes a big limit as an integer and get all the prime numbers in that range, including the limit itself. Returns a numpy array of the primes. Fragmentation is an int that multiplies the sqrt of the limit to increase the fragment size. Bigger fragmentation consumes more memory and less time. Fragmentation limit = sqrt of limit. For 4 GB RAM not enough memory for limit == 109. Fragmentation 1000 ok | def get_primes_in_big_limit(limit, fragmentation=1):
print("Getting primes...")
print("Fragmentation set to", fragmentation)
fragment_limit = int(np.sqrt(limit))
fragment_lowest = 0
fragment_highest = fragment_lowest + fragment_limit
primes_in_limit = np.array([], dtype=int)
while fragment_highest < limit:
if fragment_lowest == 0:
fragment_highest += 1
primes_in_first_fragment = get_primes_in(fragment_highest)
primes_in_limit = np.concatenate([primes_in_limit,
primes_in_first_fragment],
axis=None)
else:
primes_in_fragment = get_primes_in_fragment(fragment_lowest,
fragment_highest,
primes_in_first_fragment
)
primes_in_limit = np.concatenate([primes_in_limit,
primes_in_fragment],
axis=None)
fragment_lowest = fragment_highest
fragment_highest += (fragment_limit * fragmentation)
primes_in_last_fragment = get_primes_in_fragment(fragment_lowest,
limit+1,
primes_in_first_fragment
)
return np.concatenate([primes_in_limit, primes_in_last_fragment], axis=None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_primes_in(limit):\n range_limit = np.arange(limit)\n prime_mask = np.ones(limit, dtype=bool)\n prime_mask[0:2] = False\n for i in range_limit[:int(np.sqrt(limit))+1]:\n if prime_mask[i]:\n prime_mask[2*i::i] = False\n return range_limit[prime_mask]",
"def eratosthenes(lim... | [
"0.7772032",
"0.75551635",
"0.754886",
"0.71958756",
"0.7041358",
"0.6890954",
"0.6870041",
"0.67170656",
"0.66442776",
"0.6626837",
"0.65599114",
"0.63915014",
"0.6374505",
"0.63370544",
"0.6328696",
"0.6316949",
"0.6307289",
"0.62010443",
"0.6167947",
"0.61109275",
"0.61072... | 0.8527422 | 0 |
Takes a limit as an integer and get all the prime numbers in that range, NOT including the limit itself. Returns a numpy array of the primes. | def get_primes_in(limit):
range_limit = np.arange(limit)
prime_mask = np.ones(limit, dtype=bool)
prime_mask[0:2] = False
for i in range_limit[:int(np.sqrt(limit))+1]:
if prime_mask[i]:
prime_mask[2*i::i] = False
return range_limit[prime_mask] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eratosthenes(limit):\n if isinstance(limit, (int, float)) and limit == int(limit):\n limit = int(limit)\n else:\n raise ValueError\n primes = []\n mask = [1]*(limit+1)\n for i in range(2, limit+1):\n if mask[i]:\n primes.append(i)\n for j in range(i*i, ... | [
"0.80535877",
"0.7970838",
"0.7566367",
"0.75646406",
"0.74854904",
"0.7452761",
"0.73869497",
"0.7217808",
"0.72028553",
"0.7137117",
"0.69901395",
"0.69098914",
"0.6839922",
"0.66989404",
"0.6691934",
"0.6605368",
"0.65635985",
"0.64167565",
"0.6413339",
"0.6396981",
"0.637... | 0.846045 | 0 |
Takes fragment lowest and highest limits as an integers and get all the prime numbers in that range, NOT including the limit itself. Returns a numpy array of the primes. Needs the primes from the first fragment of the program as input. | def get_primes_in_fragment(fragment_lowest, fragment_highest,
primes_in_first_fragment):
fragment_range = np.arange(fragment_lowest, fragment_highest)
prime_mask = np.ones(len(fragment_range), dtype=bool)
for p in primes_in_first_fragment:
if fragment_lowest % p == 0:
first_multiple = fragment_lowest // p
else:
first_multiple = fragment_lowest // p + 1
first_multiple_index = first_multiple * p - fragment_lowest
prime_mask[first_multiple_index::p] = False
return fragment_range[prime_mask] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_primes_in_big_limit(limit, fragmentation=1):\n print(\"Getting primes...\")\n print(\"Fragmentation set to\", fragmentation)\n fragment_limit = int(np.sqrt(limit))\n fragment_lowest = 0\n fragment_highest = fragment_lowest + fragment_limit\n primes_in_limit = np.array([], dtype=int)\n ... | [
"0.7555909",
"0.745268",
"0.72320384",
"0.6928359",
"0.6911003",
"0.6905713",
"0.67729235",
"0.6719026",
"0.6628001",
"0.66014606",
"0.65840936",
"0.6533467",
"0.6412444",
"0.64070624",
"0.64064884",
"0.63762397",
"0.63470197",
"0.6316131",
"0.6301665",
"0.6293129",
"0.629164... | 0.80316025 | 0 |
Takes a tuple where the first element is the dividend and the second element is the divisor. Both element sould be int. Performs a long division | def long_division(dividend_divisor_tuple, decimal_limit=5):
natural, decimal = [], []
dividend, divisor = dividend_divisor_tuple[0], dividend_divisor_tuple[1]
assert isinstance(dividend, int), "Dividend not int"
assert isinstance(divisor, int), "Divisor not int"
floor_div = dividend // divisor
rest = dividend % divisor
# Natural part of the division
while floor_div > 0:
natural.append(str(floor_div))
dividend = rest
floor_div = dividend // divisor
rest = dividend % divisor
if rest == 0: # Divisor is factor of dividend
print("Divisor is factor of dividend")
return ("".join(natural), None, None)
# Decimal part of the division
dividend_list = []
recurring_index = None
while len(decimal) < decimal_limit:
dividend_list.append(dividend)
dividend *= 10
floor_div = dividend // divisor
decimal.append(str(floor_div))
rest = dividend % divisor
if rest == 0: # Terminating decimal reached
return ("".join(natural), "".join(decimal), None)
elif rest in dividend_list: # Recurring cycle found
recurring_index = dividend_list.index(rest)
print("Recurring cycle found")
break
else:
dividend = rest
if recurring_index is not None:
recurring = decimal[recurring_index:]
decimal = decimal[:recurring_index]
return ("".join(natural), "".join(decimal), "".join(recurring))
else:
print("Decimal limit reached")
return ("".join(natural), "".join(decimal), None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def div_numbers(a: int, b: int) -> int:\n return a / b",
"def test_div():\n l = [1, 2, 3, 4]\n assert s7.div(*l) == 1 / 2 / 3 / 4\n assert s7.div(100, 20) == 5\n assert s7.div(100.0, 20) == 5.0\n assert s7.div(100, 20.0) == 5.0",
"def div(seq):\n for (i, n) in enumerate(seq):\n # tr... | [
"0.65800995",
"0.6371114",
"0.63462335",
"0.6256875",
"0.6244074",
"0.62214583",
"0.6192333",
"0.61851525",
"0.6185146",
"0.61841047",
"0.6174636",
"0.6085751",
"0.6082528",
"0.603412",
"0.6029013",
"0.6028425",
"0.6017244",
"0.6011632",
"0.60035694",
"0.59994143",
"0.5984466... | 0.6508378 | 1 |
Get length of number in digits. | def get_number_length(number):
return len(str(number)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ndigits(n):\n return len(str(abs(n)))",
"def count_digits(n):\n return len(str(n))",
"def _number_of_digits(number: int) -> int:\n return int(log10(number)) + 1",
"def get_int_width(integer):\n return len(str(integer))",
"def get_length(x):\n\n try:\n return int(x)\n ex... | [
"0.7974036",
"0.78436166",
"0.75876623",
"0.72771937",
"0.68577904",
"0.68538064",
"0.677399",
"0.6735333",
"0.6720063",
"0.6719415",
"0.6715743",
"0.6707653",
"0.6707653",
"0.6627682",
"0.6612727",
"0.65931964",
"0.6514543",
"0.64946806",
"0.6464933",
"0.6453461",
"0.6445275... | 0.8823181 | 0 |
Returns array of all the posible sums between list elements. | def cross_sum_elements_of_list(list_of_int):
array_of_int = np.array(list_of_int).reshape((len(list_of_int), 1))
transposed_array = array_of_int.copy().T
sum_of_elements_array = array_of_int + transposed_array
return np.unique(sum_of_elements_array) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum(lists) -> list:\r\n return list(np.sum(lists, 0))",
"def sum_elements(arr):\n return sum(arr)",
"def sum_list(input_list: List[float]) -> float:\n return sum(input_list)",
"def sum_list(input_list: List[float]) -> float:\n return sum(input_list)",
"def sum_list(input_list: List[float]) ... | [
"0.7886432",
"0.72365195",
"0.7159521",
"0.7159521",
"0.71008116",
"0.7051906",
"0.70465595",
"0.7040757",
"0.67752486",
"0.6750484",
"0.6748924",
"0.6736692",
"0.6732239",
"0.66944194",
"0.6687826",
"0.667164",
"0.66535944",
"0.6639427",
"0.66387355",
"0.6596252",
"0.6593165... | 0.71858424 | 2 |
Return list of all the divisors of an integer num. | def get_divisors(num):
assert num != 0, "Num is 0"
divisors = []
sq_root = int(num**0.5)
for i in range(1, sq_root + 1):
if num % i == 0:
divisors.extend([i, num // i])
# if num has a perfect sq, that number will be added twice, then:
if sq_root ** 2 == num:
divisors.remove(sq_root)
return divisors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simple_get_divisors(num: int) -> list:\n all_divisors = []\n for possible_divisor in range(1, math.floor(num / 2) + 1):\n if num % possible_divisor == 0:\n all_divisors.append(possible_divisor)\n return all_divisors",
"def get_divisores(num):\n divisores = [] #uso una lista para... | [
"0.87616765",
"0.84940773",
"0.8239428",
"0.8224629",
"0.81623006",
"0.80934465",
"0.8033521",
"0.78625435",
"0.78059375",
"0.7753855",
"0.7717071",
"0.76835775",
"0.767592",
"0.7558653",
"0.75212115",
"0.74451685",
"0.74397975",
"0.7423215",
"0.74036175",
"0.7400764",
"0.739... | 0.8431378 | 2 |
Get absolute path to resource, to get logo | def resource_path(relative_path):
try:
# PyInstaller creates a temp folder and stores path in _MEIPASS
base_path = sys._MEIPASS
except Exception:
base_path = os.path.abspath(".")
return os.path.join(base_path, relative_path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logo_url(self):\n return self.get_url(\"logo\", \"images/logo.png\")",
"def logo_uri(self) -> str:\n return pulumi.get(self, \"logo_uri\")",
"def resource_path(name):\n return os.path.join(\n os.path.dirname(__file__), 'images', 'resource', name)",
"def get_client_company_logo_dir... | [
"0.72962266",
"0.719628",
"0.715207",
"0.7071001",
"0.6983272",
"0.69696295",
"0.6932713",
"0.6828541",
"0.6828541",
"0.6821016",
"0.68035823",
"0.6728892",
"0.67225164",
"0.67204624",
"0.6692771",
"0.6692771",
"0.6684799",
"0.6639405",
"0.6596103",
"0.65899694",
"0.6586349",... | 0.0 | -1 |
function looping through other functions to build tree and then save it | def loop_trough_row(var, name_col, list_error, list_of_project_info):
sheet = get_excel(exceldokument)
i = 3
while i < sheet.nrows:
try:
file_name = str(sheet.cell_value(i, name_col))
if file_name != "":
tree, safecookie, steps, prev = createxmlmall()
list_error = loop_through_col(steps, safecookie, i, file_name, var, list_error, list_of_project_info)
# save_xml(tree, (file_name) + ".xml", folder_name)
for errors in list_error:
if errors.error_type == "4":
return list_error
save_xml(tree, file_name + ".tcs", folder_name)
else:
for l in range(sheet.ncols):
if str(sheet.cell_value(i, l)) != "":
p = AddFileWithError(i + 1, "3")
list_error = p.add_el(list_error, p)
i += 1
except:
p = AddFileWithError(i + 1, "1")
list_error = p.add_el(list_error, p)
return list_error
return list_error | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_tree(self, prefix, depth):\n for count, function in [[self.n_files, self.make_file],\n [self.n_children, self.make_child_recurse],\n [self.n_symlinks, self.make_symlink]]:\n for i in range(count):\n if not self... | [
"0.635694",
"0.63468206",
"0.6294683",
"0.6240964",
"0.6053419",
"0.59460986",
"0.59322184",
"0.58918864",
"0.5855702",
"0.581498",
"0.57331216",
"0.56759137",
"0.56216335",
"0.5617605",
"0.5604815",
"0.56032133",
"0.56020284",
"0.559628",
"0.5595393",
"0.5594104",
"0.5552079... | 0.0 | -1 |
opens the chosen exceldocument and returns it as sheet | def get_excel(exceldocument):
sheet = xlrd.open_workbook(exceldocument).sheet_by_index(0)
return sheet | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def openExcelSheet(outputFileName):\n workbook = Workbook()\n worksheet = workbook.add_sheet(\"Sheet 1\")\n return workbook, worksheet",
"def _get_spreadsheet(i):\n path = io_mgr.get_parties_spreadsheet(i)\n if not os.path.exists(path):\n raise IOError()\n\n return openpyxl.load_workbook(path,... | [
"0.69280106",
"0.6738904",
"0.6419168",
"0.6310797",
"0.605773",
"0.6051629",
"0.6044591",
"0.6008777",
"0.5982114",
"0.5974647",
"0.59715974",
"0.5966216",
"0.59524924",
"0.59430736",
"0.5873261",
"0.5856575",
"0.57233405",
"0.5704794",
"0.569487",
"0.5689535",
"0.5683357",
... | 0.77836186 | 0 |
creates an xml structure with root and motherelements | def createxmlmall():
root = ET.Element("state")
model = ET.SubElement(root, "model")
model.text = r""
dataid = ET.SubElement(root, "dataids")
application = ET.SubElement(root, "application")
application.text = "SIBS Configurator"
safecookie = ET.SubElement(root, "safecookie")
steps = ET.SubElement(root, "steps")
prev = ET.SubElement(steps, "prev")
lastproxy = ET.SubElement(root, "last-proxy").text = "tcserver0"
tree = ET.ElementTree(root) # saves tree in variable "tree"
return tree, safecookie, steps, prev | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_xml(self, root_name):\n\n self.tree = ET.ElementTree(ET.fromstring('<?xml version=\"1.0\" encoding=\"UTF-8\"?><%s></%s>'%(\n root_name, root_name)))\n return self.tree.getroot()",
"def create_roots(self):\n self.root ... | [
"0.6970181",
"0.63764966",
"0.6287799",
"0.6225016",
"0.6220165",
"0.6217637",
"0.6206258",
"0.619495",
"0.6160407",
"0.6134908",
"0.61195517",
"0.6091069",
"0.6088098",
"0.60488194",
"0.59819216",
"0.59459764",
"0.59355354",
"0.5920509",
"0.5884173",
"0.5878814",
"0.5870564"... | 0.75603426 | 0 |
Creates a folder and saves xml tree in a specific path | def save_xml(tree, file_name, folder_name):
import os # ändrar plats för filer
os.chdir(folder_name)
tree.write(file_name) # Namnet på ny fil
| {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mkdir(path):",
"def create_folder(path):\n command = ['mkdir', TEST_DIR]\n file_operation(path, command)",
"def create_folder(path):\n if not os.path.exists(path):\n os.makedirs(path)",
"def create_folder(self):\n Path(self.root_name).mkdir(parents=True, exist_ok=True)\n Pat... | [
"0.7024828",
"0.700881",
"0.6860256",
"0.68011755",
"0.6756072",
"0.6738238",
"0.66949385",
"0.66890776",
"0.6670779",
"0.6649409",
"0.6647468",
"0.66387165",
"0.66373086",
"0.66274315",
"0.66152924",
"0.66047573",
"0.6588086",
"0.6582058",
"0.656134",
"0.65589786",
"0.651623... | 0.7450946 | 0 |
takes input and returns a string | def makeinputstring(variabel):
if type(variabel) == int:
return str(variabel)
elif type(variabel) == float:
return str(int(float(variabel)))
else:
return str(variabel) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_input_string():\n return input(\"Enter input string: \")",
"def get_string(opt=\"encode\"):\n text = input(f\"Enter string to {opt}: \")\n return text",
"def input_str() -> str:\n\tinput_string = str(input('Enter your string: '))\n\treturn input_string",
"def input_str() -> str:\n\t\tinput_s... | [
"0.73874146",
"0.7343399",
"0.72803926",
"0.7171811",
"0.7066056",
"0.6929175",
"0.69019353",
"0.6721488",
"0.66247624",
"0.65604264",
"0.6521488",
"0.6518847",
"0.6444485",
"0.6426503",
"0.6425762",
"0.63756746",
"0.6344128",
"0.6306453",
"0.6288618",
"0.6283329",
"0.6271066... | 0.63531923 | 16 |
This function loops through the excel and sorts out elements, names, texts and where in the tree they should be added. | def loop_through_col(steps, safecookie, b, file_name, var, list_error, list_of_project_info):
col, k, j, g = 4, 1, 0, 0
sheet = get_excel(exceldokument)
row_for_commitname = 2 #nya
#row_for_commitname = 1 #gamla
while col < sheet.ncols:
if sheet.cell_type(0, col) != 0:
j += 1
if sheet.cell_type(row_for_commitname, col)!= 0:
g += 1
col += 1
if j == 0 or g == 0:
p = AddFileWithError(file_name, "4")
list_error = p.add_el(list_error, p)
return list_error
col = 4
while col < sheet.ncols:
if sheet.cell_type(0, col) != 0:
name = (sheet.cell_value(0, col))
commit = Steps(name).addtoxml(k, j, steps, safecookie)
commit_name = (sheet.cell_value(row_for_commitname, col))
list_error = check_cell_error(b, col, sheet, list_error, file_name)
if commit_name.lower() == "littra":
commit_name = "littra"
if k == 1 and sheet.cell_type(b, col) != 0:
c_name = (sheet.cell_value(b, col))
AddAttrToTree(commit, commit_name, makeinputstring(c_name)).addtoxml()
for x in range(0, 5):
AddAttrToTree(commit, list_of_project_info[x], makeinputstring(var[x])).addtoxml()
elif k != 1 and sheet.cell_type(b, col) != 0:
c_name = (sheet.cell_value(b, col))
AddAttrToTree(commit, commit_name, makeinputstring(c_name)).addtoxml()
k += 1
n = col + 1
if sheet.cell_type(0, n) != 0:
if sheet.cell_type(b, col) != 0:
commit_name = (sheet.cell_value(row_for_commitname, col))
c_name = (sheet.cell_value(b, col))
AddAttrToTree(commit, commit_name, makeinputstring(c_name)).addtoxml()
elif sheet.cell_type(0, n) == 0:
try:
while sheet.cell_type(0, n) == 0 and n - 1 < sheet.ncols:
if sheet.cell_type(b, n) != 0:
list_error = check_cell_error(b, n, sheet, list_error, file_name)
commit_name = (sheet.cell_value(row_for_commitname, n))
c_name = (sheet.cell_value(b, n))
AddAttrToTree(commit, commit_name, makeinputstring(c_name)).addtoxml()
n += 1
except:
pass
col += 1
return list_error | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_excel(self):\r\n try:\r\n self.check_point_1 = True\r\n self.filename = tkFileDialog.askopenfilename(initialdir=\"/\", title=\"Select file\",\r\n filetypes=((\"excel files\", \"*.xlsx\"), (\"all files\", \"*.*\")))\r\n\r\n ... | [
"0.58093977",
"0.55304813",
"0.54485965",
"0.5410043",
"0.53819305",
"0.5349107",
"0.5269191",
"0.5251047",
"0.51980996",
"0.5178889",
"0.51472735",
"0.5129128",
"0.5119549",
"0.50939554",
"0.5085807",
"0.5049187",
"0.5038129",
"0.50297076",
"0.5020485",
"0.49983808",
"0.4973... | 0.49841878 | 20 |
Creates variable of chosen exceldocument | def entry_set_excel(self, entry):
global exceldokument
exceldokument = filedialog.askopenfilename(filetypes=[("Excel file","*.xlsx"),("Excel file", "*.xlsm")])
entry.delete(0, 'end')
entry.insert(tk.END, exceldokument) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def documento():\r\n\tpass",
"def edit_document():",
"def build_document(self):\n pass",
"def savedoc():\r\n document.save('QSDoc_{0}_{1}_{2}_{3}.docx'.format(args.server, year, month, day))",
"def create(init_document: 'Document') -> 'DocumentArray':",
"def _create_document(result_dict):\n ... | [
"0.5883688",
"0.5880611",
"0.58433646",
"0.58253616",
"0.57991326",
"0.57213825",
"0.5719066",
"0.5658872",
"0.56124973",
"0.5600502",
"0.5573449",
"0.55684054",
"0.55032",
"0.5484727",
"0.54810476",
"0.5461333",
"0.5415002",
"0.54017013",
"0.53869313",
"0.538439",
"0.5352028... | 0.0 | -1 |
Creates variable of chosen folder | def entry_set_folder(self, entry):
global folder_name
folder_name = filedialog.askdirectory()
entry.delete(0, 'end')
entry.insert(tk.END, folder_name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_folder():\n return input(\"Folder: \")",
"def create_folder(self):\n cur_dir=os.getcwd()\n unique=False\n dirlist= [item for item in os.listdir(cur_dir) if os.path.isdir(os.path.join(cur_dir,item))]\n folder_name='taxonomy_{}_{}'.format(self.place,self.year)\n j=1\n ... | [
"0.6584977",
"0.6489762",
"0.6430416",
"0.6309875",
"0.63006985",
"0.6285221",
"0.6282425",
"0.6207818",
"0.61075854",
"0.60703206",
"0.6058079",
"0.6047258",
"0.6042317",
"0.6019528",
"0.6018604",
"0.6012094",
"0.6007274",
"0.597246",
"0.5971677",
"0.59710586",
"0.5961468",
... | 0.56268847 | 66 |
Sends all the inputinformation to loop | def start_config(self, entries, name_col, list_error, list_of_project_info):
var = []
for x in entries[3:]:
var.append(x.get())
list_error = loop_trough_row(var, name_col, list_error, list_of_project_info)
return list_error | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loop(self):\n pass",
"def loop(self):\n while True:\n self._print_field()\n try:\n cmd = input(PROMPT)\n self._invoke_cmd(cmd)\n except EOFError: # Allows to exit by pressing ⌃D without error\n break",
"def inputlo... | [
"0.68043214",
"0.6738158",
"0.6389131",
"0.6361578",
"0.63389635",
"0.62979394",
"0.626825",
"0.6264768",
"0.62522584",
"0.6227473",
"0.6211855",
"0.61628276",
"0.6144344",
"0.6113936",
"0.6113531",
"0.6113409",
"0.6088087",
"0.6075006",
"0.60653067",
"0.6044094",
"0.6031112"... | 0.0 | -1 |
Contoll of inputs and try/except for mainloop | def check_entry(self, controller, entries, list_of_project_info, error_label):
for x in range(0, len(entries)):
if entries[x].get() == "":
messagebox.showerror("Error", "Expected no empty fields")
return
if not entries[2].get().isalpha():
messagebox.showerror("Error", "Expected column in letter not number, e.g. 'B' ")
return
name_col = self.col_to_num(entries[2].get())
self.write_to_indata(entries)
list_error,error_present = [], []
list_error = controller.start_config(entries, name_col, list_error, list_of_project_info)
if len(list_error) == 0:
message = "Successfully generated all state files"
error_present.append(message)
error_label.config(text="Successfully generated all state files")
else:
for element in list_error:
if element.error_type == "1": # error in loop_trough_row
message = "expected error in excel spreadsheet at row" + str(element.file_name) + "\n"
elif element.error_type == "2": #filname missing
message = "expected error in file " + str(element.file_name)+ "\n"
elif element.error_type == "3": # Filename error
message = "expected error in file name at row " + str(element.file_name) + "\n"
elif element.error_type == "4": # "Seems like error in 1:st or 3:rd line in excel sheet"
message = "expected error in excel spreadsheet on 1:st or 3:rd row " + "\n"
error_present.append(message)
error_report = open("error_report.txt", "w+")
error_report.write(''.join(error_present))
error_report.close()
error_label.config(text="Error occured, check error report in "+ entries[1].get())
# error_label.config(text=(''.join(error_present)))
| {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cont():\n\n try:\n input = raw_input()\n except Exception:\n pass",
"def interactive_run(self):\r\n while True:\r\n try:\r\n #self.display_mang.print_instructions()\r\n input_string = input()\r\n if input_string == \"exit\":\r... | [
"0.68585896",
"0.68095475",
"0.6770353",
"0.65708673",
"0.6512728",
"0.6459991",
"0.6366776",
"0.6324164",
"0.62918556",
"0.6262099",
"0.6262099",
"0.62162334",
"0.6207645",
"0.6178404",
"0.6168539",
"0.61427873",
"0.60846925",
"0.60826176",
"0.6050576",
"0.60469836",
"0.6045... | 0.0 | -1 |
Create an instance to manager the blob properties extraction. | def Instance(self):
if self.__Instance is None:
self.__Instance = Properties()
return self.__Instance | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, blob=None):\n if blob is None:\n self.versionCode = '0'\n self.data = {}\n else:\n self.versionCode = blob[0]\n encoded = blob[1:]\n compressed = base64.b64decode(encoded)\n self.data = json.loads(zlib.decompress(com... | [
"0.6232803",
"0.5880269",
"0.58206016",
"0.5818862",
"0.5719443",
"0.57131475",
"0.5703017",
"0.56779015",
"0.5674141",
"0.5668743",
"0.5663582",
"0.5659485",
"0.565841",
"0.56503475",
"0.56440836",
"0.5627367",
"0.5611333",
"0.5609648",
"0.5596115",
"0.5574799",
"0.55605406"... | 0.0 | -1 |
This constructor is never used by the system. | def __init__(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n raise NotImplementedError",
"def __init__(self):\n raise NotImplementedError",
"def __init__(self):\n raise NotImplementedError",
"def __init__(self):\n raise NotImplementedError",
"def __init__(self):\n raise NotImplementedError(\"This class cannot ... | [
"0.82291555",
"0.82291555",
"0.82291555",
"0.82291555",
"0.8227341",
"0.8077878",
"0.8016458",
"0.8003538",
"0.79657507",
"0.79657507",
"0.79657507",
"0.79657507",
"0.79657507",
"0.79657507",
"0.79657507",
"0.79657507",
"0.79657507",
"0.79657507",
"0.79657507",
"0.79657507",
... | 0.73578566 | 63 |
Gets an object representation in a string format. | def __repr__(self):
return "IAMLTools.BlobProperties object." | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_str(self, obj):\n if self.pretty:\n return pprint.pformat(obj)\n else:\n return str(obj)",
"def objectToString(obj):\n if (hasattr(obj, \"__iter__\")):\n # matrix or vector\n if len(obj) == 0:\n return \"\"\n else:\n if (ha... | [
"0.79434896",
"0.76730764",
"0.74159396",
"0.7268582",
"0.7246455",
"0.7231229",
"0.7168203",
"0.710605",
"0.7084541",
"0.70546156",
"0.70546156",
"0.70546156",
"0.70546156",
"0.70546156",
"0.70546156",
"0.70546156",
"0.70546156",
"0.70546156",
"0.70546156",
"0.70546156",
"0.... | 0.0 | -1 |
Calcule and return a list of strings specifying by properties. | def getContourProperties(self, contour, properties=[]):
# Initial variables.
failInInput = False
props = {}
for prop in properties:
prop = str(prop).lower()
if prop == "approximation":
props.update({"Approximation" : self.__CalculateApproximation(contour)})
if prop == "area":
props.update({"Area" : self.__CalculateArea(contour)})
elif prop == "boundingbox":
props.update({"BoundingBox" : self.__CalculateBoundingBox(contour)})
elif prop == "centroid":
props.update({"Centroid" : self.__CalculateCentroid(contour)})
elif prop == "circle":
props.update({"Circle" : self.__CalculateCircle(contour)})
elif prop == "circularity":
props.update({"Circularity" : self.__CalculateCircularity(contour)})
elif prop == "convexhull":
props.update({"ConvexHull" : self.__CalculateConvexHull(contour)})
elif prop == "extend":
props.update({"Extend" : self.__CalculateExtend(contour)})
elif prop == "ellipse":
props.update({"Ellipse" : self.__CalculateEllipse(contour)})
elif prop == "isconvex":
props.update({"IsConvex" : self.__IsConvex(contour)})
elif prop == "length":
props.update({"Length" : self.__CalculateLength(contour)})
elif prop == "moments":
props.update({"Moments" : self.__CalculateMoments(contour)})
elif prop == "perimeter":
props.update({"Perimeter" : self.__CalculatePerimeter(contour)})
elif prop == "rotatedbox":
props.update({"RotatedBox" : self.__CalculateRotatedBox(contour)})
elif failInInput:
pass
else:
print("\t--" * 20)
print("\t*** PROPERTY ERROR " + prop + " DOES NOT EXIST ***")
print("\tTHIS ERROR MESSAGE WILL ONLY BE PRINTED ONCE")
print("\--" * 20)
failInInput = True
return props | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getProperties(properties =['electrical_props', '__description'], \r\n sproperty ='electrical_props'):\r\n #------------------------------------\r\n from .database import GeoDataBase\r\n #-----------------------------------\r\n def _fs (v): \r\n \"\"\... | [
"0.66682273",
"0.6444924",
"0.6429075",
"0.6418234",
"0.62668264",
"0.61048454",
"0.6090979",
"0.60708404",
"0.60441667",
"0.600167",
"0.59521866",
"0.5907654",
"0.58133453",
"0.5764389",
"0.5727516",
"0.57220525",
"0.5717066",
"0.56708825",
"0.5670351",
"0.56337535",
"0.5605... | 0.5443529 | 30 |
Calculate the approximation of a contour shape to another shape with less number of vertices depending upon the precision we specify. | def __CalculateApproximation(self, contour):
epsilon = 0.1 * cv2.arcLength(contour, True)
return cv2.approxPolyDP(contour, epsilon, True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def contourApprox(cnt, epsilon = 0.005):\n\tepsilon = epsilon*cv2.arcLength(cnt, True)\n\tapprox = cv2.approxPolyDP(cnt, epsilon, True)\n\treturn approx",
"def approx_poly(self, mask):\n\n mask_expand = mask.copy()\n contours, _ = cv2.findContours(mask_expand, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NO... | [
"0.6073888",
"0.5673097",
"0.5591408",
"0.5486369",
"0.5361581",
"0.53499943",
"0.5272163",
"0.52631676",
"0.5168495",
"0.51550204",
"0.5142952",
"0.51347584",
"0.51139116",
"0.5096012",
"0.5069017",
"0.50188994",
"0.5007644",
"0.5004071",
"0.50028485",
"0.49921945",
"0.49831... | 0.6092272 | 0 |
Calculate the contour area by the function cv2.contourArea() or from moments, M["m00"]. | def __CalculateArea(self, contour):
return cv2.contourArea(contour) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def area(cnt):\n\treturn cv2.contourArea(cnt)",
"def get_contour_area(contour):\n assert isinstance(contour, np.ndarray), 'contour should be a numpy array'\n return cv2.contourArea(contour)",
"def __CalculateMoments(self, contour):\r\n return cv2.moments(contour)",
"def get_max_area(contours):\n... | [
"0.7210734",
"0.66500163",
"0.6628211",
"0.6365675",
"0.614254",
"0.61276436",
"0.6062467",
"0.5952984",
"0.5937475",
"0.59279317",
"0.58706164",
"0.57940084",
"0.5752224",
"0.5744717",
"0.5743859",
"0.5743859",
"0.5719784",
"0.5644189",
"0.56355894",
"0.5590524",
"0.5581619"... | 0.7479222 | 0 |
Calculate the bouding rectangle. It is a straight rectangle, it doesn't consider the rotation of the object. So area of the bounding rectangle won't be minimum. It is found by the function cv2.boundingRect(). | def __CalculateBoundingBox(self, contour):
return cv2.boundingRect(contour) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def boundingRect(self):\n return self.rect().adjusted(-2, -2, 2, 2)",
"def boundingRect(cnt):\n\tx, y, w, h = cv2.boundingRect(cnt)\n\treturn {\"x\":x, \"y\": y, \"w\": w, \"h\": h}",
"def boundingBox(self):\n minx, miny, maxx, maxy = self.substrates.bounds\n return pcbnew.BOX2I(\n ... | [
"0.7676917",
"0.72490233",
"0.71938384",
"0.7107463",
"0.70778424",
"0.7075241",
"0.6987138",
"0.698335",
"0.69716114",
"0.691494",
"0.6906388",
"0.6903976",
"0.68773127",
"0.685709",
"0.6815819",
"0.68036884",
"0.6765353",
"0.6762905",
"0.6715452",
"0.66673505",
"0.66570497"... | 0.74042195 | 1 |
Calculates the centroid of the contour. Moments up to the third order of a polygon or rasterized shape. | def __CalculateCentroid(self, contour):
moments = cv2.moments(contour)
centroid = (-1, -1)
if moments["m00"] != 0:
centroid = (int(round(moments["m10"] / moments["m00"])),
int(round(moments["m01"] / moments["m00"])))
return centroid | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def centroid(self):\n return self.contours_to_matrix().mean(axis=0)",
"def calculateCentroid(self,image):\n\t\tim=cv2.imread(image,0) #reads it in greyscale\n\t\tret,thresh = cv2.threshold(img_copy,128,255,cv2.THRESH_OTSU)\n\t\tim2,contours,hierarchy = cv2.findContours(thresh, 1, 2)\n\t\tcnt = contours[0]... | [
"0.7549272",
"0.7480494",
"0.74477065",
"0.72905296",
"0.72855806",
"0.7277071",
"0.72547257",
"0.7159602",
"0.71536976",
"0.70305306",
"0.7029446",
"0.7029446",
"0.7026189",
"0.6984927",
"0.69735426",
"0.6927554",
"0.69200563",
"0.69048506",
"0.69047856",
"0.6894379",
"0.688... | 0.80175775 | 0 |
Calculate the circumcircle of an object using the function cv2.minEnclosingCircle(). It is a circle which completely covers the object with minimum area. | def __CalculateCircle(self, contour):
return cv2.minEnclosingCircle(contour) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def boundingCircle(self):\n\n try:\n import cv2\n except:\n logger.warning(\"Unable to import cv2\")\n return None\n\n # contour of the blob in image\n contour = self.contour()\n\n points = []\n # list of contour points converted to suitabl... | [
"0.74524856",
"0.72214043",
"0.6968209",
"0.655094",
"0.637335",
"0.62411404",
"0.61780167",
"0.61020416",
"0.6038088",
"0.6018948",
"0.6009186",
"0.59972024",
"0.5996103",
"0.5971567",
"0.5965567",
"0.5927634",
"0.5920173",
"0.5918442",
"0.59156424",
"0.5889828",
"0.58796084... | 0.80844194 | 0 |
Calculate the ellipse circularity. | def __CalculateCircularity(self, contour):
if len(contour) < 2:
return 0
perimeter = cv2.arcLength(contour, False)
area = self.__CalculateArea(contour)
return (4 * math.pi * area) / (perimeter * perimeter) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_eccentricity(self, ellipse):\r\n a = ellipse.get_width()\r\n b = ellipse.get_height()\r\n if b > a:\r\n a, b = b, a\r\n c = np.sqrt(a**2 - b**2)\r\n return fdiv(c, a)",
"def ellipse(self):\n f = self.img\n x = self.x\n y = self.y\n x2 ... | [
"0.7989176",
"0.6924032",
"0.68412817",
"0.68127716",
"0.6727333",
"0.66740966",
"0.6610501",
"0.6582428",
"0.6562776",
"0.65454847",
"0.6515111",
"0.6455083",
"0.6424359",
"0.6401664",
"0.6375693",
"0.6350507",
"0.6339286",
"0.6323839",
"0.62589574",
"0.6257008",
"0.6223934"... | 0.6321363 | 18 |
Finds the convex hull of a point set by checking a curve for convexity defects and corrects it. | def __CalculateConvexHull(self, contour):
return cv2.convexHull(contour) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convex_hull(points):\n\n # Sort the points lexicographically (tuples are compared lexicographically).\n # Remove duplicates to detect the case we have just one unique point.\n points = sorted(set(points))\n\n # Boring case: no points or a single point, possibly repeated multiple times.\n if len(... | [
"0.7381319",
"0.7166372",
"0.71521324",
"0.69881785",
"0.69819653",
"0.69719875",
"0.69375825",
"0.68497926",
"0.6776819",
"0.66407245",
"0.6561083",
"0.6464603",
"0.6462413",
"0.6459737",
"0.64563394",
"0.64457273",
"0.6220267",
"0.6213466",
"0.62115705",
"0.61951804",
"0.61... | 0.5578606 | 48 |
Fit an ellipse to an object. It returns the rotated rectangle in which the ellipse is inscribed. | def __CalculateEllipse(self, contour):
if len(contour) > 5:
return cv2.fitEllipse(contour)
return cv2.minAreaRect(contour) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_ellipse(x,y):\r\n \r\n def fit(x,y):\r\n x = x[:,np.newaxis]\r\n y = y[:,np.newaxis]\r\n D = np.hstack((x*x, x*y, y*y, x, y, np.ones_like(x)))\r\n S = np.dot(D.T,D)\r\n C = np.zeros([6,6])\r\n C[0,2] = C[2,0] = 2; C[1,1] = -1\r\n E, V = np.linalg.eig... | [
"0.72764295",
"0.65389484",
"0.6258115",
"0.6085874",
"0.6078846",
"0.59491014",
"0.5820374",
"0.5784566",
"0.561725",
"0.55927783",
"0.5559429",
"0.5536257",
"0.5470644",
"0.5456046",
"0.54508764",
"0.54230434",
"0.5402299",
"0.53830856",
"0.5359062",
"0.53571004",
"0.535605... | 0.5605659 | 9 |
Calculate the countour extend. | def __CalculateExtend(self, contour):
area = self.__CalculateArea(contour)
boundingBox = self.__CalculateBoundingBox(contour)
return area / (boundingBox[2] * boundingBox[3]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def life_insurance_to_recive_total(self):\n pass",
"def extendability(self):\n self._extendability = 0.50 * self.ANA - 0.50 * self.DCC + 0.50 * self.MFA + 0.50 * self.NOP\n return round(self._extendability, 5)",
"def calculate(self):",
"def calculate(self):\n pass",
"def update_... | [
"0.56703246",
"0.5525739",
"0.5475888",
"0.5367172",
"0.5338628",
"0.53284657",
"0.53263986",
"0.53008175",
"0.529843",
"0.5273235",
"0.52313775",
"0.5210509",
"0.5181706",
"0.51630366",
"0.5138338",
"0.51348615",
"0.50815606",
"0.50513184",
"0.504204",
"0.50351846",
"0.50212... | 0.6228183 | 0 |
Check if a curve is convex or not. | def __IsConvex(self, contour):
return cv2.isContourConvex(contour) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convex(self):\n # Convex has positive curvature (2nd derivative)\n # f\"(x) = 2a, so a > 0 corresponds to convex\n return (self.a > 0)",
"def _check_curve(layer: ogr.Layer) -> None:\n # Check if the feature geometry is polygonal:\n feature_defn = layer.GetLayerDefn()\n ... | [
"0.7643623",
"0.6757536",
"0.67146444",
"0.65801567",
"0.6464188",
"0.6454179",
"0.635574",
"0.62782335",
"0.61885536",
"0.61603767",
"0.6148129",
"0.6033672",
"0.60245943",
"0.590163",
"0.580078",
"0.5784255",
"0.57838607",
"0.5783847",
"0.5773544",
"0.57301515",
"0.5673152"... | 0.73451805 | 1 |
Calculate a contour perimeter or a curve length. | def __CalculateLength(self, curve):
return cv2.arcLength(curve, True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __CalculatePerimeter(self, curve):\r\n return cv2.arcLength(curve, True)",
"def perimeter(cnt):\n\treturn cv2.arcLength(cnt, True)",
"def perimeter(self):\n return self.sidelength1 + self.sidelength2 + self.baselength1 + self.baselength2",
"def perimeter(self):\n return sum([s.length for... | [
"0.7951354",
"0.72823113",
"0.69471735",
"0.68977535",
"0.6630319",
"0.65940684",
"0.65453714",
"0.65153366",
"0.6505985",
"0.64768934",
"0.6449339",
"0.6431239",
"0.6404429",
"0.63940036",
"0.6379212",
"0.6343764",
"0.6341372",
"0.6341372",
"0.63238937",
"0.6322581",
"0.6228... | 0.66685665 | 4 |
Calculate the contour moments to help you to calculate some features like center of mass of the object, area of the object etc. | def __CalculateMoments(self, contour):
return cv2.moments(contour) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def moments(cnt):\n\treturn cv2.moments(cnt)",
"def moments(cnt):\n\treturn cv2.moments(cnt)",
"def moments(self):",
"def moments(data):\n# =============================================================================\n# total = data.sum()\n# X, Y = np.indices(data.shape)\n# x = (X*da... | [
"0.6727947",
"0.6727947",
"0.66949683",
"0.65000355",
"0.6481608",
"0.63708127",
"0.6356746",
"0.6351715",
"0.6243697",
"0.61840034",
"0.6168322",
"0.6164202",
"0.6142851",
"0.6103647",
"0.60443234",
"0.6014186",
"0.6013817",
"0.5995825",
"0.59587353",
"0.59543926",
"0.595082... | 0.77274 | 0 |
Calculates a contour perimeter or a curve length. | def __CalculatePerimeter(self, curve):
return cv2.arcLength(curve, True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def perimeter(cnt):\n\treturn cv2.arcLength(cnt, True)",
"def perimeter(self):\n return self.sidelength1 + self.sidelength2 + self.baselength1 + self.baselength2",
"def perimeter(self):\n return sum([s.length for s in self.segments])",
"def perimeter(self):",
"def __CalculateLength(self, curve):\... | [
"0.721825",
"0.69289505",
"0.6759035",
"0.6589213",
"0.6564522",
"0.65498984",
"0.6483492",
"0.6478432",
"0.6431225",
"0.6417622",
"0.6385283",
"0.6373984",
"0.63636816",
"0.636077",
"0.6348714",
"0.6287157",
"0.62746215",
"0.6269028",
"0.6236131",
"0.6204229",
"0.6204229",
... | 0.7875777 | 0 |
Calculate the rotated rectangle as a Box2D structure which contains | def __CalculateRotatedBox(self, contour):
rectangle = cv2.minAreaRect(contour)
box = cv2.boxPoints(rectangle)
return np.int0(box) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _apply_rotation(self, rectangle):\n if self._rotation == 90:\n return Rectangle(\n self._height - rectangle.y2,\n rectangle.x1,\n self._height - rectangle.y1,\n rectangle.x2,\n )\n if self._rotation == 180:\n ... | [
"0.7022365",
"0.667482",
"0.64325494",
"0.641342",
"0.6358206",
"0.6105708",
"0.60524374",
"0.604659",
"0.604289",
"0.602959",
"0.60229516",
"0.6003215",
"0.5952361",
"0.58678347",
"0.58623916",
"0.5842129",
"0.5837796",
"0.58315367",
"0.5814212",
"0.5811554",
"0.58072996",
... | 0.6074911 | 6 |
Converts UTM coordinates into latitude/longitude. assumes rows are easting, northing, zone number, either 'N' for northern hemisphere or 'S' for southern hemisphere | def utm_to_latlong(input_data_file=None, output_data_file=None, log_file=None, log_level=DEFAULT_LOG_LEVEL):
logger = logger_message(__name__, log_file, log_level)
# Check required input and output data file names were given.
assert input_data_file is not None, 'An input CSV file with columns of values.'
assert output_data_file is not None, 'An output CSV file to write new values.'
_in = open(input_data_file, 'r')
try:
_out = open(output_data_file, 'w')
try:
data = csv.reader(_in)
output = csv.writer(_out)
for row_ind, row in enumerate(data):
east = float(row[0])
north = float(row[1])
zone = int(row[2])
latlong = utm.to_latlon(east, north, zone, northern=('N' == row[3]))
logger.info('Changed row {} from: {} to: {}'.format(row_ind,
(row[0], row[1]), latlong))
output.writerow(latlong)
finally:
_out.close()
finally:
_in.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_pseudo_epsg4326_coordinates(self):\n self.create_3d_coord_on_sphere(on_sphere=True)\n self.df_attributes['lat'] = 180*(pi/2 - np.arccos(self.df_attributes['coord_z']))/pi\n self.df_attributes['lon'] = 180*np.arctan2(self.df_attributes['coord_y'], self.df_attributes['coord_x'])/pi",
... | [
"0.6428161",
"0.63630664",
"0.63455874",
"0.6290571",
"0.62546146",
"0.62182456",
"0.6173703",
"0.616266",
"0.61362135",
"0.6058876",
"0.60567707",
"0.6025662",
"0.5944653",
"0.5914385",
"0.5914179",
"0.5903728",
"0.5840953",
"0.5805078",
"0.57799006",
"0.5759482",
"0.5756983... | 0.5855182 | 16 |
Adds a shortcut between input and residual block and merges them with "sum" | def _shortcut(input, residual):
# Expand channels of shortcut to match residual.
# Stride appropriately to match residual (width, height)
# Should be int if network architecture is correctly configured.
input_shape = K.int_shape(input)
residual_shape = K.int_shape(residual)
stride_width = int(round(input_shape[2] / residual_shape[2]))
stride_height = int(round(input_shape[3] / residual_shape[3]))
stride_depth = int(round(input_shape[4] / residual_shape[4]))
equal_channels = input_shape[1] == residual_shape[1]
shortcut = input
# 1 X 1 conv if shape is different. Else identity.
if stride_width > 1 or stride_height > 1 or stride_depth > 1 or not equal_channels:
shortcut = Convolution3D(residual_shape[1], 1, 1, 1, subsample=(stride_width, stride_height, stride_depth), border_mode = "valid", init="he_normal",W_regularizer=l2(0.0001))(input)
return shortcut | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def residual_block(layer, filters):\n shortcut = layer\n layer = Conv2D(filters=filters, kernel_size=(3, 3),\n strides=(1, 1), padding=\"same\")(layer)\n layer = LeakyReLU(alpha=LEAKY_RELU_ALPHA)(layer)\n layer = Conv2D(filters=filters, kernel_s... | [
"0.6083529",
"0.5894693",
"0.5735994",
"0.56371546",
"0.5619291",
"0.5514519",
"0.5502387",
"0.5502087",
"0.54550755",
"0.54191214",
"0.54108816",
"0.5387289",
"0.53559756",
"0.5333165",
"0.53286403",
"0.5305475",
"0.5285419",
"0.5280931",
"0.5280322",
"0.52757835",
"0.526515... | 0.515336 | 25 |
Patching out the functions in CrimeIncidentsIntent that use requests.get | def setUp(self):
super().setUp()
self.get_crime_incident_response = \
mock.patch(
('mycity.intents.crime_activity_intent.'
'get_crime_incident_response'),
return_value=test_constants.GET_CRIME_INCIDENTS_API_MOCK)
self.get_crime_incident_response.start()
response = self.controller.on_intent(self.request)
for record in MOCK_RESPONSE[RESULT][RECORDS]:
self.assertIn(record[STREET], response.output_speech) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _external_request(self, method, url, *args, **kwargs):\n self.last_url = url\n if url in self.responses.keys() and method == 'get':\n return self.responses[url] # return from cache if its there\n\n headers = kwargs.pop('headers', None)\n custom = {'User-Agent': useragent}... | [
"0.6091576",
"0.5723631",
"0.5565101",
"0.5542613",
"0.55409104",
"0.55404246",
"0.5505588",
"0.5505458",
"0.54588634",
"0.5443315",
"0.5433013",
"0.5402714",
"0.5384366",
"0.5381944",
"0.5375504",
"0.5370188",
"0.5344704",
"0.5320391",
"0.5319966",
"0.531785",
"0.5312466",
... | 0.0 | -1 |
Update the ElasticSearch index every hour. | def update_es_index():
for job in scheduler.get_jobs():
if 'task_type' in job.meta and job.meta['task_type'] == "update_index":
scheduler.cancel(job)
scheduler.schedule(
scheduled_time=datetime.now(),
func='haystack.management.commands.update_index.Command().handle()',
interval=60 * 60,
repeat=None,
)
for job in scheduler.get_jobs():
index_job = job
if index_job.func_name == 'haystack.management.commands.update_index.Command().handle()':
break
index_job.meta['task_type'] = "update_index"
index_job.save() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index_later(self):\n return",
"def update_time(cls, key):\n key.put()",
"def every_hour(self, time, function, args=None, kwargs=None, name=None):\n if args is None:\n args = list()\n if kwargs is None:\n kwargs = dict()\n if name is None:\n ... | [
"0.59411937",
"0.57995015",
"0.56473935",
"0.5602451",
"0.558092",
"0.551876",
"0.5453459",
"0.5422525",
"0.54206413",
"0.54206413",
"0.5394929",
"0.5394929",
"0.53662395",
"0.53635",
"0.53479695",
"0.53402996",
"0.532217",
"0.53142494",
"0.5309737",
"0.5285711",
"0.52673167"... | 0.6486948 | 0 |
JavaProcess.__init__(self, class_loc, args=[]) Initializes an external Java process. | def __init__(self, config, class_loc, args=[]):
JavaProcess.config = JavaProcessConfig.configFrom_dict(config)
self._cp = self._construct_classpath_str()
self.class_loc = class_loc
self.args = args
self._process = None
self._stdout = None
self._stderr = None
LOG.debug("JavaProcess constructed for %s", self.class_loc)
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, paths):\n Process.__init__(self)\n self.paths = paths",
"def __init__(self, host=\"\", port=8432):\n Process.__init__(self)\n self.host, self.port = host, port\n self._Handler.annotator = self",
"def __init__(self):\n self._recording = None\n ... | [
"0.6975941",
"0.6958235",
"0.67394876",
"0.6490618",
"0.6321262",
"0.6161817",
"0.612476",
"0.6118696",
"0.6096931",
"0.6078772",
"0.60693926",
"0.60651165",
"0.60423166",
"0.60343724",
"0.6023563",
"0.600156",
"0.5997967",
"0.5996555",
"0.5996109",
"0.5992397",
"0.59232205",... | 0.8258955 | 0 |
we will do a bubble sort on the list and then get the 2nd element to the last | def second_largest(number_list):
for i in range(len(number_list)):
for j in range(len(number_list) - 1 - i):
if number_list[j] > number_list[j+1]:
number_list[j + 1], number_list[j] = number_list[j], number_list[j+1]
return number_list[-2] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bubbleSort(list):",
"def bubble_sort(list):\n for i in range(1, len(list) - 1):\n for j in range(len(list) - 1, i-1, -1):\n if list[j - 1] > list[j]:\n x = list[j]\n list[j] = list[j - 1]\n list[j - 1] = x\n return list",
"def bubbleSort(... | [
"0.77857566",
"0.7745999",
"0.75933444",
"0.7433549",
"0.7385789",
"0.73774844",
"0.736563",
"0.7351545",
"0.73503095",
"0.73399705",
"0.7298297",
"0.7254225",
"0.7216236",
"0.7211703",
"0.7194435",
"0.7183924",
"0.71444356",
"0.71343726",
"0.7121137",
"0.7121137",
"0.7100498... | 0.6551871 | 56 |
slick solution in python ONLY zeros = [0 for i in range(zeros_and_ones.count(0))] ones = [1 for j in range(zeros_and_ones.count(1))] return zeros + ones | def zeros_before_ones(zeros_and_ones):
index_i = 0
last_index = len(zeros_and_ones) - 1
while index_i < last_index:
if zeros_and_ones[index_i] == 1 and zeros_and_ones[last_index] == 0:
zeros_and_ones[index_i], zeros_and_ones[last_index] = zeros_and_ones[last_index], zeros_and_ones[index_i]
index_i += 1
last_index -= 1
# print(zeros_and_ones)
# TODO: NEEDS IMPROVEMENTS! zeros_and_ones | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solution2(n):\n ones = 0\n while n > 0:\n if n & 1:\n ones += 1\n n = n >> 1\n\n return 0 if ones % 2 == 0 else 1",
"def c(ixs):\n return sum(range(1, sum((i > 0 for i in ixs)) + 1))",
"def _iter_restrict(self, zeros, ones):\n inputs = list(self.inputs)\n ... | [
"0.6483679",
"0.624784",
"0.61705774",
"0.610907",
"0.6090902",
"0.6031265",
"0.59823155",
"0.59540856",
"0.59308344",
"0.59170455",
"0.5842495",
"0.5830201",
"0.5826083",
"0.5814207",
"0.578468",
"0.57763344",
"0.5771295",
"0.57675946",
"0.5759372",
"0.5745411",
"0.5724746",... | 0.6798596 | 0 |
Implements a descending exponential cooling scheme. Temperature becomes zero after all iterations have been passed. | def update_temperature(self):
self.iteration += 1
self.T = self.T0 * 0.9935**self.iteration | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def constant_temp(self, numIterations):\n return 1 + self.alpha",
"def _etaE_cool(self,x):\n return self._eta_sfr_scaling(x,'E_cool')",
"def _etaE(self,x):\n return self._etaE_cool(x) + self._etaE_hot(x)",
"def sim_alternating_exp():\n catches = 0\n for _ in range(100000):\n ... | [
"0.65226835",
"0.63014704",
"0.613545",
"0.6096842",
"0.60904115",
"0.6022001",
"0.59910226",
"0.5871977",
"0.58546734",
"0.5735474",
"0.5727299",
"0.5672892",
"0.5629865",
"0.560521",
"0.55958956",
"0.558111",
"0.5577392",
"0.5571009",
"0.5570365",
"0.5565791",
"0.5564864",
... | 0.5585291 | 15 |
Calculates new and old K. Checks and accepts better solutions than the current solution. Also sometimes accepts solutions that are worse, depending on the current temperature. | def check_solution(self, potential_solution):
old_k = self.K
new_k = potential_solution.set_K(self.len_connections)
# calculate the probability of accepting this solution
delta = new_k - old_k
if delta >= 0:
probability = 1
probability = np.exp(delta / self.T)
# pull a random number between 0 and 1 and see if we accept the solution
if random.random() < probability:
self.column1.append(self.iteration)
self.column2.append(new_k)
self.state = potential_solution
self.K = new_k
# save progress to a csv file
with open('annealing.csv', 'w', newline='') as csv_file:
fieldnames = ['Iterations', 'K']
writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
writer.writeheader()
for i, j in zip(self.column1, self.column2):
writer.writerow({'Iterations': i, 'K': j})
# update the temperature
self.update_temperature() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_k(self):\n\t\n\tself.k = -np.array([self.sth*self.cphi, self.sth*self.sphi, self.cth])\n\n\treturn",
"def obrien_fleming_cutoff(K, current_k, alpha):\n\n if not isinstance(K, int) or K < 1 or K > 10:\n raise ValueError('K must be an integer between 1 and 10.')\n\n if not isinstance(current_... | [
"0.6411429",
"0.61664015",
"0.60879153",
"0.59830314",
"0.58720684",
"0.5814098",
"0.58111423",
"0.58111423",
"0.577404",
"0.5765074",
"0.5746197",
"0.57347727",
"0.5694414",
"0.5672527",
"0.5637371",
"0.5624423",
"0.56225246",
"0.5611478",
"0.5611203",
"0.5557416",
"0.555590... | 0.0 | -1 |
Warn the user that running with nipy being imported locally is a bad idea. | def _test_local_install():
if os.getcwd() == os.sep.join(
os.path.abspath(__file__).split(os.sep)[:-2]):
import warnings
warnings.warn('Running the tests from the install directory may '
'trigger some failures') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_nuke():\n try:\n import _nuke\n return True\n except ImportError:\n return False",
"def provoke_and_handle_ImportError():\n try:\n from you import me\n except ImportError as impe:\n print(f\"Sorry! {impe}\")",
"def unavailable_importer(**kwargs):\n retur... | [
"0.59475875",
"0.5733747",
"0.5700879",
"0.56831914",
"0.56009203",
"0.5547987",
"0.54913825",
"0.5431076",
"0.5426784",
"0.53830874",
"0.53597766",
"0.53400105",
"0.53313553",
"0.53298444",
"0.52693295",
"0.5264683",
"0.5247983",
"0.5241664",
"0.5224841",
"0.5179244",
"0.517... | 0.5077109 | 29 |
Tire l'objectif d'une partie de chiffre. | def tire_objectif() -> int:
return random.randint(min_objectif, max_objectif) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def object(self):",
"def test_partie(joueur1: object,\n joueur2: object,\n tableau_invisible_joueur1: list, tableau_invisible_joueur2: list\n ):\n print(\"plateau du joueur 2 : \\n\")\n\n tour_de_jeu(joueur1, joueur2, tableau_invisible_joueur2)\n\n rafraichir... | [
"0.6027109",
"0.5971558",
"0.58855444",
"0.58450836",
"0.5830027",
"0.58068246",
"0.5640876",
"0.55412936",
"0.55015695",
"0.5419981",
"0.53639406",
"0.53315765",
"0.5311751",
"0.5300423",
"0.5263753",
"0.5260159",
"0.52363807",
"0.5175996",
"0.51674426",
"0.5153223",
"0.5149... | 0.0 | -1 |
Saves table's data source to given path | def save(self, export_path: str): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(file, table):\n pq.write_table(pa.Table.from_pandas(table), file)",
"def save(self):\r\n debug.write(\"[SourceRPG] Handling SQL Save\", 1)\r\n if self.path != \":memory:\":\r\n debug.write(\"Path is not in memory\", 2, False)\r\n if currentTurboMode is False:\r\n ... | [
"0.6399908",
"0.6323182",
"0.61869615",
"0.6044013",
"0.6044013",
"0.6044013",
"0.59645635",
"0.59101415",
"0.58439785",
"0.5820229",
"0.58036727",
"0.57980114",
"0.5796495",
"0.5790788",
"0.57840085",
"0.57607806",
"0.57270277",
"0.57178634",
"0.570963",
"0.570963",
"0.56416... | 0.582292 | 9 |
Registers all the JRPC overloaders in the jrpc server | def register_overloaders(jrpc_server: JRPCServer, receiver) -> None:
jrpc_server.register_overloader(
'Application.GetProperties', lambda server: GetPropertiesOverloader(server, receiver))
jrpc_server.register_overloader(
'Application.SetMute', lambda server: SetMuteOverloader(receiver))
jrpc_server.register_overloader(
'Application.SetVolume', lambda server: SetVolumeOverloader(receiver))
jrpc_server.register_overloader(
'Application.Quit', lambda server: ApplicationQuitOverloader(receiver))
jrpc_server.register_overloader(
'System.Hibernate', lambda server: ApplicationQuitOverloader(receiver))
jrpc_server.register_overloader(
'System.Shutdown', lambda server: ApplicationQuitOverloader(receiver))
jrpc_server.register_overloader(
'System.Suspend', lambda server: ApplicationQuitOverloader(receiver))
jrpc_server.register_overloader(
'System.GetProperties', lambda server: SystemPropertiesOverloader()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def register_rpc_proxies(self):\n for rpc_name in self.rpc_proxy_list:\n logger.debug('Registering RPC to Proxy: {}'.format(rpc_name))\n\n class RPCProxy:\n\n def __init__(self, local_session, rpc_name):\n self._local_session = local_session\n ... | [
"0.5887183",
"0.53439647",
"0.5303127",
"0.5229928",
"0.5181709",
"0.51379925",
"0.5042705",
"0.5018712",
"0.50179935",
"0.5007511",
"0.50063205",
"0.50051254",
"0.49503332",
"0.4928616",
"0.4922325",
"0.4869519",
"0.4867418",
"0.48619875",
"0.4855552",
"0.4855092",
"0.484246... | 0.78924644 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.