code stringlengths 4 4.48k | docstring stringlengths 1 6.45k | _id stringlengths 24 24 |
|---|---|---|
def get_avg(coin: str, currency: str = CURRENCY, exchange: str = 'CCCAGG') -> Optional[Dict]: <NEW_LINE> <INDENT> response = _query_cryptocompare(_URL_AVG.format( coin, currency, _format_parameter(exchange))) <NEW_LINE> if response: <NEW_LINE> <INDENT> return response['RAW'] <NEW_LINE> <DEDENT> return None | Get the average price
:param coin: symbolic name of the coin (e.g. BTC)
:param currency: short hand description of the currency (e.g. EUR)
:param exchange: exchange to use (default: 'CCCAGG')
:returns: dict of coin and currency price pairs | 625941bb07f4c71912b11341 |
def resetPosition(self): <NEW_LINE> <INDENT> self.setQuadraturePosition(0, 0) | This function resets the encoder position to 0 | 625941bb2ae34c7f2600cfeb |
def getQValue(self, state, action): <NEW_LINE> <INDENT> qvalue = 0 <NEW_LINE> value = 0 <NEW_LINE> features= self.featExtractor.getFeatures(state,action) <NEW_LINE> for key in self.getWeights(): <NEW_LINE> <INDENT> value = self.getWeights()[key] * features[key] <NEW_LINE> qvalue = value + qvalue <NEW_LINE> <DEDENT> return qvalue | Should return Q(state,action) = w * featureVector
where * is the dotProduct operator | 625941bb76d4e153a657e9ea |
def get_selected_keys(self, selection: int) -> list[str]: <NEW_LINE> <INDENT> return [k for k, b in self._lookup.items() if b & selection] | Return a list of keys for the given selection. | 625941bb57b8e32f5248335a |
def _collect_testlibs(config, server_match, client_match=[None]): <NEW_LINE> <INDENT> def expand_libs(config): <NEW_LINE> <INDENT> for lib in config: <NEW_LINE> <INDENT> sv = lib.pop('server', None) <NEW_LINE> cl = lib.pop('client', None) <NEW_LINE> yield lib, sv, cl <NEW_LINE> <DEDENT> <DEDENT> def yield_testlibs(base_configs, configs, match): <NEW_LINE> <INDENT> for base, conf in zip(base_configs, configs): <NEW_LINE> <INDENT> if conf: <NEW_LINE> <INDENT> if not match or base['name'] in match: <NEW_LINE> <INDENT> platforms = conf.get('platforms') or base.get('platforms') <NEW_LINE> if not platforms or platform.system() in platforms: <NEW_LINE> <INDENT> yield merge_dict(base, conf) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> <DEDENT> <DEDENT> libs, svs, cls = zip(*expand_libs(config)) <NEW_LINE> servers = list(yield_testlibs(libs, svs, server_match)) <NEW_LINE> clients = list(yield_testlibs(libs, cls, client_match)) <NEW_LINE> return servers, clients | Collects server/client configurations from library configurations | 625941bb8a43f66fc4b53f23 |
def filter_gdf( gdf, rel_orbit_numbers=None, footprint_overlaps=None, start_date=None, end_date=None): <NEW_LINE> <INDENT> if len(gdf) and start_date is not None: <NEW_LINE> <INDENT> mask = gdf['sensing_end'] >= start_date <NEW_LINE> gdf = gdf[mask] <NEW_LINE> <DEDENT> if len(gdf) and end_date is not None: <NEW_LINE> <INDENT> mask = gdf['sensing_start'] <= end_date <NEW_LINE> gdf = gdf[mask] <NEW_LINE> <DEDENT> if len(gdf) and rel_orbit_numbers is not None: <NEW_LINE> <INDENT> mask = gdf.apply((lambda d: d['relative_orbit_number'] in rel_orbit_numbers), axis=1) <NEW_LINE> gdf = gdf[mask] <NEW_LINE> <DEDENT> if len(gdf) and footprint_overlaps is not None: <NEW_LINE> <INDENT> mask = gdf.intersects(footprint_overlaps) <NEW_LINE> gdf = gdf[mask] <NEW_LINE> <DEDENT> return gdf | Filter S1 metadata GeoDataFrame
Parameters
----------
gdf : GeoDataFrame
S1 metadata
rel_orbit_numbers : list of int
relative orbit numbers
footprint_overlaps : shapely.geometry.Polygon
AOI polygon
start_date, end_date : datetime.datetime or datestr
date interval | 625941bb4d74a7450ccd407c |
def test_set_new(self): <NEW_LINE> <INDENT> c = Context() <NEW_LINE> c.set_new('foo', {}) <NEW_LINE> self.assertEqual(c['foo'], {}) <NEW_LINE> c.set_new('foo', 100) <NEW_LINE> self.assertEqual(c['foo'], {}) | Test setting values if not present | 625941bb004d5f362079a1f0 |
def __format_param(param): <NEW_LINE> <INDENT> bool_list = ['removemargin', 'flagshadow', 'flagstroke', 'opaqueavatar', 'darktriangles', 'darkheader', 'rankedscore'] <NEW_LINE> xp = ['xpbar', 'xpbarhex'] <NEW_LINE> int_list = ['avatarrounding', 'onlineindicator'] <NEW_LINE> res = '' <NEW_LINE> if xp[0] in param and xp[1] in param and param[xp[0]] is True and param[xp[1]] is True: <NEW_LINE> <INDENT> res += "&{}&{}".format(xp[0], xp[1]) <NEW_LINE> <DEDENT> elif xp[0] in param and xp[1] not in param and xp[0] is True: <NEW_LINE> <INDENT> res += '&{}'.format(xp[0]) <NEW_LINE> <DEDENT> for key, val in param.items(): <NEW_LINE> <INDENT> if key in bool_list and val is True: <NEW_LINE> <INDENT> res += '&{}'.format(key) <NEW_LINE> <DEDENT> if key in int_list and isinstance(val, int): <NEW_LINE> <INDENT> res += '&{}={}'.format(key, str(val)) <NEW_LINE> <DEDENT> <DEDENT> return res | Clean up the advanced parameter from generate()
:param param: the advanced parameter from generate()
:return: string of formatted parameters | 625941bb090684286d50eb9b |
def manage_existing_get_size(self, volume, existing_ref): <NEW_LINE> <INDENT> pass | Return size of volume to be managed by manage_existing.
When calculating the size, round up to the next GB.
:param volume: Cinder volume to manage
:param existing_ref: Dictionary with keys 'source-id', 'source-name'
with driver-specific values to identify a backend
storage object.
:raises: ManageExistingInvalidReference If the existing_ref doesn't
make sense, or doesn't refer to an existing backend storage
object. | 625941bb32920d7e50b28086 |
def updateModeless(self, refreshAxes=False): <NEW_LINE> <INDENT> if refreshAxes: <NEW_LINE> <INDENT> self.dd.aPanel.drawAxisLabels() <NEW_LINE> <DEDENT> r = self.limitLineMovement(self.x1, self.y1, self.x2, self.y2) <NEW_LINE> self.x1 = r[0] <NEW_LINE> self.y1 = r[1] <NEW_LINE> self.x2 = r[2] <NEW_LINE> self.y2 = r[3] <NEW_LINE> self.updateLineProfile() <NEW_LINE> self.resetAbelParameters() <NEW_LINE> self.updateMeans() | Called when Pixel Display Type (actual/normalized) is changed or when
new image is loaded. | 625941bbd486a94d0b98e004 |
def push(self): <NEW_LINE> <INDENT> self._stack.append({}) <NEW_LINE> self._cur += 1 | Push a new frame onto the stack. | 625941bb63d6d428bbe443a9 |
def get(access_token, media_id, **kwargs): <NEW_LINE> <INDENT> api = 'https://api.weixin.qq.com/cgi-bin/media/get' <NEW_LINE> params = {'access_token': access_token, 'media_id': media_id} <NEW_LINE> params.update(**kwargs) <NEW_LINE> return requests_get(api, params) | 获取临时素材 | 625941bb0c0af96317bb80a3 |
def test_reload_with_changed_fields(self): <NEW_LINE> <INDENT> class User(Document): <NEW_LINE> <INDENT> name = StringField() <NEW_LINE> number = IntField() <NEW_LINE> <DEDENT> User.drop_collection() <NEW_LINE> user = User(name="Bob", number=1).save() <NEW_LINE> user.name = "John" <NEW_LINE> user.number = 2 <NEW_LINE> self.assertEqual(user._get_changed_fields(), ['name', 'number']) <NEW_LINE> user.reload('number') <NEW_LINE> self.assertEqual(user._get_changed_fields(), ['name']) <NEW_LINE> user.save() <NEW_LINE> user.reload() <NEW_LINE> self.assertEqual(user.name, "John") | Ensures reloading will not affect changed fields | 625941bb4e696a04525c9306 |
def exclusive() -> Callable[[Observable[Observable[_T]]], Observable[_T]]: <NEW_LINE> <INDENT> from ._exclusive import exclusive_ <NEW_LINE> return exclusive_() | Performs a exclusive waiting for the first to finish before
subscribing to another observable. Observables that come in between
subscriptions will be dropped on the floor.
.. marble::
:alt: exclusive
-+---+-----+-------|
+-7-8-9-|
+-4-5-6-|
+-1-2-3-|
[ exclusive() ]
---1-2-3-----7-8-9-|
Returns:
An exclusive observable with only the results that
happen when subscribed. | 625941bb60cbc95b062c6403 |
def __eq__(self, other): <NEW_LINE> <INDENT> if not isinstance(other, PageDtoDiscoveredVendorDto): <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> return self.__dict__ == other.__dict__ | Returns true if both objects are equal | 625941bb796e427e537b047c |
def connect_JSON(config): <NEW_LINE> <INDENT> testnet = config.get('testnet', '0') <NEW_LINE> testnet = (int(testnet) > 0) <NEW_LINE> if not 'rpcport' in config: <NEW_LINE> <INDENT> config['rpcport'] = 51475 if testnet else 50051 <NEW_LINE> <DEDENT> connect = "http://%s:%s@127.0.0.1:%s"%(config['rpcuser'], config['rpcpassword'], config['rpcport']) <NEW_LINE> try: <NEW_LINE> <INDENT> result = ServiceProxy(connect) <NEW_LINE> if result.getmininginfo()['testnet'] != testnet: <NEW_LINE> <INDENT> sys.stderr.write("RPC server at "+connect+" testnet setting mismatch\n") <NEW_LINE> sys.exit(1) <NEW_LINE> <DEDENT> return result <NEW_LINE> <DEDENT> except: <NEW_LINE> <INDENT> sys.stderr.write("Error connecting to RPC server at "+connect+"\n") <NEW_LINE> sys.exit(1) | Connect to a send JSON-RPC server | 625941bb4f6381625f1148f8 |
def P_S_arrival_T_common(epi_val, evdp): <NEW_LINE> <INDENT> P_WAVE_VELOCITY = 6.10 <NEW_LINE> S_WAVE_VELOCITY = 3.55 <NEW_LINE> hypo_dist = np.sqrt(epi_val**2 + evdp**2) <NEW_LINE> P_arrival_T = hypo_dist/P_WAVE_VELOCITY <NEW_LINE> S_arrival_T = hypo_dist/S_WAVE_VELOCITY <NEW_LINE> return P_arrival_T, S_arrival_T | p and s travel time for common model | 625941bb55399d3f0558856d |
def get_url(self, url): <NEW_LINE> <INDENT> return self.session.get(url, timeout=15).json() | Flat wrapper for fetching URL directly | 625941bb10dbd63aa1bd2a68 |
def read_dict(self, where): <NEW_LINE> <INDENT> out = {} <NEW_LINE> nd = self.get_group(where) <NEW_LINE> for prpnm, prp in nd.attrs.iteritems(): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> out[prpnm] = pkl.loads(prp) <NEW_LINE> <DEDENT> except TypeError: <NEW_LINE> <INDENT> out[prpnm] = prp <NEW_LINE> <DEDENT> <DEDENT> return out | Read a dictionary object at `where`. | 625941bb6fb2d068a760ef54 |
def update_options(self, *args): <NEW_LINE> <INDENT> args = args <NEW_LINE> self.update_path() | Update path | 625941bb4c3428357757c1e4 |
def test_new_user_email_normalized(self): <NEW_LINE> <INDENT> email = "mmoraru@gGMAIL.COM" <NEW_LINE> user = get_user_model().objects.create_user(email, 'test123') <NEW_LINE> self.assertEqual(user.email, email.lower()) | Test the email for the new uesr is normalized | 625941bb45492302aab5e17a |
def update_database(self, images): <NEW_LINE> <INDENT> conn = sqlite3.connect(self.db_path) <NEW_LINE> cur = conn.cursor() <NEW_LINE> images_to_insert = [] <NEW_LINE> for image in images: <NEW_LINE> <INDENT> count_selector = "SELECT count FROM images WHERE url = '%s'" % image['url'] <NEW_LINE> current_count = cur.execute(count_selector).fetchone() <NEW_LINE> if current_count: <NEW_LINE> <INDENT> current_count = current_count[0] <NEW_LINE> new_count = current_count + image['count'] <NEW_LINE> if current_count > 1: <NEW_LINE> <INDENT> update_statement = "UPDATE images " "SET count = '%i' " "WHERE url = '%s'" % (new_count, image['url']) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> update_statement = "UPDATE images " "SET count = '%i', " "share_text = 'shares'" "WHERE url = '%s'" % (new_count, image['url']) <NEW_LINE> <DEDENT> cur.execute(update_statement) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> images_to_insert.append(image) <NEW_LINE> <DEDENT> <DEDENT> if images_to_insert: <NEW_LINE> <INDENT> insert_list = ["('%s','%s','%s')" % (i['url'], i['count'], i['share_text']) for i in images_to_insert] <NEW_LINE> insert_statement = "INSERT INTO images VALUES %s" % ','.join(insert_list) <NEW_LINE> cur.execute(insert_statement) <NEW_LINE> <DEDENT> conn.commit() | Take a list of images and update the database to reflect them
:param db_path: Path to database to update
:param images: List of image distionaries | 625941bb1b99ca400220a96b |
def send_to_model_server(path_to_model, url): <NEW_LINE> <INDENT> shutil.make_archive("/output/model", 'zip', path_to_model) <NEW_LINE> r = requests.post(url, data=open("/output/model.zip"), headers={'content-type': 'application/zip'} ) | Send an existing model to an external server.
Parameters:
----------
path_to_model: str
Path from which the model will be loaded
url: str
Url to which the model will be send a zip file | 625941bb7cff6e4e8111783f |
def get_test_descriptors(): <NEW_LINE> <INDENT> resp = requests.get(env.test_descriptors_api, timeout=env.timeout, headers=env.header) <NEW_LINE> env.set_return_header(resp.headers) <NEW_LINE> if resp.status_code != 200: <NEW_LINE> <INDENT> LOG.debug("Request for test descriptors returned with " + (str(resp.status_code))) <NEW_LINE> return False, [] <NEW_LINE> <DEDENT> descriptors = json.loads(resp.text) <NEW_LINE> descriptors_res = [] <NEW_LINE> for descriptor in descriptors: <NEW_LINE> <INDENT> platforms = "" <NEW_LINE> for platform in descriptor['testd']['service_platforms']: <NEW_LINE> <INDENT> print (platform) <NEW_LINE> if platforms == "": <NEW_LINE> <INDENT> platforms = platform <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> platforms = platforms + "," + platform <NEW_LINE> <DEDENT> <DEDENT> dic = {'uuid': descriptor['uuid'], 'name': descriptor['testd']['name'], 'vendor': descriptor['testd']['vendor'], 'version': descriptor['testd']['version'], 'platforms': platforms, 'status': descriptor['status'], 'updated_at': descriptor['updated_at']} <NEW_LINE> LOG.debug(str(dic)) <NEW_LINE> descriptors_res.append(dic) <NEW_LINE> <DEDENT> return True, descriptors_res | Returns info on all available test descriptors.
:returns: A tuple. [0] is a bool with the result. [1] is a list of
dictionaries. Each dictionary contains a test descriptor. | 625941bbbaa26c4b54cb0fdd |
def __init__(self, lifespan=None): <NEW_LINE> <INDENT> BaseWorld.__init__(self, lifespan) <NEW_LINE> self.name = 'grid_1D_chase' <NEW_LINE> print("Entering", self.name) <NEW_LINE> self.size = 7 <NEW_LINE> self.n_sensors = self.size + 2 * (self.size - 1) <NEW_LINE> self.n_actions = 2 * (self.size - 1) <NEW_LINE> self.reward = 0. <NEW_LINE> self.action = np.zeros(self.n_actions) <NEW_LINE> self.jump_fraction = .1 <NEW_LINE> self.energy = 0. <NEW_LINE> self.energy_cost = 1e-2 <NEW_LINE> self.sensors = np.zeros(self.n_sensors) <NEW_LINE> self.position = 2 <NEW_LINE> self.target_position = 1 <NEW_LINE> self.visualize_interval = 1e6 | Initialize the world.
Parameters
----------
lifespan : int
The number of time steps to continue the world. | 625941bb6fece00bbac2d5f6 |
def generate_timestamp(): <NEW_LINE> <INDENT> now = datetime.datetime.utcnow() <NEW_LINE> ts = now.strftime('%Y-%m-%dT%H:%M:%SZ') <NEW_LINE> return ts | Generates timestamp of the format 2014-08-18T12:00:00Z. | 625941bb26238365f5f0ed24 |
def calc_last_modified(request, *args, **kwargs): <NEW_LINE> <INDENT> assert "cache_name" in kwargs, "Must specify cache_name as a keyword arg." <NEW_LINE> try: <NEW_LINE> <INDENT> cache = get_cache(kwargs["cache_name"]) <NEW_LINE> assert isinstance(cache, FileBasedCache) or isinstance(cache, LocMemCache), "requires file-based or mem-based cache." <NEW_LINE> <DEDENT> except InvalidCacheBackendError: <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> key = django_get_cache_key(request, cache=cache) <NEW_LINE> if key is None or not cache.has_key(key): <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> if isinstance(cache, FileBasedCache): <NEW_LINE> <INDENT> fname = cache._key_to_file(cache.make_key(key)) <NEW_LINE> if not os.path.exists(fname): <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> last_modified = datetime.datetime.fromtimestamp(os.path.getmtime(fname)) <NEW_LINE> <DEDENT> elif isinstance(cache, LocMemCache): <NEW_LINE> <INDENT> creation_time = cache._expire_info[cache.make_key(key)] - settings.CACHE_TIME <NEW_LINE> last_modified = datetime.datetime.fromtimestamp(creation_time) <NEW_LINE> <DEDENT> return last_modified | Returns the file's modified time as the last-modified date | 625941bb293b9510aa2c3152 |
def build_params(self, codestring): <NEW_LINE> <INDENT> params = super(AztecCode._Renderer, self).build_params(codestring) <NEW_LINE> cbbox = self._code_bbox(codestring) <NEW_LINE> params['bbox'] = '%d %d %d %d' %(self._boundingbox(cbbox, cbbox)) <NEW_LINE> return params | >>> AztecCode._Renderer({}).build_params('abcd')
{'yscale': 1.0, 'codestring': '<61626364>', 'bbox': '0 0 30 30', 'codetype': {}, 'xscale': 1.0, 'options': '<>'} | 625941bbe8904600ed9f1de3 |
def print_sorted(self): <NEW_LINE> <INDENT> print(sorted(self)) | Prints the list in ascending order | 625941bbd10714528d5ffb9a |
def __init__(self, parent: Optional['SymbolNode'], character: int): <NEW_LINE> <INDENT> self.__children: CharReferenceMap = None <NEW_LINE> self.__token_type: TokenType = TokenType.Unknown <NEW_LINE> self.__valid: bool = None <NEW_LINE> self.__ancestry: str = None <NEW_LINE> self.__parent: SymbolNode = parent <NEW_LINE> self.__character: int = character | Constructs a SymbolNode with the given parent, representing the given character.
:param parent: This node's parent
:param character: This node's associated character. | 625941bb07d97122c4178745 |
def get_damage(unit): <NEW_LINE> <INDENT> return unit[1] | a = make_unit( 'zerg', 12 )
get_catchphrase(a)
'zerg'
get_damage(a)
12 | 625941bbbde94217f3682cb5 |
def get_update_list(fp_update): <NEW_LINE> <INDENT> update_list = [] <NEW_LINE> for item in fp_update: <NEW_LINE> <INDENT> temp = item.strip().split() <NEW_LINE> temp_item = [temp[0], temp[5], temp[-1]] <NEW_LINE> update_list.append(temp_item) <NEW_LINE> <DEDENT> return update_list | Divide the fp update based on sync-client | 625941bb187af65679ca4fd7 |
def parse_enemies(current_chunk): <NEW_LINE> <INDENT> global enemies <NEW_LINE> global frenemy <NEW_LINE> current_chunk = strip_ansi(current_chunk) <NEW_LINE> m = re_enemies.search(current_chunk) <NEW_LINE> enemies = m.groups()[0].split("\r\n") <NEW_LINE> c.echo(f"enemies: {' '.join(enemies)}") <NEW_LINE> frenemy.notify("enemies", enemies) | You have the following enemies:
Farrah
Mezghar
You have currently used 2 enemy slots of your 20 maximum. | 625941bb15fb5d323cde09c4 |
def test_get_node_health_with_invalid_id(self): <NEW_LINE> <INDENT> request_id = "xxxxxxxxxxx" <NEW_LINE> self.assertRaises( DiscoveryError, Discovery.get_node_health, request_id) | Check for node health backend url with invalid id. | 625941bb26068e7796caeb93 |
def join(): <NEW_LINE> <INDENT> t = threading.Thread(name = 'process', target= worker2, args=(3,)) <NEW_LINE> t.start() <NEW_LINE> t.join() <NEW_LINE> t2 = threading.Thread(name = 'process2', target= worker2, args=(3,)) <NEW_LINE> t2.start() | 阻塞线程 | 625941bb30c21e258bdfa355 |
def brand_info_counts(self): <NEW_LINE> <INDENT> return { 'no_brand': self.active_issues().filter(no_brand=True).count(), 'unknown': self.active_issues().filter(no_brand=False, brand__isnull=True).count(), } | Simple method for the UI to use, as the UI can't pass parameters. | 625941bb91af0d3eaac9b8cf |
def classFactory(iface): <NEW_LINE> <INDENT> from .ImportPhotos import ImportPhotos <NEW_LINE> return ImportPhotos(iface) | Load ImportPhotos class from file ImportPhotos.
:param iface: A QGIS interface instance.
:type iface: QgsInterface | 625941bb63b5f9789fde6fa0 |
def eta_func(r_list, param_dict, func_type='well-behaved', scaled=False): <NEW_LINE> <INDENT> if func_type == 'power law': <NEW_LINE> <INDENT> rScale, rc, etaScale, betaDelta = get_eta_powerlaw_params(param_dict) <NEW_LINE> r = np.array(r_list) <NEW_LINE> w = (r-rc)/rScale <NEW_LINE> return etaScale*w**(betaDelta) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> rScale, rc, etaScale, lambdaH, B, F = get_eta_params(param_dict) <NEW_LINE> r = np.array(r_list) <NEW_LINE> w = (r-rc)/rScale <NEW_LINE> if func_type == 'truncated': <NEW_LINE> <INDENT> eta = (etaScale*np.exp(-lambdaH/w) * (B+(1/w)) ** (-F+B*lambdaH)) <NEW_LINE> if scaled: <NEW_LINE> <INDENT> eta = np.exp(-B**2*w*lambdaH)*eta <NEW_LINE> <DEDENT> return eta <NEW_LINE> <DEDENT> elif func_type == 'well-behaved': <NEW_LINE> <INDENT> eta = (etaScale*np.exp(-B*F*w-lambdaH/w) * w ** (-B*lambdaH+F)) <NEW_LINE> if scaled: <NEW_LINE> <INDENT> eta = np.exp(B**2*w*lambdaH)*eta <NEW_LINE> <DEDENT> return eta <NEW_LINE> <DEDENT> elif func_type == 'pitchfork': <NEW_LINE> <INDENT> exponential_piece = (np.exp(-(F/w)-(lambdaH/(2*w**2)) - np.sqrt(B) * F * np.arctan(np.sqrt(B)*w))) <NEW_LINE> powerlaw_piece = (w**(-B*lambdaH) * (1+B*w**2) ** (B*lambdaH/2)) <NEW_LINE> return etaScale*exponential_piece*powerlaw_piece <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> print("functional type not recognized,", " using 'well-behaved' form") <NEW_LINE> eta = (etaScale*np.exp(-B*F*w-lambdaH/w) * w ** (-B*lambdaH+F)) <NEW_LINE> return eta | Nonlinear scaling variable function determined from
the flow equations of the disorder, w, and field, h
Input:
r_list - list of r values
param_dict - dictionary of parameters on which eta(r) is dependent
func_type - which form of eta(r) to use. Options:
'power law' - eta(r) derived with dw/dl = (1/nu) w
'truncated' - eta(r) derived with dw/dl = w^2 + B w^3
'well-behaved' - eta(r) derived with dw/dl = w^2 / (1 + B w)
'pitchfork' - eta(r) derived with dw/dl = w^3 + B w^5
scaled - flag for whether to use the eta derived with the
'truncated' dw/dl scaled for comparison with the
'well-behaved' form at small r
Output:
eta(r) values for the given inputs | 625941bb7cff6e4e81117840 |
def main(): <NEW_LINE> <INDENT> T = int(input()) <NEW_LINE> for case in range(T): <NEW_LINE> <INDENT> num = int(input()) <NEW_LINE> solve(num, 1, int(math.sqrt(num * 2))) | 이게 최대 n 값 찾기
x = n * (2 * a1 + n - 1) / 2
x = n * (2 * a1 + -(n - 1)) / 2 | 625941bb2ae34c7f2600cfec |
def test_edit_full(self) -> None: <NEW_LINE> <INDENT> self.submit_form('edit_address', 'input_id_submit', send_form_keys={ 'id_address_line_1': '2986 Heron Way', 'id_address_line_2': 'Attn. Anna Freytag', 'id_city': 'Portland', 'id_zip': '97205', 'id_state': 'Oregon' }, select_dropdowns={ 'id_country': ('US',) }) <NEW_LINE> self.assert_url_equal('edit_address', 'Check that we stayed on the right page') <NEW_LINE> address = self.user.alumni.address <NEW_LINE> self.assertEqual(address.address_line_1, '2986 Heron Way') <NEW_LINE> self.assertEqual(address.address_line_2, 'Attn. Anna Freytag') <NEW_LINE> self.assertEqual(address.city, 'Portland') <NEW_LINE> self.assertEqual(address.zip, '97205') <NEW_LINE> self.assertEqual(address.state, 'Oregon') <NEW_LINE> self.assertEqual(address.country.name, 'United States of America') | Tests that adding a full address works | 625941bb85dfad0860c3ad13 |
def receive_weather(self, weather_id): <NEW_LINE> <INDENT> path = self._compose_path("integrations/weather/{0}".format(weather_id)) <NEW_LINE> return self._get(path) | Get data from the Adafruit IO Weather Forecast Service
NOTE: This service is avaliable to Adafruit IO Plus subscribers only.
:param int weather_id: ID for retrieving a specified weather record. | 625941bb4c3428357757c1e5 |
def resize(self, size): <NEW_LINE> <INDENT> return type(self)(self._data.name, size=size, index=self._index) | Returns a new copy of this font in a different size | 625941bb2c8b7c6e89b3567d |
def _stepwise_interp(xi, yi, x): <NEW_LINE> <INDENT> end = np.atleast_1d(xi.searchsorted(x)) <NEW_LINE> end[end == 0] += 1 <NEW_LINE> start = end - 1 <NEW_LINE> end[end == len(xi)] -= 1 <NEW_LINE> try: <NEW_LINE> <INDENT> xi_smallest_diff = 20 * np.finfo(xi.dtype).resolution <NEW_LINE> <DEDENT> except ValueError: <NEW_LINE> <INDENT> xi_smallest_diff = 0 <NEW_LINE> <DEDENT> try: <NEW_LINE> <INDENT> x_smallest_diff = 20 * np.finfo(x.dtype).resolution <NEW_LINE> <DEDENT> except ValueError: <NEW_LINE> <INDENT> x_smallest_diff = 0 <NEW_LINE> <DEDENT> smallest_diff = max(x_smallest_diff, xi_smallest_diff) <NEW_LINE> equal_or_just_below = xi[end] - x < smallest_diff <NEW_LINE> start[equal_or_just_below] = end[equal_or_just_below] <NEW_LINE> start = np.reshape(start, np.shape(x)) <NEW_LINE> return yi[start] | Step-wise interpolate (or extrapolate) (xi, yi) values to x positions.
Given a set of N ``(x, y)`` points, provided in the *xi* and *yi* arrays,
this will calculate ``y``-coordinate values for a set of M
``x``-coordinates provided in the *x* array, using step-wise (zeroth-order)
interpolation and extrapolation.
The input *x* coordinates are compared to the fixed *xi* values, and the
largest *xi* value smaller than or approximately equal to each *x* value is
selected. The corresponding *yi* value is then returned. For *x* values
below the entire set of *xi* values, the smallest *xi* value is selected.
The steps of the interpolation therefore start at each *xi* value and
extends to the right (above it) until the next bigger *xi*, except for the
first step, which extends to the left (below it) as well, and the last
step, which extends until positive infinity.
Parameters
----------
xi : array, shape (N,)
Array of fixed x-coordinates, sorted in ascending order and with no
duplicate values
yi : array, shape (N,)
Corresponding array of fixed y-coordinates
x : float or array, shape (M,)
Array of x-coordinates at which to do interpolation of y-values
Returns
-------
y : float or array, shape (M,)
Array of interpolated y-values
Notes
-----
The equality check of *x* values is approximate on purpose, to handle some
degree of numerical imprecision in floating-point values. This is important
for step-wise interpolation, as there are potentially large discontinuities
in *y* at the *xi* values, which makes it sensitive to small mismatches in
*x*. For continuous interpolation (linear and up) this is unnecessary. | 625941bb45492302aab5e17b |
def stop_vm(self, vmname): <NEW_LINE> <INDENT> sms = ServiceManagementService(self.__subscription, self.__certSelection) <NEW_LINE> result = sms.shutdown_role(self.getVmService(vmname), self.getVmService(vmname), vmname) <NEW_LINE> if result: <NEW_LINE> <INDENT> return self.wait_operation(result.request_id) <NEW_LINE> <DEDENT> return False | starts vm role | 625941bb9f2886367277a74b |
def ssr(self, x, y): <NEW_LINE> <INDENT> J = np.ones((y.shape[0], y.shape[0])) <NEW_LINE> G = np.linalg.inv(np.dot(x.T, x)) <NEW_LINE> H = np.dot(x, np.dot(G, x.T)) <NEW_LINE> Qr = H - (1/y.shape[0])*J <NEW_LINE> SSR = np.dot(y.T, np.dot(Qr, y)) <NEW_LINE> return SSR | Compute the regression sum of squares.
Parameters:
- - - - -
x: feature matrix
y: response matrix | 625941bbde87d2750b85fc49 |
def trainer(self, classes=None): <NEW_LINE> <INDENT> self.logger.info('Running trainer method') <NEW_LINE> if classes is None: <NEW_LINE> <INDENT> classes = ['ok'] <NEW_LINE> <DEDENT> try: <NEW_LINE> <INDENT> self.cleaned = self.data.copy() <NEW_LINE> self.cleaned = self.data[self.selection + self.codes] <NEW_LINE> self.cleaned = self.cleaned.dropna(how='any') <NEW_LINE> for col in self.categories: <NEW_LINE> <INDENT> encoder = LabelEncoder() <NEW_LINE> encoder.fit(self.cleaned[col]) <NEW_LINE> self.cleaned.loc[:, col] = encoder.transform(self.cleaned.loc[:, col]) <NEW_LINE> <DEDENT> self.target_encoder.fit(self.cleaned['target']) <NEW_LINE> self.cleaned['target'] = self.target_encoder.transform(self.cleaned['target']) <NEW_LINE> bin_true = self.target_encoder.transform(classes) <NEW_LINE> targets_numeric = [1 if x in bin_true else 0 for x in self.cleaned['target']] <NEW_LINE> self.cleaned['target'] = targets_numeric <NEW_LINE> self.cleaned.drop('respondent_id', axis=1, inplace=True) <NEW_LINE> assert self.cleaned.shape[0] > 0 <NEW_LINE> <DEDENT> except AssertionError: <NEW_LINE> <INDENT> self.logger.error('self.cleaned did not return any rows') <NEW_LINE> raise <NEW_LINE> <DEDENT> except Exception: <NEW_LINE> <INDENT> self.logger.error('Error while running trainer method') <NEW_LINE> raise | Prepare the data for training | 625941bb94891a1f4081b963 |
def optimize(self, network, data_X, data_Y): <NEW_LINE> <INDENT> optimize_start_time = time.time() <NEW_LINE> indexes = np.arange(len(data_X)) <NEW_LINE> if self.verbosity > 0: <NEW_LINE> <INDENT> c = network.cost(data_X, data_Y) <NEW_LINE> print("Cost before epochs: {}".format(c)) <NEW_LINE> <DEDENT> for epoch in range(self.n_epochs): <NEW_LINE> <INDENT> epoch_start_time = time.time() <NEW_LINE> np.random.shuffle(indexes) <NEW_LINE> shuffle_X = np.asarray([data_X[i] for i in indexes]) <NEW_LINE> shuffle_Y = np.asarray([data_Y[i] for i in indexes]) <NEW_LINE> mdiv = len(data_X) // self.mini_batch_size <NEW_LINE> for m in range(mdiv): <NEW_LINE> <INDENT> mb_start_time = time.time() <NEW_LINE> mini_X = shuffle_X[m*self.mini_batch_size:(m+1)*self.mini_batch_size] <NEW_LINE> mini_Y = shuffle_Y[m*self.mini_batch_size:(m+1)*self.mini_batch_size] <NEW_LINE> if self.n_threads > 1: <NEW_LINE> <INDENT> self.cost_gradient_parallel(network, mini_X, mini_Y) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.dc_db, self.dc_dq, self.dc_dr, self.dc_dn, self.dc_dm = network.cost_gradient(mini_X, mini_Y) <NEW_LINE> <DEDENT> self.weight_update_func(network) <NEW_LINE> if self.alpha_decay is not None: <NEW_LINE> <INDENT> self.alpha *= 1.0 - self.alpha_decay <NEW_LINE> <DEDENT> if self.verbosity > 1 and m % self.cost_freq == 0: <NEW_LINE> <INDENT> c = network.cost(data_X, data_Y) <NEW_LINE> print("Cost at epoch {} mini-batch {}: {:g}".format(epoch, m, c)) <NEW_LINE> sys.stdout.flush() <NEW_LINE> <DEDENT> elif self.verbosity == 1 and m % self.cost_freq == 0: <NEW_LINE> <INDENT> c = network.cost(mini_X, mini_Y) <NEW_LINE> mt = time.time() - mb_start_time <NEW_LINE> emt = mt * (mdiv-1 - m) <NEW_LINE> print("Estimated cost at epoch {:2d} mini-batch {:4d}: {:.6f} mini-batch time: {:.2f} estimated epoch time remaining: {:.2f}".format( epoch, m, c, mt, emt)) <NEW_LINE> sys.stdout.flush() <NEW_LINE> <DEDENT> <DEDENT> if self.verbosity > 0: <NEW_LINE> <INDENT> c = network.cost(data_X, data_Y) <NEW_LINE> print("Cost after epoch {}: {:g}".format(epoch, c)) <NEW_LINE> print("Epoch time: {:g} s".format(time.time() - epoch_start_time)) <NEW_LINE> sys.stdout.flush() <NEW_LINE> <DEDENT> <DEDENT> if self.verbosity > 0: <NEW_LINE> <INDENT> c = network.cost(data_X, data_Y) <NEW_LINE> print("\n\nCost after optimize run: {:g}".format(c)) <NEW_LINE> print("Optimize run time: {:g} s".format(time.time() - optimize_start_time)) <NEW_LINE> sys.stdout.flush() <NEW_LINE> <DEDENT> return network | :return: optimized network | 625941bbd164cc6175782c08 |
def talk_m10_02_x21(): <NEW_LINE> <INDENT> ClearNpcMenuResults() <NEW_LINE> if GetEventFlag(102181) != 0: <NEW_LINE> <INDENT> assert talk_m10_02_x23() <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> assert talk_m10_02_x22() <NEW_LINE> <DEDENT> """State 4: End state""" <NEW_LINE> return 0 | Retired fire prevention woman 1: Conversation | 625941bb8c3a873295158279 |
def isLoading(self): <NEW_LINE> <INDENT> return self.__isLoading | Public method to get the loading state.
@return flag indicating the loading state (boolean) | 625941bbcb5e8a47e48b7969 |
def put_inst(self, byte): <NEW_LINE> <INDENT> self._inst(byte) | Write an instruction byte. | 625941bb26068e7796caeb94 |
def order_limit_sell(self, disable_validation=False, timeInForce=TIME_IN_FORCE_GTC, **params): <NEW_LINE> <INDENT> params.update({ 'side': SIDE_SELL }) <NEW_LINE> return self.order_limit(disable_validation=disable_validation, timeInForce=timeInForce, **params) | Send in a new limit sell order
:param symbol: required
:type symbol: str
:param quantity: required
:type quantity: decimal
:param price: required
:type price: decimal
:param timeInForce: default Good till cancelled
:type timeInForce: enum
:param newClientOrderId: A unique id for the order. Automatically generated if not sent.
:type newClientOrderId: str
:param stopPrice: Used with stop orders
:type stopPrice: decimal
:param icebergQty: Used with iceberg orders
:type icebergQty: decimal
:param disable_validation: disable client side order validation, default False
:type disable_validation: bool
:returns: API response
.. code-block:: python
{
"symbol":"LTCBTC",
"orderId": 1,
"clientOrderId": "myOrder1" # Will be newClientOrderId
"transactTime": 1499827319559
}
:raises: BinanceResponseException, BinanceAPIException, BinanceOrderException, BinanceOrderMinAmountException, BinanceOrderMinPriceException, BinanceOrderMinTotalException, BinanceOrderUnknownSymbolException, BinanceOrderInactiveSymbolException | 625941bb0a366e3fb873e6d2 |
def find_or_create(community, teamJSON): <NEW_LINE> <INDENT> if 'name' in teamJSON: <NEW_LINE> <INDENT> return TeamService.find_by_name(community, teamJSON['name']) <NEW_LINE> <DEDENT> elif 'goalkeeper' in teamJSON and 'forward' in teamJSON: <NEW_LINE> <INDENT> gk_id = teamJSON['goalkeeper'] <NEW_LINE> fw_id = teamJSON['forward'] <NEW_LINE> return TeamService.find_by_player_ids(community, gk_id, fw_id) <NEW_LINE> <DEDENT> return None | Find team using provided team json: by name or by players. | 625941bbfbf16365ca6f6078 |
def testProcess(self): <NEW_LINE> <INDENT> use_context = True <NEW_LINE> conn0, child_conn0 = mp.Pipe() <NEW_LINE> conn1, child_conn1 = mp.Pipe() <NEW_LINE> if use_context: <NEW_LINE> <INDENT> context = mp.get_context("fork") <NEW_LINE> proc0 = context.Process(target=worker, args=(child_conn0,)) <NEW_LINE> proc1 = context.Process(target=worker, args=(child_conn1,)) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> proc0 = mp.Process(target=worker, args=(child_conn0,)) <NEW_LINE> proc1 = mp.Process(target=worker, args=(child_conn1,)) <NEW_LINE> <DEDENT> proc0.start() <NEW_LINE> proc1.start() <NEW_LINE> conn0.recv() <NEW_LINE> conn1.recv() <NEW_LINE> conn0.send(COMMAND_ACTION) <NEW_LINE> conn1.send(COMMAND_ACTION) <NEW_LINE> obs0 = conn0.recv() <NEW_LINE> obs1 = conn1.recv() <NEW_LINE> screen0 = obs0["screen"] <NEW_LINE> self.assertEqual( (84,84,3), screen0.shape ) <NEW_LINE> screen1 = obs1["screen"] <NEW_LINE> self.assertEqual( (84,84,3), screen1.shape ) <NEW_LINE> conn0.send(COMMAND_TERMINATE) <NEW_LINE> conn1.send(COMMAND_TERMINATE) | env_dummy = rodentia.Environment(width=84, height=84,
bg_color=[0.0, 0.0, 0.0])
env_dummy.close()
env_dummy = None | 625941bba934411ee3751555 |
def _expr(self): <NEW_LINE> <INDENT> expr_value = self._or() <NEW_LINE> while self._accept('XOR'): <NEW_LINE> <INDENT> return self.graph.addOperator('XOR', leftNode=expr_value, rightNode=self._expr(), side=self.side) <NEW_LINE> <DEDENT> return expr_value | <expr> ::= <or> {'^' <expr>} | 625941bbab23a570cc25003a |
def t350190_x14(): <NEW_LINE> <INDENT> Quit() <NEW_LINE> return 0 | State 0 | 625941bbb57a9660fec3373b |
def _createProtoQuery(self): <NEW_LINE> <INDENT> protoObj = LeveldbServerMessages.ActualData() <NEW_LINE> protoObj.timestamp = arrow.now().timestamp <NEW_LINE> protoObj.type = LeveldbServerMessages.ActualData.QUERY <NEW_LINE> return protoObj | helper method that creates the LeveldbServerMessages.ActualData object for us, sets the timestamp
and the type, and then returns it for us
this is for a ServerQuery
@return a ActualData protobuf object | 625941bb92d797404e304044 |
def test_check_failure(self): <NEW_LINE> <INDENT> results = Run(["grep", "--asdfghjk"])() <NEW_LINE> results = Check(AssertExitFailure())(results) <NEW_LINE> self.assertEqual(results.returncode, 0) | Check should set results to successful by asserting exit failure. | 625941bb4f88993c3716bf28 |
def astimezone(self, tz=LOCAL): <NEW_LINE> <INDENT> if tz is None: <NEW_LINE> <INDENT> tz = LOCAL <NEW_LINE> <DEDENT> tz = parser.get_timezone(tz) <NEW_LINE> return self.datetime.astimezone(tz) | Return datetime shifted to timezone `tz`.
Note:
This returns a native datetime object.
Args:
tz (None|str|tzinfo, optional): Timezone to shift to. Defaults to `"local"` which uses
the local timezone.
Returns:
:class:`datetime` | 625941bb63f4b57ef0000fdb |
def generate_template(tmpl, dest, config): <NEW_LINE> <INDENT> with open(tmpl) as tmpl: <NEW_LINE> <INDENT> with open(dest, 'w') as dest: <NEW_LINE> <INDENT> dest.write(render_template(tmpl.read(), config)) | generate file
| 625941bb9c8ee82313fbb630 |
def seg_ctc_ent_cost(out, targets, sizes, target_sizes, uni_rate=1.5): <NEW_LINE> <INDENT> Time = out.size(0) <NEW_LINE> loss_func = seg_ctc_ent_loss_log <NEW_LINE> offset = 0 <NEW_LINE> batch = target_sizes.size(0) <NEW_LINE> uniform_mask = Variable(T.zeros(Time, batch).type(byteX)) <NEW_LINE> for index, (target_size, size) in enumerate(zip(target_sizes, sizes)): <NEW_LINE> <INDENT> offset += target_size.item() <NEW_LINE> uni_length = int(uni_rate * (size.data.item() / (target_size.data.item() + 1))) <NEW_LINE> uniform_mask[-uni_length:, index] = 1 <NEW_LINE> <DEDENT> if not cuda: <NEW_LINE> <INDENT> H, costs = loss_func(out.cpu(), sizes.data.type(longX), targets, target_sizes.data.type(longX), uniform_mask) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> H, costs = loss_func(out, sizes.data.type(longX), targets, target_sizes.data.type(longX), uniform_mask) <NEW_LINE> <DEDENT> return H, costs | out = out.cpu()
targets = targets.cpu()
sizes = sizes.cpu()
target_sizes = target_sizes.cpu() | 625941bbcdde0d52a9e52eea |
def _find_existing_inputs(in_bam): <NEW_LINE> <INDENT> sr_file = "%s-sr.bam" % os.path.splitext(in_bam)[0] <NEW_LINE> disc_file = "%s-disc.bam" % os.path.splitext(in_bam)[0] <NEW_LINE> if utils.file_exists(sr_file) and utils.file_exists(disc_file): <NEW_LINE> <INDENT> return in_bam, sr_file, disc_file <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return None, None, None | Check for pre-calculated split reads and discordants done as part of alignment streaming.
| 625941bbff9c53063f47c0b0 |
def repeat_last_operation(calc): <NEW_LINE> <INDENT> if calc['history']: <NEW_LINE> <INDENT> return calc['history'][-1][-1] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return None | Return passed calculator's last operation result. | 625941bb30bbd722463cbc7e |
def filter_by_regex(self, kind=None, value=None, exclude=False): <NEW_LINE> <INDENT> self.loggit.debug('Filtering indices by regex') <NEW_LINE> if kind not in [ 'regex', 'prefix', 'suffix', 'timestring' ]: <NEW_LINE> <INDENT> raise ValueError('{0}: Invalid value for kind'.format(kind)) <NEW_LINE> <DEDENT> if value == 0: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> elif not value: <NEW_LINE> <INDENT> raise ValueError( '{0}: Invalid value for "value". ' 'Cannot be "None" type, empty, or False' ) <NEW_LINE> <DEDENT> if kind == 'timestring': <NEW_LINE> <INDENT> regex = settings.regex_map()[kind].format(utils.get_date_regex(value)) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> regex = settings.regex_map()[kind].format(value) <NEW_LINE> <DEDENT> self.empty_list_check() <NEW_LINE> pattern = re.compile(regex) <NEW_LINE> for index in self.working_list(): <NEW_LINE> <INDENT> self.loggit.debug('Filter by regex: Index: {0}'.format(index)) <NEW_LINE> match = pattern.search(index) <NEW_LINE> if match: <NEW_LINE> <INDENT> self.__excludify(True, exclude, index) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.__excludify(False, exclude, index) | Match indices by regular expression (pattern).
:arg kind: Can be one of: ``suffix``, ``prefix``, ``regex``, or
``timestring``. This option defines what kind of filter you will be
building.
:arg value: Depends on `kind`. It is the strftime string if `kind` is
``timestring``. It's used to build the regular expression for other
kinds.
:arg exclude: If `exclude` is `True`, this filter will remove matching
indices from `indices`. If `exclude` is `False`, then only matching
indices will be kept in `indices`.
Default is `False` | 625941bb50812a4eaa59c1df |
def ll_copyfile(self, src, dst, *, follow_symlinks=True): <NEW_LINE> <INDENT> if shutil._samefile(src, dst): <NEW_LINE> <INDENT> raise shutil.SameFileError("{!r} and {!r} are the same file".format(src, dst)) <NEW_LINE> <DEDENT> for fn in [src, dst]: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> st = os.stat(fn) <NEW_LINE> <DEDENT> except OSError: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> if shutil.stat.S_ISFIFO(st.st_mode): <NEW_LINE> <INDENT> raise shutil.SpecialFileError("`%s` is a named pipe" % fn) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> if not follow_symlinks and os.path.islink(src): <NEW_LINE> <INDENT> os.symlink(os.readlink(src), dst) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> size = os.stat(src).st_size <NEW_LINE> with open(src, 'rb') as fsrc: <NEW_LINE> <INDENT> with open(dst, 'wb') as fdst: <NEW_LINE> <INDENT> self.copyfileobj(fsrc, fdst, total=size) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> return dst | Copy data from src to dst.
If follow_symlinks is not set and src is a symbolic link, a new
symlink will be created instead of copying the file it points to. | 625941bb3346ee7daa2b2c25 |
def generateRandomKey(): <NEW_LINE> <INDENT> key = list(LETTERS) <NEW_LINE> random.shuffle(key) <NEW_LINE> return ''.join(key) | Generate and return a random encryption key. | 625941bbd18da76e2353238d |
def test_approx_freq_pattern_finder(self): <NEW_LINE> <INDENT> for DNA, pat_len, dist, freq in self.known_approx_freq: <NEW_LINE> <INDENT> result = freq_finder.find_most_approx_freq(DNA, pat_len, dist) <NEW_LINE> self.assertCountEqual(freq, result) | Most-frequent approximate patterns should be found correctly | 625941bbe1aae11d1e749b6f |
def predict(image_path, model, topk=5): <NEW_LINE> <INDENT> model.eval() <NEW_LINE> img = process_image(image_path) <NEW_LINE> img = torch.from_numpy(np.array(img)).float() <NEW_LINE> img = img.to(device) <NEW_LINE> img.unsqueeze_(0) <NEW_LINE> output = model.forward(img) <NEW_LINE> probs, classes = torch.exp(output).topk(topk) <NEW_LINE> probs = probs.cpu() <NEW_LINE> probs = probs.detach().numpy()[0] <NEW_LINE> classes = classes.cpu() <NEW_LINE> classes = classes.numpy()[0] <NEW_LINE> return probs, classes | Predict the class (or classes) of an image using a trained deep learning model.
| 625941bb6fb2d068a760ef55 |
def _create_hash(self): <NEW_LINE> <INDENT> sha = hashlib.sha256() <NEW_LINE> for index in self.collect_package_indices(): <NEW_LINE> <INDENT> sha.update(index.encode()) <NEW_LINE> <DEDENT> return sha.hexdigest()[:32] | Creates a hash based on the configuration of this Source.
The hash should uniquely identify a source configuration,
without having to store a massive string. | 625941bb090684286d50eb9c |
def PlotResult(model,x_test,y_test): <NEW_LINE> <INDENT> x = [i+1 for i in range(len(y_test))][:100] <NEW_LINE> y_pred = model.predict(x_test) <NEW_LINE> plt.rcParams['font.family'] = ['sans-serif'] <NEW_LINE> plt.rcParams['font.sans-serif'] = ['SimHei'] <NEW_LINE> fig = plt.figure(figsize=(12,6)) <NEW_LINE> plt.plot(x,y_test[:100],c='green',label='y_true') <NEW_LINE> plt.plot(x,y_pred[:100],c='red',label='y_pred') <NEW_LINE> plt.legend() <NEW_LINE> plt.xlabel("预测\真实") <NEW_LINE> plt.ylabel("值大小") <NEW_LINE> plt.title("预测值与真实值变化趋势图") <NEW_LINE> plt.show() | 预测值\真实值可视化. | 625941bb925a0f43d2549d2f |
def upload_test_results(self): <NEW_LINE> <INDENT> project_id = self.config_dict.get_config('project_id') <NEW_LINE> self.qtest_project_id = project_id <NEW_LINE> auto_api = swagger_client.TestlogApi() <NEW_LINE> auto_req = self._generate_auto_request() <NEW_LINE> try: <NEW_LINE> <INDENT> response = auto_api.submit_automation_test_logs_0(project_id=self._qtest_project_id, body=auto_req, type='automation') <NEW_LINE> <DEDENT> except ApiException as e: <NEW_LINE> <INDENT> raise RuntimeError("The qTest API reported an error!\n" "Status code: {}\n" "Reason: {}\n" "Message: {}".format(e.status, e.reason, e.body)) <NEW_LINE> <DEDENT> if response.state == 'FAILED': <NEW_LINE> <INDENT> raise RuntimeError("The qTest API failed to process the job!\nJob ID: {}".format(response.id)) <NEW_LINE> <DEDENT> self._requirement_link_facade.link() <NEW_LINE> return int(response.id) | Construct a 'AutomationRequest' qTest resource and upload the test results to the desired project in
qTest Manager.
Returns:
int: The queue processing ID for the job.
Raises:
RuntimeError: Failed to upload test results to qTest Manager. | 625941bb5fc7496912cc3841 |
def index_search(self, wait=True): <NEW_LINE> <INDENT> if not self.driver: <NEW_LINE> <INDENT> self.logger.error("Not connected.") <NEW_LINE> return False <NEW_LINE> <DEDENT> if self._index_searched: <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> for i, axis in enumerate(self.axes): <NEW_LINE> <INDENT> self.logger.info("Index search index_search axis %d..." % i) <NEW_LINE> axis.requested_state = AXIS_STATE_ENCODER_INDEX_SEARCH <NEW_LINE> <DEDENT> if wait: <NEW_LINE> <INDENT> for i, axis in enumerate(self.axes): <NEW_LINE> <INDENT> while axis.current_state != AXIS_STATE_IDLE: <NEW_LINE> <INDENT> time.sleep(0.1) <NEW_LINE> <DEDENT> <DEDENT> for i, axis in enumerate(self.axes): <NEW_LINE> <INDENT> if axis.error != 0: <NEW_LINE> <INDENT> self.logger.error("Failed index_search with axis error 0x%x, motor error 0x%x" % (axis.error, axis.motor.error)) <NEW_LINE> return False <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> self._index_searched = True <NEW_LINE> return True | Finding index, requires full rotation on motor | 625941bbff9c53063f47c0b1 |
def off(self): <NEW_LINE> <INDENT> if self.state == OFF: <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> self.process.terminate() <NEW_LINE> self.state = OFF | выключает видео | 625941bb6e29344779a624d0 |
def _get_sal_config(self, channel): <NEW_LINE> <INDENT> if 'channels' not in self.config['sal']: <NEW_LINE> <INDENT> return {} <NEW_LINE> <DEDENT> if channel not in self.config['sal']['channels']: <NEW_LINE> <INDENT> return {} <NEW_LINE> <DEDENT> return self.config['sal']['channels'][channel] | Get SAL configuration for given channel. | 625941bb2c8b7c6e89b3567e |
def image_gradient_T(x): <NEW_LINE> <INDENT> if isinstance(x, np.ndarray): <NEW_LINE> <INDENT> x_h = x[0] <NEW_LINE> x_v = x[1] <NEW_LINE> x_h_ext = np.hstack((x_h, x_h[:, :1])) <NEW_LINE> x_v_ext = np.vstack((x_v, x_v[:1])) <NEW_LINE> d_x = x_h_ext[:, :-1] - x_h_ext[:, 1:] <NEW_LINE> d_y = x_v_ext[:-1] - x_v_ext[1:] <NEW_LINE> return d_x + d_y <NEW_LINE> <DEDENT> elif isinstance(x, ctorch.ComplexTensor): <NEW_LINE> <INDENT> x_h = x[0] <NEW_LINE> x_v = x[1] <NEW_LINE> x_h_ext = ctorch.cat((x_h, x_h[:, :1]), dim=1) <NEW_LINE> x_v_ext = ctorch.cat((x_v, x_v[:1]), dim=0) <NEW_LINE> d_x = x_h_ext[:, :-1] - x_h_ext[:, 1:] <NEW_LINE> d_y = x_v_ext[:-1] - x_v_ext[1:] <NEW_LINE> return d_x + d_y <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise TypeError('Input must be a numpy.ndarray ' + 'or a ctorch.ComplexTensor.') | Transpose of the operator that function image_gradient implements.
Computes the transpose of the matrix given by function image_gradient.
Parameters
----------
x : numpy.ndarray or ctorch.ComplexTensor
stack of two identically shaped arrays
Returns
-------
numpy.ndarray or ctorch.ComplexTensor
result of applying to x the transpose of function image_gradient | 625941bb76d4e153a657e9eb |
def _IsTestMethod(attrname, test_case_class): <NEW_LINE> <INDENT> attr = getattr(test_case_class, attrname) <NEW_LINE> return callable(attr) and attrname.startswith('test') | Checks whether this is a valid test method.
Args:
attrname: the method name.
test_case_class: the test case class.
Returns:
True if test_case_class.'attrname' is callable and it starts with 'test';
False otherwise. | 625941bbb57a9660fec3373c |
def get_lpm_len_from_node(self, node, dst_addr): <NEW_LINE> <INDENT> cur_lpm_len = 0 <NEW_LINE> dst_addr = ipaddress.ip_address(dst_addr) <NEW_LINE> is_ipv4 = isinstance(dst_addr, ipaddress.IPv4Address) <NEW_LINE> for cur_prefix in self.get_node_prefixes(node, is_ipv4): <NEW_LINE> <INDENT> if dst_addr in ipaddress.ip_network(cur_prefix): <NEW_LINE> <INDENT> cur_len = int(cur_prefix.split("/")[1]) <NEW_LINE> cur_lpm_len = max(cur_lpm_len, cur_len) <NEW_LINE> <DEDENT> <DEDENT> return cur_lpm_len | return the longest prefix match of dst_addr in node's
advertising prefix pool | 625941bb0fa83653e4656e78 |
def norm1(self, x): <NEW_LINE> <INDENT> return self._get_module_by_name(self.norm1_name)(x) | Apply norm1. | 625941bb2eb69b55b151c767 |
def pc_output_buffers_full(self, *args): <NEW_LINE> <INDENT> return _Interfaces_swig.ax25_sink_b_sptr_pc_output_buffers_full(self, *args) | pc_output_buffers_full(ax25_sink_b_sptr self, int which) -> float
pc_output_buffers_full(ax25_sink_b_sptr self) -> pmt_vector_float | 625941bb7b180e01f3dc46c0 |
def test_clean_name_string(self): <NEW_LINE> <INDENT> self.assertEqual('this is a full name', baidu.clean_name_string('this is a full name')) <NEW_LINE> self.assertEqual('this is a full ,. pz', baidu.clean_name_string('this is a full ;,.$&[{{}}(=*)+]pz')) <NEW_LINE> self.assertEqual('', baidu.clean_name_string('')) | bibauthorid - test cleaning of name strings | 625941bb167d2b6e31218a52 |
def last_record(): <NEW_LINE> <INDENT> out_record = dict() <NEW_LINE> out_record['date'] = "2014-12-08" <NEW_LINE> out_record['time'] = "21:38" <NEW_LINE> out_record['celsius'] = -4 <NEW_LINE> out_record['fahrenheit'] = int(round(out_record['celsius']*9/5.0 + 32)) <NEW_LINE> out_record['humidity'] = 50 <NEW_LINE> return out_record | Returns the last temperature and humidity record data.
The returned object is a dict with keys ts, fahrenheit, celsius and
humidity.
In the mockup, there is no real temperature sensor to query, so
an arbitrary result is returned. | 625941bb56ac1b37e6264091 |
def variant(bg): <NEW_LINE> <INDENT> fullname = epp.literal(misc.normalize(bg.name)) <NEW_LINE> shortname = epp.literal(misc.normalize(bg.shortname)) <NEW_LINE> eff = epp.effect(lambda val, st: val.update({Capture.BACKGROUND: bg})) <NEW_LINE> return epp.chain( [epp.branch([fullname, shortname], save_iterator=False), eff], save_iterator=False) | Make a parser for the background. | 625941bb379a373c97cfaa06 |
def get(self, request, format=None): <NEW_LINE> <INDENT> an_apiview = [ 'Uses HTTP methods as function (get, post, put, patch, delete).', 'It is similar to a traditional django view', 'Gives you the most control over your logic', 'Is mapped manually to URLs', ] <NEW_LINE> return Response({'message': 'Hello world', 'an_apiview': an_apiview }) | Returns a list of APIView feature. | 625941bbac7a0e7691ed3f94 |
def output_multiple(self): <NEW_LINE> <INDENT> return _trellis.trellis_viterbi_combined_fi_sptr_output_multiple(self) | output_multiple(self) -> int | 625941bb21a7993f00bc7ba6 |
def delete_extra_channel(self, id, **kwargs): <NEW_LINE> <INDENT> kwargs['_return_http_data_only'] = True <NEW_LINE> if kwargs.get('async_req'): <NEW_LINE> <INDENT> return self.delete_extra_channel_with_http_info(id, **kwargs) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> (data) = self.delete_extra_channel_with_http_info(id, **kwargs) <NEW_LINE> return data | DeleteExtraChannel deletes the extra channel matching the given id. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_extra_channel(id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str id: (required)
:return: ApiDeleteExtraChannelResponse
If the method is called asynchronously,
returns the request thread. | 625941bb66673b3332b91f4c |
def to_basic_block(self): <NEW_LINE> <INDENT> return _gnuradio_core_general.gr_multiply_ff_sptr_to_basic_block(self) | to_basic_block(self) -> gr_basic_block_sptr | 625941bba219f33f34628830 |
def generate_access_config(access, psecurity = False): <NEW_LINE> <INDENT> result_cmd_list = [] <NEW_LINE> access_template = [ 'switchport mode access', 'switchport access vlan', 'switchport nonegotiate', 'spanning-tree portfast', 'spanning-tree bpduguard enable' ] <NEW_LINE> port_security = [ 'switchport port-security maximum 2', 'switchport port-security violation restrict', 'switchport port-security' ] <NEW_LINE> for intf, vlan_num in access.items(): <NEW_LINE> <INDENT> result_cmd_list.append('interface {}'.format(intf)) <NEW_LINE> for cmd in access_template: <NEW_LINE> <INDENT> if cmd.endswith('access vlan'): <NEW_LINE> <INDENT> result_cmd_list.append(' {} {}'.format(cmd, vlan_num)) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> result_cmd_list.append(' {}'.format(cmd)) <NEW_LINE> <DEDENT> <DEDENT> if psecurity: <NEW_LINE> <INDENT> for cmd in port_security: <NEW_LINE> <INDENT> result_cmd_list.append(cmd) <NEW_LINE> <DEDENT> <DEDENT> result_cmd_list.append('!') <NEW_LINE> <DEDENT> return result_cmd_list | из задания 9.1а
access - словарь access-портов,
для которых необходимо сгенерировать конфигурацию, вида:
{ 'FastEthernet0/12':10,
'FastEthernet0/14':11,
'FastEthernet0/16':17 }
psecurity - контролирует нужна ли настройка Port Security. По умолчанию значение False
- если значение True, то настройка выполняется с добавлением шаблона port_security
- если значение False, то настройка не выполняется
Возвращает список всех команд, которые были сгенерированы на основе шаблона | 625941bb627d3e7fe0d68d0a |
def randomNetwork(sites, cmin=1, cmax=10): <NEW_LINE> <INDENT> sites = list(sites) <NEW_LINE> c = {} <NEW_LINE> for i in xrange(len(sites)): <NEW_LINE> <INDENT> a = sites[i] <NEW_LINE> c[a, a] = 0 <NEW_LINE> for j in xrange(i + 1, len(sites)): <NEW_LINE> <INDENT> b = sites[j] <NEW_LINE> c[b, a] = c[a, b] = randint(cmin, cmax) <NEW_LINE> <DEDENT> <DEDENT> return c | sites: names of the sites | 625941bb8a43f66fc4b53f25 |
@csrf_exempt <NEW_LINE> def logUser(request): <NEW_LINE> <INDENT> if request.method == 'POST': <NEW_LINE> <INDENT> objJson = json.loads(request.body.decode('utf-8')) <NEW_LINE> login = objJson['login'] <NEW_LINE> password = objJson['password'] <NEW_LINE> user = authenticate(username=login, password=password) <NEW_LINE> if user is not None: <NEW_LINE> <INDENT> if user.is_active: <NEW_LINE> <INDENT> logger.debug(str(user) + " authenticated !") <NEW_LINE> prof = Profile.objects.filter(id_user=user)[0] <NEW_LINE> p = ProfileDTO(prof, prof.pourcentage) <NEW_LINE> return myDumpJson(p.toJson()) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> logger.error(str(user) + " is not active !") <NEW_LINE> return HttpResponse(status=401) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> logger.error("Can't authenticate " + str(user) + "!") <NEW_LINE> return HttpResponse(status=400) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> return HttpResponse(content="Not a POST request", status=400) | Connecte un utilisateur | 625941bb2ae34c7f2600cfed |
def get_list_example(): <NEW_LINE> <INDENT> return [ [1, '2017-11-01'], [2, '2017-11-08'], [3, '2017-11-15'] ] | 获取某一类监控数据的列表，分页显示
:return:
[
[1, '2017-11-01'],
[2, '2017-11-08'],
[3, '2017-11-15']
] | 625941bb1d351010ab8559d9 |
def test_assembly_fails_for_incompatible_dimensions(self): <NEW_LINE> <INDENT> from bempp.api import BlockedOperator <NEW_LINE> op = BlockedOperator(2, 1) <NEW_LINE> op[0, 0] = self._slp <NEW_LINE> with self.assertRaises(ValueError): <NEW_LINE> <INDENT> op[1, 0] = self._hyp | Assembly fails for incompatible dimensions. | 625941bb6aa9bd52df036c5e |
def __ne__(self, other): <NEW_LINE> <INDENT> if not isinstance(other, ReportCampaignsGroup): <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> return self.to_dict() != other.to_dict() | Returns true if both objects are not equal | 625941bbcc40096d6159580e |
def __str__(self): <NEW_LINE> <INDENT> return self.outfit_name | String for representing the Outfit object. | 625941bba17c0f6771cbdf0f |
def _load_location(location, element): <NEW_LINE> <INDENT> location.file = element.get('file') <NEW_LINE> line = element.get('line') <NEW_LINE> if line is None: <NEW_LINE> <INDENT> line = element.get('linenr') <NEW_LINE> <DEDENT> if line is None: <NEW_LINE> <INDENT> line = '0' <NEW_LINE> <DEDENT> location.linenr = int(line) <NEW_LINE> location.column = int(element.get('column', '0')) | Load location from element/dict | 625941bb60cbc95b062c6405 |
def __init__(self, title=None, description=None, visible=None, type=None, order=None, width=None, local_vars_configuration=None): <NEW_LINE> <INDENT> if local_vars_configuration is None: <NEW_LINE> <INDENT> local_vars_configuration = Configuration() <NEW_LINE> <DEDENT> self.local_vars_configuration = local_vars_configuration <NEW_LINE> self._title = None <NEW_LINE> self._description = None <NEW_LINE> self._visible = None <NEW_LINE> self._type = None <NEW_LINE> self._order = None <NEW_LINE> self._width = None <NEW_LINE> self.discriminator = None <NEW_LINE> if title is not None: <NEW_LINE> <INDENT> self.title = title <NEW_LINE> <DEDENT> if description is not None: <NEW_LINE> <INDENT> self.description = description <NEW_LINE> <DEDENT> if visible is not None: <NEW_LINE> <INDENT> self.visible = visible <NEW_LINE> <DEDENT> if type is not None: <NEW_LINE> <INDENT> self.type = type <NEW_LINE> <DEDENT> if order is not None: <NEW_LINE> <INDENT> self.order = order <NEW_LINE> <DEDENT> if width is not None: <NEW_LINE> <INDENT> self.width = width | TopicGraphCreateRequest - a model defined in OpenAPI | 625941bb796e427e537b047e |
def test_baidu_search(self): <NEW_LINE> <INDENT> home_page = HomePage(self.driver) <NEW_LINE> home_page.search("selenium") | # 1
self.driver.find_element_by_id("kw").send_keys("selenium"+Keys.RETURN)
time.sleep(2)
assert "selenium" in self.driver.title | 625941bb4527f215b584c316 |
def get_keywords(self, keyword_part='', current_dict=None): <NEW_LINE> <INDENT> keywords = dict() <NEW_LINE> if current_dict is None: <NEW_LINE> <INDENT> current_dict = self.keyword_trie_dict <NEW_LINE> <DEDENT> for char in current_dict: <NEW_LINE> <INDENT> if char == self._keyword_flag: <NEW_LINE> <INDENT> keywords[keyword_part] = current_dict[self._keyword_flag] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> keywords_ = self.get_keywords(keyword_part+char, current_dict[char]) <NEW_LINE> keywords.update(keywords_) <NEW_LINE> <DEDENT> <DEDENT> return keywords | 获取所有的keywords
Returns:
keywords: list | 625941bb10dbd63aa1bd2a6a |
def __init__(self, id=None, label=None, data_type=None, input=None, values=None, operators=None): <NEW_LINE> <INDENT> self.swagger_types = { 'id': 'str', 'label': 'str', 'data_type': 'str', 'input': 'str', 'values': 'list[SchemeValueType]', 'operators': 'list[str]' } <NEW_LINE> self.attribute_map = { 'id': 'id', 'label': 'label', 'data_type': 'dataType', 'input': 'input', 'values': 'values', 'operators': 'operators' } <NEW_LINE> self._id = id <NEW_LINE> self._label = label <NEW_LINE> self._data_type = data_type <NEW_LINE> self._input = input <NEW_LINE> self._values = values <NEW_LINE> self._operators = operators | SchemeField - a model defined in Swagger
:param dict swaggerTypes: The key is attribute name
and the value is attribute type.
:param dict attributeMap: The key is attribute name
and the value is json key in definition. | 625941bb73bcbd0ca4b2bf39 |
def __setitem__ (self, name, newValue): <NEW_LINE> <INDENT> comp = self.fun <NEW_LINE> if isinstance( newValue, FunctionWrapper): <NEW_LINE> <INDENT> comp[name] = newValue.fun <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> comp[name] = newValue | Called from array-like access on LHS
**It should not be called directly.**
:param name: name or index in the []
:param newValue: new value for item | 625941bbd8ef3951e32433f9 |
def __init__(self, client_id=None, event=None): <NEW_LINE> <INDENT> self._client_id = None <NEW_LINE> self._event = None <NEW_LINE> self.discriminator = None <NEW_LINE> self.client_id = client_id <NEW_LINE> self.event = event | Log - a model defined in Swagger | 625941bb30bbd722463cbc7f |
def validate_date(self, date): <NEW_LINE> <INDENT> if isinstance(date, datetime.datetime) and date.date() < timezone.now().date(): <NEW_LINE> <INDENT> raise ValidationError("Please verify the end dates are not in the past.") | Validate that end dates are not in the past. | 625941bb5166f23b2e1a5015 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.