code
stringlengths 4
4.48k
| docstring
stringlengths 1
6.45k
| _id
stringlengths 24
24
|
|---|---|---|
def conda_creator(env_name, pkgs): <NEW_LINE> <INDENT> call_wrapper("conda create --yes -n %s %s" % (env_name, pkgs), shell=True) | Create a conda environment of a given name containing a given string of pkgs.
| 625941b2d10714528d5ffa87 |
def start_simulation(self): <NEW_LINE> <INDENT> self.assert_state(State.INITIALIZED) <NEW_LINE> logging.debug("Starting simulation.") <NEW_LINE> self.state = State.STARTED <NEW_LINE> self.thread = Thread(group=None, target=self.run, name=constant.SHORT_NAME) <NEW_LINE> self.thread.start() <NEW_LINE> mainloop() | Start simulation | 625941b23539df3088e2e0ed |
def rmd(self, dirname): <NEW_LINE> <INDENT> return self.voidcmd('RMD ' + dirname) | Remove a directory. | 625941b2a79ad161976cbee7 |
@register.filter(is_safe=True) <NEW_LINE> @stringfilter <NEW_LINE> def guessComponentClass(verbose_name): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> r = verbose_name.split()[0] <NEW_LINE> r = r[0].upper() + r[1:].lower() + 'Component' <NEW_LINE> return r <NEW_LINE> <DEDENT> except: <NEW_LINE> <INDENT> return '' | Guess Model class based on Meta.verbose_name.
e.g. 'DNA constructs' -> DnaComponent | 625941b2a17c0f6771cbddfe |
def test_filter_one_key(): <NEW_LINE> <INDENT> data = [ { "name": "Bill", "last_name": "Gilbert", "occupation": "was here", "type": "person", }, {"is_dead": True, "kind": "parrot", "type": "bird", "name": "polly"}, ] <NEW_LINE> actual_result = make_filter(last_name="Gilbert").apply(data) <NEW_LINE> expected_result = [data[0]] <NEW_LINE> assert actual_result == expected_result | Testing with one key.
Test input: last_name="Gilbert"
Expecting the first dictionary as an output. | 625941b20383005118ecf386 |
def getSoundSetFileNames(self, setName): <NEW_LINE> <INDENT> if not self.proxy: <NEW_LINE> <INDENT> self.proxy = self.session.service("ALAudioPlayer") <NEW_LINE> <DEDENT> return self.proxy.getSoundSetFileNames(setName) | Return the list of files contained in a sound set
:param str setName: name of the set
:returns std::vector<std::string>: | 625941b2627d3e7fe0d68bf0 |
def __init__(self): <NEW_LINE> <INDENT> self._layout = None <NEW_LINE> self._materialized = False <NEW_LINE> self._bound_events = [] <NEW_LINE> self._widget_index = dict() <NEW_LINE> self._factory = WidgetFactory(self) <NEW_LINE> self._root = None | constructor | 625941b266656f66f7cbbf53 |
def set_recipe_yield(self): <NEW_LINE> <INDENT> self.recipe_yield = self.soup.find("dd", {"class": "yield"}).text | Gets recipe yield (serving size) from Epicurious.com recipe
:return: None | 625941b2796e427e537b0363 |
def return_annotation(self, *, link=None): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> annot = typing.get_type_hints(self.obj).get('return', '') <NEW_LINE> <DEDENT> except NameError as e: <NEW_LINE> <INDENT> warn("Error handling return annotation for {}: {}".format(self.name, e.args[0])) <NEW_LINE> annot = inspect.signature(inspect.unwrap(self.obj)).return_annotation <NEW_LINE> if annot == inspect.Parameter.empty: <NEW_LINE> <INDENT> annot = '' <NEW_LINE> <DEDENT> <DEDENT> if not annot: <NEW_LINE> <INDENT> return '' <NEW_LINE> <DEDENT> s = inspect.formatannotation(annot).replace(' ', '\N{NBSP}') <NEW_LINE> if link: <NEW_LINE> <INDENT> from pdoc.html_helpers import _linkify <NEW_LINE> s = re.sub(r'[\w\.]+', partial(_linkify, link=link, module=self.module), s) <NEW_LINE> <DEDENT> return s | Formatted function return type annotation or empty string if none. | 625941b2ec188e330fd5a54b |
def TryGetInt32(self,item_name,*__args): <NEW_LINE> <INDENT> pass | TryGetInt32(self: GH_Chunk,item_name: str,item_index: int,value: int) -> (bool,int)
Gets the value of the item with the specified name and index.
Name comparison is
not case-sensitive.
item_name: Name of item to retrieve.
item_index: Index of item to retrieve.
value: Target of assignment.
Returns: True if the value was set.
TryGetInt32(self: GH_Chunk,item_name: str,value: int) -> (bool,int)
Gets the value of the item with the specified name.
Name comparison is not
case-sensitive.
item_name: Name of item to retrieve.
value: Target of assignment.
Returns: True if the value was set. | 625941b224f1403a92600914 |
def wordBreak(self, s, wordDict): <NEW_LINE> <INDENT> path = [[] for i in range(len(s) + 1)] <NEW_LINE> path[0] = [0] <NEW_LINE> for i in range(len(s)): <NEW_LINE> <INDENT> for j in range(0, i + 1): <NEW_LINE> <INDENT> if path[j] and s[j : i + 1] in wordDict: <NEW_LINE> <INDENT> path[i + 1].append(j) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> if not path[-1]: <NEW_LINE> <INDENT> return [] <NEW_LINE> <DEDENT> res = [] <NEW_LINE> self.traceBack(res, path, "", len(s), s) <NEW_LINE> return res | :type s: str
:type wordDict: Set[str]
:rtype: List[str] | 625941b2596a89723608986d |
def get_all_drbd_hard_drive_object(self, include_remote=False): <NEW_LINE> <INDENT> hard_drive_objects = [] <NEW_LINE> hdd_factory = self.po__get_registered_object('hard_drive_factory') <NEW_LINE> for hdd_object in hdd_factory.get_all(): <NEW_LINE> <INDENT> if ((get_hostname() in hdd_object.nodes or include_remote) and hdd_object.get_type() == 'Drbd'): <NEW_LINE> <INDENT> hard_drive_objects.append(hdd_object) <NEW_LINE> <DEDENT> <DEDENT> return hard_drive_objects | Obtain all hard drive objects that are backed by DRBD. | 625941b276d4e153a657e8d2 |
def lower_resolution(forest_cover,fgeo,ogeo,proj): <NEW_LINE> <INDENT> if len(ogeo.lat.shape)>1: <NEW_LINE> <INDENT> olon,olat=(ogeo.lon[1,:],ogeo.lat[:,1]) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> olon,olat=(ogeo.lon,ogeo.lat) <NEW_LINE> <DEDENT> outputdata=np.zeros((2,olat.shape[0],olon.shape[0])) <NEW_LINE> for i in range(forest_cover.shape[0]): <NEW_LINE> <INDENT> if (i%100)==0: <NEW_LINE> <INDENT> print(i,forest_cover.shape[0], " "+str(float(i)/forest_cover.shape[0]*100)[:5]+"%", end=" ") <NEW_LINE> <DEDENT> for j in range(forest_cover.shape[1]): <NEW_LINE> <INDENT> xlat,xlon=mygis.proj2ll(x=float(fgeo.x[j]),y=float(fgeo.y[i]),proj=proj) <NEW_LINE> xpos=np.argmin(np.abs(olon-xlon)) <NEW_LINE> ypos=np.argmin(np.abs(olat-xlat)) <NEW_LINE> outputdata[0,ypos,xpos]+=forest_cover[i,j] <NEW_LINE> outputdata[1,ypos,xpos]+=1 <NEW_LINE> <DEDENT> <DEDENT> forest_fraction=outputdata[0,...]/outputdata[1,...] <NEW_LINE> forest_fraction[forest_fraction>=0.5]=1 <NEW_LINE> forest_fraction[forest_fraction<0.5]=0 <NEW_LINE> return forest_fraction | convert forest cover to a lower resolution map | 625941b20383005118ecf387 |
def results_table(results): <NEW_LINE> <INDENT> df = results.loc[:, ('_pipe', 'mean_fit_time', 'mean_score_time', 'mean_test_score')] <NEW_LINE> df['Mean Test Score'] = df['mean_test_score'] <NEW_LINE> df['Mean Run Time'] = df['mean_fit_time'] + df['mean_score_time'] <NEW_LINE> df['Pipe'] = df['_pipe'] <NEW_LINE> return df.drop(['_pipe', 'mean_fit_time', 'mean_score_time', 'mean_test_score'], axis=1).set_index('Pipe') .sort_values(by='Mean Test Score', ascending=False) | Create a results table from the results of a ModelSearch | 625941b2b5575c28eb68dd9f |
def check_integrity(sakefile, verbose): <NEW_LINE> <INDENT> if verbose: <NEW_LINE> <INDENT> print("Call to check_integrity issued") <NEW_LINE> <DEDENT> if not sakefile: <NEW_LINE> <INDENT> sys.stderr.write("Sakefile is empty\n") <NEW_LINE> return False <NEW_LINE> <DEDENT> if len(sakefile.keys()) != len(set(sakefile.keys())): <NEW_LINE> <INDENT> sys.stderr.write("Sakefile contains duplicate targets\n") <NEW_LINE> return False <NEW_LINE> <DEDENT> for target in sakefile: <NEW_LINE> <INDENT> if target == "all": <NEW_LINE> <INDENT> if not check_target_integrity(target, sakefile["all"], all=True): <NEW_LINE> <INDENT> sys.stderr.write("Failed to accept target 'all'\n") <NEW_LINE> return False <NEW_LINE> <DEDENT> continue <NEW_LINE> <DEDENT> if "formula" not in sakefile[target]: <NEW_LINE> <INDENT> if not check_target_integrity(target, sakefile[target], meta=True): <NEW_LINE> <INDENT> errmes = "Failed to accept meta-target '{}'\n".format(target) <NEW_LINE> sys.stderr.write(errmes) <NEW_LINE> return False <NEW_LINE> <DEDENT> for atom_target in sakefile[target]: <NEW_LINE> <INDENT> if atom_target == "help": <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> if not check_target_integrity(atom_target, sakefile[target][atom_target], parent=target): <NEW_LINE> <INDENT> errmes = "Failed to accept target '{}'\n".format( atom_target) <NEW_LINE> sys.stderr.write(errmes) <NEW_LINE> return False <NEW_LINE> <DEDENT> <DEDENT> continue <NEW_LINE> <DEDENT> if not check_target_integrity(target, sakefile[target]): <NEW_LINE> <INDENT> errmes = "Failed to accept target '{}'\n".format(target) <NEW_LINE> sys.stderr.write(errmes) <NEW_LINE> return False <NEW_LINE> <DEDENT> <DEDENT> return True | Checks the format of the sakefile dictionary
to ensure it conforms to specification
Args:
A dictionary that is the parsed Sakefile (from sake.py)
A flag indicating verbosity
Returns:
True if the Sakefile is conformant
False if not | 625941b3dc8b845886cb52d6 |
def minimum(tensors=None, function=lambda x: x, rmax=10, max_iter=10, verbose=False, **kwargs): <NEW_LINE> <INDENT> _, info = cross( **kwargs, tensors=tensors, function=function, rmax=rmax, max_iter=max_iter, verbose=verbose, return_info=True, _minimize=True) <NEW_LINE> return info['min'] | Estimate the minimal element of a tensor (or a function of one or several tensors)
:param t: input :class:`Tensor`
:param rmax: used for :func:`cross.cross()`. Lower is faster; higher is more accurate (default is 10)
:param max_iter: used for :func:`cross.cross()`. Lower is faster; higher is more accurate (default is 10)
:param verbose: default is False
:param **kwargs: passed to :func:`cross.cross()`
:return: a scalar | 625941b350485f2cf553cb3b |
def auto_init(self): <NEW_LINE> <INDENT> self.state = self.STATE_INIT <NEW_LINE> self.start_time = time.time() <NEW_LINE> self.last_state = self.STATE_INIT | Used right before autonomous. Might be a good place to grab the time or reset encoders. | 625941b36fece00bbac2d4dd |
def test_get_detail(self): <NEW_LINE> <INDENT> url = "/api/packagedb/products/%d/" % (self.fixture_obj.pk,) <NEW_LINE> response = self.client.get(url, HTTP_AUTHORIZATION=self.credentials) <NEW_LINE> self.assertEqual(response.status_code, 200) <NEW_LINE> self.assertEqual(response.data, self.data[0]) | GET requests to APIView should return a single object. | 625941b37047854f462a11b0 |
def handle_conn_error( self, err_type: str, err_id: int, err_str: str, close: bool = True ) -> None: <NEW_LINE> <INDENT> if self._timeout_ev: <NEW_LINE> <INDENT> self._timeout_ev.delete() <NEW_LINE> <DEDENT> if self._error_sent: <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> self._error_sent = True <NEW_LINE> self.unregister_fd() <NEW_LINE> self.emit("connect_error", err_type, err_id, err_str) <NEW_LINE> if close and self.sock: <NEW_LINE> <INDENT> self.sock.close() | Handle a connect error. | 625941b321a7993f00bc7a8a |
def turn_off(self): <NEW_LINE> <INDENT> self.gate.clear() | Disable flow | 625941b399cbb53fe679298a |
def search_in_rotated_sorted_array(A, value): <NEW_LINE> <INDENT> def find_pivot(A): <NEW_LINE> <INDENT> left = 0 <NEW_LINE> right = len(A) - 1 <NEW_LINE> while left < right: <NEW_LINE> <INDENT> if A[left] < A[right]: <NEW_LINE> <INDENT> return left <NEW_LINE> <DEDENT> middle = left + (right - left) / 2 <NEW_LINE> if A[left] < A[middle]: <NEW_LINE> <INDENT> left = middle + 1 <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> right = middle <NEW_LINE> <DEDENT> <DEDENT> return left <NEW_LINE> <DEDENT> def binary_search(A, left, right, value): <NEW_LINE> <INDENT> while left < right: <NEW_LINE> <INDENT> middle = left + (right - left) / 2 <NEW_LINE> if value == A[middle]: <NEW_LINE> <INDENT> return middle <NEW_LINE> <DEDENT> elif value < A[middle]: <NEW_LINE> <INDENT> right = middle - 1 <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> left = middle + 1 <NEW_LINE> <DEDENT> <DEDENT> if A[left] == value: <NEW_LINE> <INDENT> return left <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return -1 <NEW_LINE> <DEDENT> <DEDENT> pivot = find_pivot(A) <NEW_LINE> index = binary_search(A, 0, pivot-1, value) <NEW_LINE> if index >= 0: <NEW_LINE> <INDENT> return index <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return binary_search(A, pivot, len(A)-1, value) | >>> search_in_rotated_sorted_array([4, 5, 6, 7, 0, 1, 2], 6)
2
>>> search_in_rotated_sorted_array([4, 5, 6, 7, 0, 1, 2], 0)
4
>>> search_in_rotated_sorted_array([5, 6, 7, 0, 1, 2, 4], 6)
1 | 625941b373bcbd0ca4b2be1f |
def test_update_entry(self): <NEW_LINE> <INDENT> pass | Test case for update_entry
# noqa: E501 | 625941b3d268445f265b4c17 |
def test_RestrictingNodeTransformer__visit_Lambda__2(): <NEW_LINE> <INDENT> result = compile_restricted_exec("lambda _bad=1: None") <NEW_LINE> assert lambda_err_msg in result.errors | It prevents keyword arguments starting with `_`. | 625941b38e7ae83300e4ad75 |
def upload_file(self, img_file_full): <NEW_LINE> <INDENT> img_file = img_file_full.split("/")[-1] <NEW_LINE> img_name = img_file.split(".")[0] <NEW_LINE> img_tpye = img_file.split(".")[1] <NEW_LINE> files_id = None <NEW_LINE> try: <NEW_LINE> <INDENT> with open(img_file_full, 'rb') as file_r: <NEW_LINE> <INDENT> object_id = self.fs.put(data=file_r, content_type=img_tpye, filename=img_name) <NEW_LINE> files_id = str(object_id) <NEW_LINE> <DEDENT> <DEDENT> except Exception as e: <NEW_LINE> <INDENT> mongo_exception_send_DD(e=e, msg="上传图片") <NEW_LINE> <DEDENT> finally: <NEW_LINE> <INDENT> return files_id | 上传图片
:param img_file_full:
:return:
1.上传成功 -> 返回 图片id
2.mongo连接不上 -> 返回 None | 625941b3287bf620b61d3814 |
def mainmenu(self): <NEW_LINE> <INDENT> print_menu() <NEW_LINE> choice = self.input_choice() <NEW_LINE> if choice == 1: <NEW_LINE> <INDENT> self.play_game() <NEW_LINE> <DEDENT> elif choice == 2: <NEW_LINE> <INDENT> self.stat_choice() <NEW_LINE> <DEDENT> elif choice == 3: <NEW_LINE> <INDENT> print("You wish to exit") <NEW_LINE> sys.exit(0) <NEW_LINE> <DEDENT> self.mainmenu() | Anropar print_menu() och input_choice().
Beroende på vad man väljer anropas play_game() eller stat_choice().
Man kan även avsluta spelet.
:return: | 625941b3099cdd3c635f09ff |
def register(self, family: str = None, position: int = None, priority: int = None): <NEW_LINE> <INDENT> def decorator(target): <NEW_LINE> <INDENT> if isclass(target): <NEW_LINE> <INDENT> self.append_handler_cls(target, family, priority) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.append_func(target, family, position, priority) <NEW_LINE> <DEDENT> return target <NEW_LINE> <DEDENT> return decorator | The factory method for creating decorators to register handlers to middleware.
Singledispathed for differenct types of targets.
If you register a function, you must give `position` and `family`.
If you register a Handler class, you can register it without explicit parameters::
@register(family='Myfamily', position=1)
def my_func(task):
print("This is called before execution")
print(task)
@register()
class MyHandler(Handler):
family = 'Myfamily'
def handle(self, task):
print("This is called before execution")
print(task)
Args:
family: received as the :attr:`Handler.family` of the Handler.
priority: received as the :attr:`Handler.priority` of the Handler.
position: represents the role of function. Should be a valid int: 0/1/2/3
0 - :meth:`Handler.on_start`
1 - :meth:`Handler.handle_before`
2 - :meth:`Handler.handle_after`
3 - :meth:`Handler.on_close` | 625941b31b99ca400220a853 |
def extend(self, iterable): <NEW_LINE> <INDENT> self._data.extend(iterable) | Extends the :class:`Sequence` by appending items from the *iterable*.
:param iterable: any *iterable* that contains items of :class:`Structure`,
:class:`Sequence`, :class:`Array` or :class:`Field` instances. If the
*iterable* is one of these instances itself then the *iterable* itself
is appended to the :class:`Sequence`. | 625941b356ac1b37e6263f85 |
def createJob(self, streamerList): <NEW_LINE> <INDENT> if not self.createdGroup: <NEW_LINE> <INDENT> self.newGroup() <NEW_LINE> self.createdGroup = True <NEW_LINE> <DEDENT> self.newJob(name = "%s-%s" % (self.jobNamePrefix, makeUUID())) <NEW_LINE> for streamer in streamerList: <NEW_LINE> <INDENT> f = File(id = streamer['id'], lfn = streamer['lfn']) <NEW_LINE> f.setLocation(streamer['location'], immediateSave = False) <NEW_LINE> self.currentJob.addFile(f) <NEW_LINE> <DEDENT> return | _createJob_ | 625941b315fb5d323cde08ab |
def save(self, size, target=None, *args, **kwargs): <NEW_LINE> <INDENT> assert_true(size in self.EXPORT_SIZES, "Unknown size {}".format(size)) <NEW_LINE> self._figure.set_size_inches(*self.EXPORT_SIZES[size]) <NEW_LINE> self._figure.savefig( os.path.join(FIGURE_PATH, self._name) if target is None else target, bbox_inches='tight', pad_inches=0.1, *args, **kwargs ) | Saves plot of frozen motion to disk in figs_path
:param size: paper dimensions in inches as tuple
:param target: target folder as string
:param args:
:param kwargs: | 625941b37d43ff24873a2a46 |
def list_deployment_runs_in_virtualization_realm(self, vr_id, search_type='SEARCH_ALL'): <NEW_LINE> <INDENT> log = logging.getLogger(self.cls_logger + '.list_deployment_runs_in_virtualization_realm') <NEW_LINE> if not isinstance(vr_id, int): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> vr_id = int(vr_id) <NEW_LINE> <DEDENT> except ValueError as exc: <NEW_LINE> <INDENT> msg = 'vr_id arg must be an Integer, found: {t}'.format(t=vr_id.__class__.__name__) <NEW_LINE> raise Cons3rtApiError(msg) from exc <NEW_LINE> <DEDENT> <DEDENT> if not isinstance(search_type, str): <NEW_LINE> <INDENT> raise Cons3rtApiError('Arg search_type must be a string, found type: {t}'.format( t=search_type.__class__.__name__)) <NEW_LINE> <DEDENT> valid_search_type = ['SEARCH_ACTIVE', 'SEARCH_ALL', 'SEARCH_AVAILABLE', 'SEARCH_COMPOSING', 'SEARCH_DECOMPOSING', 'SEARCH_INACTIVE', 'SEARCH_PROCESSING', 'SEARCH_SCHEDULED', 'SEARCH_TESTING', 'SEARCH_SCHEDULED_AND_ACTIVE'] <NEW_LINE> search_type = search_type.upper() <NEW_LINE> if search_type not in valid_search_type: <NEW_LINE> <INDENT> raise Cons3rtApiError('Arg status provided is not valid, must be one of: {s}'.format( s=', '.join(search_type))) <NEW_LINE> <DEDENT> log.info('Attempting to get a list of deployment runs with search_type {s} in ' 'virtualization realm ID: {i}'.format(i=str(vr_id), s=search_type)) <NEW_LINE> try: <NEW_LINE> <INDENT> drs = self.cons3rt_client.list_all_deployment_runs_in_virtualization_realm( vr_id=vr_id, search_type=search_type ) <NEW_LINE> <DEDENT> except Cons3rtClientError as exc: <NEW_LINE> <INDENT> msg = 'Problem listing runs in virtualization realm ID: {i} with search type {t}'.format( i=str(vr_id), t=search_type) <NEW_LINE> raise Cons3rtClientError(msg) from exc <NEW_LINE> <DEDENT> log.info('Found {n} runs in virtualization realm ID: {i}'.format(n=str(len(drs)), i=str(vr_id))) <NEW_LINE> return drs | Query CONS3RT to return a list of deployment runs in a virtualization realm
:param: vr_id: (int) virtualization realm ID
:param: search_type (str) the run status to filter the search on
:return: (list) of deployment runs
:raises: Cons3rtApiError | 625941b3a934411ee375143e |
def validate(self, task): <NEW_LINE> <INDENT> if not driver_utils.get_node_mac_addresses(task): <NEW_LINE> <INDENT> raise ir_exc.MissingParameterValue( _("Node %s does not have any ports associated with it" ) % task.node.uuid) | Check that the node's 'driver_info' is valid.
Check that the node's 'driver_info' contains the requisite fields
and that an Libvirt connection to the node can be established.
:param task: a TaskManager instance containing the node to act on.
:raises: InvalidParameterValue if any connection parameters are
incorrect or if failed to connect to the libvirt socket.
:raises: MissingParameterValue if no ports are enrolled for the given
node. | 625941b3baa26c4b54cb0ecc |
def check(self, client): <NEW_LINE> <INDENT> status = discord.Status.offline <NEW_LINE> for member in client.get_all_members(): <NEW_LINE> <INDENT> if member.id == self.user_id: <NEW_LINE> <INDENT> status = member.status <NEW_LINE> <DEDENT> <DEDENT> if self.is_afk: <NEW_LINE> <INDENT> if status == discord.Status.online and (self.afk_on['idle'] or self.afk_on['off']): <NEW_LINE> <INDENT> self.afk(False) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> if ((status == discord.Status.idle and self.afk_on['idle']) or (status == discord.Status.offline and self.afk_on['off'])): <NEW_LINE> <INDENT> self.afk() | Update the AFK status. | 625941b3498bea3a759b9855 |
def test_add_remove_triples(self): <NEW_LINE> <INDENT> c = self.repo.get(self.repo.path2uri(CPATH)) <NEW_LINE> resource = c.add_container(self.repo.dc_rdf(MDATA1)) <NEW_LINE> self.assertIsNotNone(resource) <NEW_LINE> uri = resource.uri <NEW_LINE> self.logger.info("New resource at {}".format(uri)) <NEW_LINE> uris = [ ('http://fake.it/things/' + s) for s in [ 'one', 'two', 'three' ] ] <NEW_LINE> for uri in uris: <NEW_LINE> <INDENT> resource.rdf_add(PCDM['hasMember'], URIRef(uri)) <NEW_LINE> <DEDENT> self.assertTrue(resource.rdf_write()) <NEW_LINE> r2 = self.repo.get(resource.uri) <NEW_LINE> members = [ str(u) for u in r2.rdf_get_all(PCDM['hasMember']) ] <NEW_LINE> for uri in uris: <NEW_LINE> <INDENT> self.assertTrue(uri in members) <NEW_LINE> <DEDENT> r2.rdf_remove(PCDM['hasMember']) <NEW_LINE> self.assertTrue(r2.rdf_write()) <NEW_LINE> r2.rdf_read() <NEW_LINE> members = r2.rdf_get_all(PCDM['hasMember']) <NEW_LINE> self.assertFalse(members) | Adding multiple triples with the same predicate | 625941b32ae34c7f2600ced4 |
def store_credentials(self, app_name, options): <NEW_LINE> <INDENT> return defer.succeed(None) | Store the U1 credentials. | 625941b399fddb7c1c9de13d |
def load_most_recent_transformed_data(self): <NEW_LINE> <INDENT> filepath = Path(self.data_path, "data/transformed_data/*") <NEW_LINE> files = glob.glob(filepath.__str__()) <NEW_LINE> if len(files) == 0: <NEW_LINE> <INDENT> print("ERROR: no files found at {}".format(filepath)) <NEW_LINE> return <NEW_LINE> <DEDENT> filenames = [os.path.basename(file) for file in files] <NEW_LINE> filenames.sort() <NEW_LINE> chosen_one = filenames[-1] <NEW_LINE> print("Loading {}".format(chosen_one)) <NEW_LINE> return self.load_transformed_data(chosen_one) | Load the most recent pickled data dictionary from the data/transformed directory,
as determined by the timestamp in the filename. | 625941b37b25080760e39206 |
def heatmap(self, shape=None, cmap='bwr', value_range=None, centering=False, absolute=False): <NEW_LINE> <INDENT> saliency = self.saliency.copy() <NEW_LINE> heatmap = numpy.zeros((*saliency.shape[:2], 3), dtype=numpy.uint8) <NEW_LINE> if absolute: <NEW_LINE> <INDENT> saliency = numpy.absolute(saliency) <NEW_LINE> <DEDENT> cm = getattr(matplotlib.cm, cmap, None) <NEW_LINE> if cm is None: <NEW_LINE> <INDENT> raise ValueError('invalid colormap name {}.'.format(cmap)) <NEW_LINE> <DEDENT> if shape is None: <NEW_LINE> <INDENT> shape = (self.height, self.width, 3) <NEW_LINE> <DEDENT> elif len(shape) == 2: <NEW_LINE> <INDENT> shape = (*shape, 3) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise TypeError("shape has an invalid shape. shape must be None or (h, w)") <NEW_LINE> <DEDENT> if value_range is None: <NEW_LINE> <INDENT> sup = saliency.max() <NEW_LINE> inf = saliency.min() <NEW_LINE> <DEDENT> elif len(value_range) == 2: <NEW_LINE> <INDENT> inf, sup = value_range <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise TypeError('value_range has invalid length that is not 2') <NEW_LINE> <DEDENT> if centering: <NEW_LINE> <INDENT> absmax = max(abs(inf), abs(sup)) <NEW_LINE> saliency /= absmax <NEW_LINE> saliency *= 127 <NEW_LINE> saliency += 128 <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> saliency -= saliency.min() <NEW_LINE> saliency /= saliency.max() <NEW_LINE> saliency *= 255 <NEW_LINE> <DEDENT> for y, row in saliency: <NEW_LINE> <INDENT> for x, value in row: <NEW_LINE> <INDENT> color_rgba = cm(value, 1, True) <NEW_LINE> heatmap[y, x] = color_rgba[:3] <NEW_LINE> <DEDENT> <DEDENT> if heatmap.shape != shape: <NEW_LINE> <INDENT> pilimg = Image.fromarray(heatmap) <NEW_LINE> pilimg.resize(shape[:2], Image.BICUBIC) <NEW_LINE> heatmap = numpy.asarray(pilimg) <NEW_LINE> <DEDENT> return heatmap | Activation visualizer based on activation saliency with a local occlusion.
This method sees the fluctuation of neuronal activation (feature map) magnitude
by occluding a certain small region in the input images, corresponding to the receptive field.
This visualization method makes a heat map of a variation of each neuronal activations came
from each local occlusions,
which implies a neuronal attentions (localities).
Generate saliency heat map corresponding to the object location.
If you choose a colormap which has transparency at the center of values,
Args:
shape (array_like): shape of heatmap, defaulting to the same size as the saliency tensor
cmap (str): the name of colormap definition in matplotlib.cm
value_range (scalar or 2d_array_like): value range for normalize the saliency
centering (bool): If True, heatmap will be symmetrized with 0
absolute (bool): if True, saliency will be visualized with its magnitude
Returns:
heatmap (numpy.array) | 625941b3004d5f362079a0db |
def nextToken(self): <NEW_LINE> <INDENT> while(self.hasToken() and not self.target[self.row]): <NEW_LINE> <INDENT> self.row += 1 <NEW_LINE> <DEDENT> if self.hasToken(): <NEW_LINE> <INDENT> ws = self.ws_skip.match(self.target[self.row], self.column) <NEW_LINE> if ws: <NEW_LINE> <INDENT> self.column = ws.end() <NEW_LINE> <DEDENT> token_match = self.regex.match(self.target[self.row], self.column) <NEW_LINE> if token_match: <NEW_LINE> <INDENT> category_id = token_match.lastgroup <NEW_LINE> category_num = self.categories[category_id] <NEW_LINE> new_token = Token((self.row + 1, self.column + 1), (category_num, category_id), token_match.string[token_match.start():token_match.end()]) <NEW_LINE> self.column = token_match.end() <NEW_LINE> if self.column >= len(self.target[self.row]): <NEW_LINE> <INDENT> self.column = 0 <NEW_LINE> self.row += 1 <NEW_LINE> <DEDENT> return new_token <NEW_LINE> <DEDENT> error = '[%03d, %03d] Invalid token' % (self.row + 1, self.column) <NEW_LINE> self.row = len(self.target) <NEW_LINE> return error <NEW_LINE> <DEDENT> return '' | Returns the next matched token.
The first section checks if there are empty lines on the next
position - If so, the current row will be updated to skip
them. Whitespaces are skipped here by ws_skip.
Returns 'Invalid token' if no token is matched. | 625941b3bf627c535bc12f79 |
def wget(url): <NEW_LINE> <INDENT> logging.info('Downloading %s', url) <NEW_LINE> localpath = path.join(path.abspath(os.getcwd()), path.basename(url)) <NEW_LINE> urlretrieve(url, localpath) | Download the given file to current directory | 625941b3cad5886f8bd26d85 |
def generate_eno_coefficients(self, k): <NEW_LINE> <INDENT> if self.side == 1: <NEW_LINE> <INDENT> d = 1 <NEW_LINE> <DEDENT> elif self.side == -1: <NEW_LINE> <INDENT> d = 0 <NEW_LINE> <DEDENT> r_values, j_values = range(k), range(k) <NEW_LINE> c_rj = {} <NEW_LINE> for r in r_values: <NEW_LINE> <INDENT> for j in j_values: <NEW_LINE> <INDENT> c_rj_sum = 0 <NEW_LINE> for m in range(j+1, k+1): <NEW_LINE> <INDENT> top_sum = 0 <NEW_LINE> bottom_product = 1 <NEW_LINE> for l in [x for x in range(k+1) if x != m]: <NEW_LINE> <INDENT> top_product_total = 1 <NEW_LINE> for q in [x for x in range(k+1) if (x != m and x != l)]: <NEW_LINE> <INDENT> top_product = r - q + d <NEW_LINE> top_product_total *= top_product <NEW_LINE> <DEDENT> bottom_product *= m - l <NEW_LINE> top_sum += top_product_total <NEW_LINE> <DEDENT> c_rj_sum += Rational(top_sum, bottom_product) <NEW_LINE> <DEDENT> c_rj[(r, j)] = c_rj_sum <NEW_LINE> <DEDENT> <DEDENT> return c_rj | Generates the c_rj ENO reconstruction coefficients given in Table 2.1
of 'Essentially Non-Oscillatory and Weighted Essentially Non-Oscillatory Schemes
for Hyperbolic Conservation Laws' by Shu(1997). Computation is of equation (2.21).
:arg int k: WENO coefficient k, equal to scheme order = 2k - 1.
:returns: dict: c_rj: Dictionary in the form (r,j) : ENO coefficient c_rj. | 625941b3fbf16365ca6f5f66 |
def parse_soup(self, soup): <NEW_LINE> <INDENT> allowed_types = ( None, "Repositories", "Wikis", "Users", "Topics", "Marketplace", "RegistryPackages", "Issues", "Commits", "Code") <NEW_LINE> if self.type not in allowed_types: <NEW_LINE> <INDENT> raise IncorrectKeyWord( "No type <{type_}> exists".format(type_=self.type)) <NEW_LINE> <DEDENT> if self.type in (None, "Repositories"): <NEW_LINE> <INDENT> return soup.find_all('li', class_='repo-list-item') <NEW_LINE> <DEDENT> elif self.type == "RegistryPackages": <NEW_LINE> <INDENT> return soup.find_all("div", class_='hx_hit-package') <NEW_LINE> <DEDENT> elif self.type == "Users": <NEW_LINE> <INDENT> return soup.find_all('div', class_='user-list-item') <NEW_LINE> <DEDENT> elif self.type == "Wikis": <NEW_LINE> <INDENT> return soup.find_all('div', class_='hx_hit-wiki') <NEW_LINE> <DEDENT> elif self.type == "Topics": <NEW_LINE> <INDENT> return soup.find_all('div', class_='topic-list-item') <NEW_LINE> <DEDENT> elif self.type == "Issues": <NEW_LINE> <INDENT> return soup.find_all('div', class_='issue-list-item') <NEW_LINE> <DEDENT> elif self.type == "Marketplace": <NEW_LINE> <INDENT> return soup.find_all('div', class_='hx_hit-marketplace') <NEW_LINE> <DEDENT> elif self.type == "Commits": <NEW_LINE> <INDENT> return soup.find_all('div', class_='commits-list-item') | Parses GitHub for a search query. | 625941b33eb6a72ae02ec27c |
def __init__(self, cases: List[Valeur]): <NEW_LINE> <INDENT> if not all(case in self._valeurs for case in cases): <NEW_LINE> <INDENT> raise ValueError("Les seuls valeurs possibles sont 1 2 3 4 ou x") <NEW_LINE> <DEDENT> if len(cases) != 16: <NEW_LINE> <INDENT> raise ValueError("Il faut fournir 16 valeurs.") <NEW_LINE> <DEDENT> self._cases = cases | Initialise via une liste. | 625941b3fff4ab517eb2f1e1 |
def list_config_file(self, **kwargs): <NEW_LINE> <INDENT> kwargs['_return_http_data_only'] = True <NEW_LINE> if kwargs.get('callback'): <NEW_LINE> <INDENT> return self.list_config_file_with_http_info(**kwargs) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> (data) = self.list_config_file_with_http_info(**kwargs) <NEW_LINE> return data | List config files
_**Needs Admin role**_ List config files
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a `callback` function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_config_file(callback=callback_function)
:param callback function: The callback function
for asynchronous request. (optional)
:return: list[ConfigFile]
If the method is called asynchronously,
returns the request thread. | 625941b3eab8aa0e5d26d901 |
def table_cell(self, value, **options): <NEW_LINE> <INDENT> return TableCell(value, **options) | Return a TableCell instance
:param value: The cell value
:type value: str
:param options: The cell options
:type options: dict
:rtype: TableCell | 625941b33539df3088e2e0ee |
def tim_parse(txtfile_path): <NEW_LINE> <INDENT> df, again_func_names = toDataframe(txtfile_path) <NEW_LINE> toCSV(df) <NEW_LINE> writeFuncNamesTXT(again_func_names) <NEW_LINE> decode() | Driver Function | 625941b39f2886367277a63d |
def _make_map(self, ls, title, nc, s1): <NEW_LINE> <INDENT> return self._make_map_only(ls, title) + self._make_nocut_only(nc, s1) | Summarise mapping information as a string (PRIVATE).
Return a string of form::
| title.
|
| enzyme1, position
| |
| AAAAAAAAAAAAAAAAAAAAA...
| |||||||||||||||||||||
| TTTTTTTTTTTTTTTTTTTTT...
Arguments:
- ls is a list of cutting enzymes.
- title is the title.
- nc is a list of non cutting enzymes.
- s1 is the sentence before the non cutting enzymes. | 625941b35fdd1c0f98dbffdc |
def execute_request(self, api_url, api_request_object=None, method=None): <NEW_LINE> <INDENT> if self._token is None: <NEW_LINE> <INDENT> raise ApiException("Access token is not abtained. " "Call authenticate_with_apikey or authenticate_with_contact_credentials first.") <NEW_LINE> <DEDENT> if not api_url.startswith("http"): <NEW_LINE> <INDENT> api_url = self.api_endpoint + api_url <NEW_LINE> <DEDENT> if method is None: <NEW_LINE> <INDENT> if api_request_object is None: <NEW_LINE> <INDENT> method = "GET" <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> method = "POST" <NEW_LINE> <DEDENT> <DEDENT> request = urllib2.Request(api_url) <NEW_LINE> if api_request_object is not None: <NEW_LINE> <INDENT> request.data = json.dumps(api_request_object, cls=_ApiObjectEncoder).encode() <NEW_LINE> <DEDENT> request.add_header("Content-Type", "application/json") <NEW_LINE> request.add_header("Accept", "application/json") <NEW_LINE> request.add_header("Authorization", "Bearer " + self._get_access_token()) <NEW_LINE> try: <NEW_LINE> <INDENT> response = urllib2.urlopen(request) <NEW_LINE> return WaApiClient._parse_response(response) <NEW_LINE> <DEDENT> except urllib2.HTTPError as httpErr: <NEW_LINE> <INDENT> if httpErr.code == 400: <NEW_LINE> <INDENT> raise ApiException(httpErr.read()) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise | perform api request and return result as an instance of ApiObject or list of ApiObjects
api_url -- absolute or relative api resource url
api_request_object -- any json serializable object to send to API
method -- HTTP method of api request. Default: GET if api_request_object is None else POST | 625941b3b57a9660fec33622 |
def __init__(self, key='', *value): <NEW_LINE> <INDENT> if key == '': <NEW_LINE> <INDENT> self.key = self.__class__.__name__ <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.key = key <NEW_LINE> <DEDENT> if len(value) != 0: <NEW_LINE> <INDENT> self.value = list(flatten(value)) | init
Args:
key (str): the key
*value: the value to be stored | 625941b3d8ef3951e32432e1 |
def iter_extract(self, entries, destination_dir): <NEW_LINE> <INDENT> wanted = set(entries) <NEW_LINE> for filename in self.iter_contents(): <NEW_LINE> <INDENT> if not filename in wanted: <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> self.extract(filename, destination_dir) <NEW_LINE> yield filename <NEW_LINE> wanted.remove(filename) <NEW_LINE> if 0 == len(wanted): <NEW_LINE> <INDENT> break | Generator to extract <entries> from archive to <destination_dir>. | 625941b35510c4643540f19e |
def serialize_numpy(self, buff, numpy): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> buff.write(_struct_i.pack(self.uiHandle)) <NEW_LINE> <DEDENT> except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(_x)))) <NEW_LINE> except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(_x)))) | serialize message with numpy array types into buffer
:param buff: buffer, ``StringIO``
:param numpy: numpy python module | 625941b3dd821e528d63af56 |
def read_header(self): <NEW_LINE> <INDENT> self.header = FdsHeader(debug=False) <NEW_LINE> self.header.process(self.file_in) | Get basic information from the header so we know
where the data starts and information about the data
:return: | 625941b350812a4eaa59c0ca |
def infer_shape(self, inputs, mod=None): <NEW_LINE> <INDENT> typ = self.infer_type(inputs, mod=mod) <NEW_LINE> if hasattr(typ, "shape"): <NEW_LINE> <INDENT> return get_const_tuple(typ.shape) <NEW_LINE> <DEDENT> return typ | A method to get the output type of an intermediate node in the graph. | 625941b35f7d997b8717483f |
def __extract_model_summary_value(model, value): <NEW_LINE> <INDENT> field_value = None <NEW_LINE> if isinstance(value, _precomputed_field): <NEW_LINE> <INDENT> field_value = value.field <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> field_value = model._get(value) <NEW_LINE> <DEDENT> if isinstance(field_value, float): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> field_value = round(field_value, 4) <NEW_LINE> <DEDENT> except: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> <DEDENT> return field_value | Extract a model summary field value | 625941b3ec188e330fd5a54c |
def __init__(self, dt, t0=0.0, phase=0.0): <NEW_LINE> <INDENT> self.dt = dt <NEW_LINE> self.t0 = t0 <NEW_LINE> self.phase = phase | Instantiates a shifted Gaussian function.
The Gaussian is calculated by::
f(t) = exp(-0.5 (t - t0)^2 / dt^2) * exp(1.0j * phase)
Its Fourier transform is::
F(w) = dt/sqrt(2pi) exp(-0.5 * (w + phase)^2 * dt^2 +
1j * t0 * w)
Parameters
----------
dt : float
The standard deviation of the temporal amplitude distribution.
t0 : float
The center of the temporal amplitude distribution.
phase : float
The linear phase coefficient of the temporal distribution. | 625941b38da39b475bd64d1a |
def load_equivalences() -> List[Tuple[str, str, str]]: <NEW_LINE> <INDENT> return _load_csv(EQUIVALENCES_PATH) | Returns FamPlex equivalences as a list of rows.
Returns
-------
list
List of lists corresponding to rows from equivalences.csv. Each row
contains three entries. A namespace, an ID, and a FamPlex ID. For
example ['BEL', 'AMP Activated Protein Kinase Complex', 'AMPK']. | 625941b3b7558d58953c4cc6 |
@set_module('mxnet.symbol.numpy') <NEW_LINE> def split(ary, indices_or_sections, axis=0): <NEW_LINE> <INDENT> indices = [] <NEW_LINE> sections = 0 <NEW_LINE> if isinstance(indices_or_sections, int): <NEW_LINE> <INDENT> sections = indices_or_sections <NEW_LINE> <DEDENT> elif isinstance(indices_or_sections, tuple): <NEW_LINE> <INDENT> indices = [0] + list(indices_or_sections) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise ValueError('indices_or_sections must either int or tuple of ints') <NEW_LINE> <DEDENT> ret = _npi.split(ary, indices, axis, False, sections) <NEW_LINE> return ret | Split an array into multiple sub-arrays.
Parameters
----------
ary : ndarray
Array to be divided into sub-arrays.
indices_or_sections : int or 1-D array
If `indices_or_sections` is an integer, N, the array will be divided
into N equal arrays along `axis`. If such a split is not possible,
an error is raised.
If `indices_or_sections` is a 1-D array of sorted integers, the entries
indicate where along `axis` the array is split. For example,
``[2, 3]`` would, for ``axis=0``, result in
- ary[:2]
- ary[2:3]
- ary[3:]
If an index exceeds the dimension of the array along `axis`,
an empty sub-array is returned correspondingly.
axis : int, optional
The axis along which to split, default is 0.
Returns
-------
sub-arrays : list of ndarrays
A list of sub-arrays.
Raises
------
ValueError
If `indices_or_sections` is given as an integer, but
a split does not result in equal division. | 625941b3460517430c393f36 |
def unique_id(self): <NEW_LINE> <INDENT> return _gnuradio_core_general.gr_int_to_float_sptr_unique_id(self) | unique_id(self) -> long | 625941b315fb5d323cde08ac |
def __init__(self, target_validator, collision_validator, locator_task, concurrent_task=NoOp(), ram_speed=None, *args, **kwargs): <NEW_LINE> <INDENT> super().__init__(*args, **kwargs) <NEW_LINE> self.logv("Starting {} task".format(self.__class__.__name__)) <NEW_LINE> self.target_validator = target_validator <NEW_LINE> self.collision_validator = collision_validator <NEW_LINE> self.ram_speed = ram_speed <NEW_LINE> self.ram_task = VelocityX() <NEW_LINE> self.locator_task = locator_task <NEW_LINE> self.concurrent_task = concurrent_task <NEW_LINE> self.TIMEOUT = 25 | target_validator - a function that returns True when a target is
visible and False otherwise.
collision_validator - a function that returns True when a collision is
made and False otherwise.
concurrent_task - an optional argument for a task to run while moving
forward to ram the target. It may be used to continually align with
the target while ramming it. | 625941b3004d5f362079a0dc |
def parse_qs_request_groups(qsdict): <NEW_LINE> <INDENT> by_suffix = {} <NEW_LINE> def get_request_group(suffix): <NEW_LINE> <INDENT> if suffix not in by_suffix: <NEW_LINE> <INDENT> rq_grp = placement_lib.RequestGroup(use_same_provider=bool(suffix)) <NEW_LINE> by_suffix[suffix] = rq_grp <NEW_LINE> <DEDENT> return by_suffix[suffix] <NEW_LINE> <DEDENT> for key, val in qsdict.items(): <NEW_LINE> <INDENT> match = _QS_KEY_PATTERN.match(key) <NEW_LINE> if not match: <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> prefix, suffix = match.groups() <NEW_LINE> request_group = get_request_group(suffix or '') <NEW_LINE> if prefix == _QS_RESOURCES: <NEW_LINE> <INDENT> request_group.resources = normalize_resources_qs_param(val) <NEW_LINE> <DEDENT> elif prefix == _QS_REQUIRED: <NEW_LINE> <INDENT> request_group.required_traits = normalize_traits_qs_param(val) <NEW_LINE> <DEDENT> <DEDENT> orphans = [('required%s' % suff) for suff, group in by_suffix.items() if group.required_traits and not group.resources] <NEW_LINE> if orphans: <NEW_LINE> <INDENT> msg = _('All traits parameters must be associated with resources. ' 'Found the following orphaned traits keys: %s') <NEW_LINE> raise webob.exc.HTTPBadRequest(msg % ', '.join(orphans)) <NEW_LINE> <DEDENT> return [by_suffix[suff] for suff in sorted(by_suffix)] | Parse numbered resources and traits groupings out of a querystring dict.
The input qsdict represents a query string of the form:
?resources=$RESOURCE_CLASS_NAME:$AMOUNT,$RESOURCE_CLASS_NAME:$AMOUNT
&required=$TRAIT_NAME,$TRAIT_NAME
&resources1=$RESOURCE_CLASS_NAME:$AMOUNT,RESOURCE_CLASS_NAME:$AMOUNT
&required1=$TRAIT_NAME,$TRAIT_NAME
&resources2=$RESOURCE_CLASS_NAME:$AMOUNT,RESOURCE_CLASS_NAME:$AMOUNT
&required2=$TRAIT_NAME,$TRAIT_NAME
These are parsed in groups according to the numeric suffix of the key.
For each group, a RequestGroup instance is created containing that group's
resources and required traits. For the (single) group with no suffix, the
RequestGroup.use_same_provider attribute is False; for the numbered groups
it is True.
The return is a list of these RequestGroup instances.
As an example, if qsdict represents the query string:
?resources=VCPU:2,MEMORY_MB:1024,DISK_GB=50
&required=HW_CPU_X86_VMX,CUSTOM_STORAGE_RAID
&resources1=SRIOV_NET_VF:2
&required1=CUSTOM_PHYSNET_PUBLIC,CUSTOM_SWITCH_A
&resources2=SRIOV_NET_VF:1
&required2=CUSTOM_PHYSNET_PRIVATE
...the return value will be:
[ RequestGroup(
use_same_provider=False,
resources={
"VCPU": 2,
"MEMORY_MB": 1024,
"DISK_GB" 50,
},
required_traits=[
"HW_CPU_X86_VMX",
"CUSTOM_STORAGE_RAID",
],
),
RequestGroup(
use_same_provider=True,
resources={
"SRIOV_NET_VF": 2,
},
required_traits=[
"CUSTOM_PHYSNET_PUBLIC",
"CUSTOM_SWITCH_A",
],
),
RequestGroup(
use_same_provider=True,
resources={
"SRIOV_NET_VF": 1,
},
required_traits=[
"CUSTOM_PHYSNET_PRIVATE",
],
),
]
:param qsdict: The MultiDict representing the querystring on a GET.
:return: A list of RequestGroup instances.
:raises `webob.exc.HTTPBadRequest` if any value is malformed, or if a
trait list is given without corresponding resources. | 625941b38a349b6b435e7f20 |
def label_smoothing(inputs, epsilon=0.1): <NEW_LINE> <INDENT> K = inputs.get_shape().as_list()[-1] <NEW_LINE> return ((1-epsilon) * inputs) + (epsilon / K) | Applies label smoothing. See https://arxiv.org/abs/1512.00567.
Args:
inputs: A 3d tensor with shape of [N, T, V], where V is the number of vocabulary.
epsilon: Smoothing rate.
For example,
```
import tensorflow as tf
inputs = tf.convert_to_tensor([[[0, 0, 1],
[0, 1, 0],
[1, 0, 0]],
[[1, 0, 0],
[1, 0, 0],
[0, 1, 0]]], tf.float32)
outputs = label_smoothing(inputs)
with tf.Session() as sess:
print(sess.run([outputs]))
>>
[array([[[ 0.03333334, 0.03333334, 0.93333334],
[ 0.03333334, 0.93333334, 0.03333334],
[ 0.93333334, 0.03333334, 0.03333334]],
[[ 0.93333334, 0.03333334, 0.03333334],
[ 0.93333334, 0.03333334, 0.03333334],
[ 0.03333334, 0.93333334, 0.03333334]]], dtype=float32)]
``` | 625941b30a366e3fb873e5ba |
def do_saveconfig(self, arg=None): <NEW_LINE> <INDENT> self.do_saveconf(arg) | save current config to file | 625941b321a7993f00bc7a8c |
def update_pkg_set(self, fmri_set): <NEW_LINE> <INDENT> if self.origin_fmri: <NEW_LINE> <INDENT> fmri_set.discard(self.origin_fmri) <NEW_LINE> <DEDENT> if self.destination_fmri: <NEW_LINE> <INDENT> fmri_set.add(self.destination_fmri) | updates a set of installed fmris to reflect
proposed new state | 625941b38e7ae83300e4ad77 |
@pytest.mark.parametrize( "data, category", [ (categorical_series(), "categorical"), (continuous_series(), "continuous"), (ordinal_series(), "ordinal"), ], ) <NEW_LINE> def test_data_cmap(data, category): <NEW_LINE> <INDENT> cmap, data_family = aes.data_cmap(data) <NEW_LINE> assert data_family == category | Test data_cmap. | 625941b399cbb53fe679298c |
def test5(self): <NEW_LINE> <INDENT> session=requests.Session() <NEW_LINE> login_res=session.post(url=self.TestData["login"]["login_url"],data=self.TestData["login"]["login_data"],headers=self.headers) <NEW_LINE> if login_res.status_code==200: <NEW_LINE> <INDENT> session.post(url=self.TestData["updateAgency"]["agency_url"],data=self.TestData["updateAgency"]["agency_data"]) <NEW_LINE> basePricePlan_res=session.post(url=self.TestData["basePricePlan"]["basePricePlan_url"],data=self.TestData["basePricePlan"]["basePricePlan_data"]) <NEW_LINE> basePricePlan_json=json.loads(allData().changeIntoStr(basePricePlan_res.text)) <NEW_LINE> self.assertTrue(basePricePlan_res.status_code==200 and len(basePricePlan_json["data"])>=1) <NEW_LINE> Logger(self.TestData["name"]).Info(str(self.TestData["basePricePlan"])) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise Exception("登录不成功不进行单元测试") <NEW_LINE> <DEDENT> session.close() | 报价单列表信息查询 | 625941b3a4f1c619b28afdf0 |
def greedy_predict_point_gen(article, encoder, decoder, vocab, article_full): <NEW_LINE> <INDENT> vocab_size = len(vocab) <NEW_LINE> unknown_index = vocab.index('[UNK]') <NEW_LINE> article_words = [word.decode("UTF-8") for word in article_full] <NEW_LINE> article_only_words = list(set(article_words).difference(set(vocab))) <NEW_LINE> full_vocab = vocab + article_only_words <NEW_LINE> h_i, hidden = encoder(article, None) <NEW_LINE> summary = [] <NEW_LINE> token = BOS_SYM <NEW_LINE> input = tf.expand_dims(tf.convert_to_tensor([vocab.index(token)]), axis=0) <NEW_LINE> while token != EOS_SYM and len(summary) < 121: <NEW_LINE> <INDENT> P_vocab, hidden, attn, p_gen = decoder(input, hidden, h_i) <NEW_LINE> P_vocab = np.array(tf.squeeze(P_vocab)) <NEW_LINE> attn = tf.squeeze(attn) <NEW_LINE> p_gen = tf.squeeze(p_gen) <NEW_LINE> P_vocab = np.pad(P_vocab, (0,len(article_only_words))) <NEW_LINE> attn_sum = np.zeros((len(full_vocab))) <NEW_LINE> for i in range(len(article_words)): <NEW_LINE> <INDENT> attn_sum[full_vocab.index(article_words[i])] += attn[i] <NEW_LINE> <DEDENT> P_extended_vocab_probs = np.array(p_gen * P_vocab + (1 - p_gen) * attn_sum).astype('float64') <NEW_LINE> P_extended_vocab_probs = P_extended_vocab_probs / np.sum(P_extended_vocab_probs) <NEW_LINE> predict_index = np.argmax(rng.multinomial(n=1, pvals=P_extended_vocab_probs)) <NEW_LINE> token = full_vocab[predict_index] <NEW_LINE> if predict_index >= vocab_size: <NEW_LINE> <INDENT> predict_index = unknown_index <NEW_LINE> <DEDENT> input = tf.expand_dims(tf.convert_to_tensor([predict_index]), axis=0) <NEW_LINE> summary.append(token) <NEW_LINE> <DEDENT> if summary[-1] == EOS_SYM: <NEW_LINE> <INDENT> return summary[:-1] <NEW_LINE> <DEDENT> return summary | Perform inference using encoder/decoder to generate
a summary of the article passed in. This uses a
very simple greedy decoding method, where the .
:param article: The article to generate a summary for.
Assumed to be in vectorized form already.
:param encoder: Trained encoder model.
:param decoder: Trained decoder model.
:param vocab: Vocabulary object.
:return: A list of English words corresponding to the
generated summary. | 625941b3aad79263cf3907e6 |
def read_int(self): <NEW_LINE> <INDENT> return self.read_long() | int and long values are written using variable-length, zig-zag coding. | 625941b3f9cc0f698b1403ab |
def run(self, data): <NEW_LINE> <INDENT> prepocessed_data = self._preprocess(data) <NEW_LINE> return [{"key": "default", "score": 0, "result": self.runOneScenario(prepocessed_data), "input": prepocessed_data}] | Run simulation and return result to the GUI.
| 625941b3293b9510aa2c303f |
def treeDisplay(self): <NEW_LINE> <INDENT> root = self.get_fptree() <NEW_LINE> treedisplay = list([]) <NEW_LINE> treedisplay.append('Null set:1') <NEW_LINE> for childnode in root.subNode: <NEW_LINE> <INDENT> treedisplay.append(self.printTreeList(root.subNode[childnode])) <NEW_LINE> <DEDENT> print(treedisplay) | print the tree
store the tree in a list
:return: | 625941b31b99ca400220a855 |
def do_get(self, args): <NEW_LINE> <INDENT> arg_list = list(shlex.split(args)) <NEW_LINE> arg_list.insert(0, 'get') <NEW_LINE> try: <NEW_LINE> <INDENT> argp = self.parser.parse_args(arg_list) <NEW_LINE> pws_get(argp) <NEW_LINE> <DEDENT> except SystemExit: <NEW_LINE> <INDENT> pass | Get an entry from the store. | 625941b34d74a7450ccd3f68 |
def read_entries_df(csv_file): <NEW_LINE> <INDENT> entries_df = pd.read_csv(csv_file, parse_dates=["dateString"]) <NEW_LINE> entries_df["bg"] = ( np.where(pd.notna(entries_df["sgv"]), entries_df["sgv"], entries_df["mbg"]) / 18.0 ) <NEW_LINE> entries_df = entries_df.rename(columns={"dateString": "ts"}) <NEW_LINE> entries_df = entries_df[["ts", "type", "bg"]] <NEW_LINE> entries_df = entries_df.sort_values(by=["ts"]) <NEW_LINE> return entries_df | Read entries from CSV exported from Nightscout
:param csv_file: a CSV file with columns dateString, type, sgv and/or mgb
:return: a Pandas dataframe with columns ts, type, bg | 625941b32c8b7c6e89b35570 |
def Ellipse(center, a, b, bc="ellipse", mat="ellipse"): <NEW_LINE> <INDENT> if abs(a[0]*b[0] + a[1]*b[1]) > 1e-12: <NEW_LINE> <INDENT> raise Exception("In Ellipse: principle axis a and b are not perpendicular") <NEW_LINE> <DEDENT> ellipse = Circle( center=(0,0), radius=1.0, mat=mat, bc=bc ) <NEW_LINE> alpha = math.pi/2-math.atan2(a[0],a[1]) <NEW_LINE> r_a = math.sqrt(a[0]**2+a[1]**2) <NEW_LINE> r_b = math.sqrt(b[0]**2+b[1]**2) <NEW_LINE> ellipse.Scale( (r_a,r_b) ) <NEW_LINE> ellipse.Rotate( alpha/math.pi*180, center=(0,0) ) <NEW_LINE> ellipse.Move( center ) <NEW_LINE> return ellipse | Creates ellipse centered at point center with principle axis a and b.
Parameters
---------
center : Vec2
center of ellipse
a : Vec2
first principle axis, needs to be perpendicular to b
b : Vec2
second principle axis, needs to be perpendicular to a
bc : string
boundary name
mat : string
material name | 625941b363b5f9789fde6e8a |
def restore(self, state) -> None: <NEW_LINE> <INDENT> self.frog_list = arcade.SpriteList() <NEW_LINE> self.bug_list = arcade.SpriteList() <NEW_LINE> self.flower_list = arcade.SpriteList() <NEW_LINE> self.frog_list.extend([Frog.from_photoshot(item) for item in state['frogs']]) <NEW_LINE> self.bug_list.extend([Bug.from_photoshot(item) for item in state['bugs']]) <NEW_LINE> self.flower_list.extend([Flower.from_photoshot(item) for item in state['flowers']]) <NEW_LINE> self.score = state['score'] <NEW_LINE> self.frog_sprite = self.frog_list[0] <NEW_LINE> self.obstacle_list = arcade.SpriteList() <NEW_LINE> self.obstacle_list.extend(self.bug_list) <NEW_LINE> self.obstacle_list.extend(self.flower_list) <NEW_LINE> self.physics_engine = arcade.PhysicsEngineSimple(self.frog_sprite, self.obstacle_list) | Восстанавливает состояние Создателя из объекта снимка. | 625941b33317a56b86939a10 |
def __init__(self, color, width, height): <NEW_LINE> <INDENT> super().__init__() <NEW_LINE> self.image = pygame.Surface([width, height]) <NEW_LINE> self.image.fill(color) <NEW_LINE> self.rect = self.image.get_rect() | Constructor. Pass in the color of the block,
and its size. | 625941b32ae34c7f2600ced6 |
def get_mission_name(meta_dict): <NEW_LINE> <INDENT> mission = None <NEW_LINE> if 'mission' in meta_dict.keys(): <NEW_LINE> <INDENT> value = meta_dict['mission'].lower() <NEW_LINE> <DEDENT> elif 'PLATFORM' in meta_dict.keys(): <NEW_LINE> <INDENT> value = meta_dict['PLATFORM'].lower() <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> print('No PLATFORM nor mission attribute found, can not identify mission name.') <NEW_LINE> print('return None') <NEW_LINE> return mission <NEW_LINE> <DEDENT> if value.startswith('ers'): <NEW_LINE> <INDENT> mission = 'ERS' <NEW_LINE> <DEDENT> elif value.startswith(('env', 'asar')): <NEW_LINE> <INDENT> mission = 'ENV' <NEW_LINE> <DEDENT> elif value.startswith(('s1', 'sen')): <NEW_LINE> <INDENT> mission = 'S1' <NEW_LINE> <DEDENT> elif value.startswith(('rs', 'rsat', 'radarsat')): <NEW_LINE> <INDENT> mission = 'RS' <NEW_LINE> if value.endswith('1'): <NEW_LINE> <INDENT> mission += '1' <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> mission += '2' <NEW_LINE> <DEDENT> <DEDENT> elif value.startswith(('csk', 'cos')): <NEW_LINE> <INDENT> mission = 'CSK' <NEW_LINE> <DEDENT> elif value.startswith(('tsx', 'tdx', 'terra', 'tandem')): <NEW_LINE> <INDENT> mission = 'TSX' <NEW_LINE> <DEDENT> elif value.startswith('jers'): <NEW_LINE> <INDENT> mission = 'JERS' <NEW_LINE> <DEDENT> elif value.startswith(('alos', 'palsar')): <NEW_LINE> <INDENT> if value.endswith('2'): <NEW_LINE> <INDENT> mission = 'ALOS2' <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> mission = 'ALOS' <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> print('Un-recognized PLATFORM attribute: '+value) <NEW_LINE> print('return None') <NEW_LINE> <DEDENT> return mission | Get mission name in UNAVCO InSAR Archive format from attribute mission/PLATFORM
Input: meta_dict : dict, attributes
Output: mission : string, mission name in standard UNAVCO format. | 625941b399fddb7c1c9de140 |
def _on_build_tool_run_complete(self): <NEW_LINE> <INDENT> core = self._core() <NEW_LINE> log = core.log <NEW_LINE> log(log.HIGH, 'target[{}]: validating tool output', self) <NEW_LINE> cmp_names = [] <NEW_LINE> cmp_operands = [] <NEW_LINE> for dep in self._dependencies: <NEW_LINE> <INDENT> if isinstance(dep, (ProcessedSourceTarget, comk.dependency.OutputRerefenceDependency)): <NEW_LINE> <INDENT> cmp_names.append(dep.file_path) <NEW_LINE> with io.open(core.inproject_path(dep.file_path), 'rb') as comparand: <NEW_LINE> <INDENT> cmp_operands.append(self._transform_comparison_operand(comparand.read())) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> if isinstance(cmp_operands[0], basestring): <NEW_LINE> <INDENT> cmp_verbose = 'internal:text-compare' <NEW_LINE> cmp_quiet = 'CMPTXT' <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> cmp_verbose = 'internal:binary-compare' <NEW_LINE> cmp_quiet = 'CMPBIN' <NEW_LINE> <DEDENT> if log.verbosity >= log.LOW: <NEW_LINE> <INDENT> log(log.LOW, '[{}] {} {}', cmp_verbose, *cmp_names) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> log(log.QUIET, '{} {} <=> {}', log.qm_tool_name(cmp_quiet), *cmp_names) <NEW_LINE> <DEDENT> equal = (cmp_operands[0] == cmp_operands[1]) <NEW_LINE> if not equal: <NEW_LINE> <INDENT> log(log.QUIET, '{}: error: {} and {} differ', self._name, *cmp_names) <NEW_LINE> <DEDENT> log.add_testcase_result(self._name, 1, 0 if equal else 1) <NEW_LINE> if not equal: <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> self._on_build_tool_output_validated() | See Target._on_build_tool_run_complete(). Overridden to perform any comparisons defined for the test.
| 625941b3e1aae11d1e749a5a |
def get_imports_from_docstring(example_passage): <NEW_LINE> <INDENT> needed_imports = re.findall(Patterns.NEED_IMPORT, example_passage, re.M) <NEW_LINE> needed_imports = needed_imports if len(needed_imports) > 0 else None <NEW_LINE> if needed_imports is None: <NEW_LINE> <INDENT> return [] <NEW_LINE> <DEDENT> needed_imports = ''.join(needed_imports).replace(Patterns.IMPORT_DEC, '').split('\n') <NEW_LINE> return format_imports(needed_imports) | ----
examples:
@need
from fastest.constants import TestBodies
@end
@let
example_passage = TestBodies.EXAMPLE_WITH_IMPORTS
import_statements = TestBodies.TEST_IMPORT_EXTRACTION
empty_example_passage = ''
@end
1) get_imports_from_docstring(example_passage) -> import_statements
2) get_imports_from_docstring(empty_example_passage) -> []
----
:param example_passage: str
:return: list | 625941b3adb09d7d5db6c539 |
def _layout(self): <NEW_LINE> <INDENT> layout = QtWidgets.QVBoxLayout() <NEW_LINE> layout.addWidget(self._btn_import_settings) <NEW_LINE> client_id_layout = QtWidgets.QHBoxLayout() <NEW_LINE> client_id_layout.addWidget(self._client_id_label) <NEW_LINE> client_id_layout.addWidget(self._client_id) <NEW_LINE> layout.addLayout(client_id_layout) <NEW_LINE> client_secret_layout = QtWidgets.QHBoxLayout() <NEW_LINE> client_secret_layout.addWidget(self._client_secret_label) <NEW_LINE> client_secret_layout.addWidget(self._client_secret) <NEW_LINE> layout.addLayout(client_secret_layout) <NEW_LINE> username_layout = QtWidgets.QHBoxLayout() <NEW_LINE> username_layout.addWidget(self._username_label) <NEW_LINE> username_layout.addWidget(self._username) <NEW_LINE> layout.addLayout(username_layout) <NEW_LINE> password_layout = QtWidgets.QHBoxLayout() <NEW_LINE> password_layout.addWidget(self._password_label) <NEW_LINE> password_layout.addWidget(self._password) <NEW_LINE> layout.addLayout(password_layout) <NEW_LINE> base_url_layout = QtWidgets.QHBoxLayout() <NEW_LINE> base_url_layout.addWidget(self._base_url_label) <NEW_LINE> base_url_layout.addWidget(self._base_url) <NEW_LINE> layout.addLayout(base_url_layout) <NEW_LINE> parser_layout = QtWidgets.QHBoxLayout() <NEW_LINE> parser_layout.addWidget(self._parser_label) <NEW_LINE> parser_layout.addWidget(self._parser) <NEW_LINE> layout.addLayout(parser_layout) <NEW_LINE> read_only_layout = QtWidgets.QHBoxLayout() <NEW_LINE> read_only_layout.addWidget(self._read_only_mode_label) <NEW_LINE> read_only_layout.addWidget(self._read_only_mode) <NEW_LINE> layout.addLayout(read_only_layout) <NEW_LINE> timeout_layout = QtWidgets.QHBoxLayout() <NEW_LINE> timeout_layout.addWidget(self._timeout_label) <NEW_LINE> timeout_layout.addWidget(self._timeout) <NEW_LINE> layout.addLayout(timeout_layout) <NEW_LINE> min_file_size_layout = QtWidgets.QHBoxLayout() <NEW_LINE> min_file_size_layout.addWidget(self._min_file_size_label) <NEW_LINE> min_file_size_layout.addWidget(self._min_file_size) <NEW_LINE> layout.addLayout(min_file_size_layout) <NEW_LINE> status_layout = QtWidgets.QHBoxLayout() <NEW_LINE> status_layout.addWidget(self._btn_check_settings) <NEW_LINE> status_layout.addWidget(self._settings_status) <NEW_LINE> layout.addLayout(status_layout) <NEW_LINE> button_layout = QtWidgets.QHBoxLayout() <NEW_LINE> button_layout.addWidget(self._btn_accept) <NEW_LINE> button_layout.addWidget(self._btn_cancel) <NEW_LINE> layout.addLayout(button_layout) <NEW_LINE> return layout | Layout widgets
:return: QtWidgets.QVBoxLayout() | 625941b3fbf16365ca6f5f68 |
def find(self): <NEW_LINE> <INDENT> if self._has_query: <NEW_LINE> <INDENT> if self._has_projection: <NEW_LINE> <INDENT> return self.interface.find_item( self._query, projection=self._projection) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return self.interface.find_item(self._query) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> if self._has_projection: <NEW_LINE> <INDENT> return self.interface.find_all( projection=self._projection) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return self.interface.find_all() | Execute find call to LightBlue.
Returns: raw response from LB | 625941b33eb6a72ae02ec27e |
def _send_command(self, command, target = CommandTarget.NMCLI): <NEW_LINE> <INDENT> self._log_command(command) <NEW_LINE> output = self._mock_command_output(command, target) <NEW_LINE> if isinstance(output, tuple): <NEW_LINE> <INDENT> self._log_command_output(*output) <NEW_LINE> return output <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self._log_command_output(0, output) <NEW_LINE> return 0, output | Sends command to ncmli with subprocess.
Returns (0, output) of the command if succeeded, returns the exit code and output when errors | 625941b3566aa707497f4321 |
def prepare_batch(self, x, y): <NEW_LINE> <INDENT> max_length = 300 <NEW_LINE> B = len(x) <NEW_LINE> new_x = torch.zeros((B, max_length, self.input_dim), dtype=torch.double) <NEW_LINE> new_y = torch.zeros((B, max_length, 12), dtype=torch.double) <NEW_LINE> for j in range(B): <NEW_LINE> <INDENT> zeropad = torch.nn.ZeroPad2d((0, 0, 0, max_length - len(x[j]))) <NEW_LINE> new_x[j] = zeropad(torch.from_numpy(x[j])).double() <NEW_LINE> new_y[j] = zeropad(torch.from_numpy(y[j])).double() <NEW_LINE> <DEDENT> x = new_x.view((B, max_length, 78)) <NEW_LINE> y = new_y.view((B, max_length, 12)) <NEW_LINE> return x, y | :param x: list of B(batchsize) acoustic trajectories of variable lenghts,
each element of the list is an array (K,18) (K not always the same)
:param y: list of B(batchsize) articulatory features,
each element of the list is an array (K,429) (K not always the same)
:return: 2 np array of sizes (B, K_max, 18) and (B, K_max, 429
x,y initially data of the batch with different sizes . the script zeropad the acoustic and
articulatory sequences so that all element in the batch have the same size | 625941b3dc8b845886cb52d9 |
@utils.supported_filters() <NEW_LINE> @database.run_in_session() <NEW_LINE> @user_api.check_user_permission_in_session( permission.PERMISSION_DEL_SWITCH_MACHINE ) <NEW_LINE> @utils.wrap_to_dict(RESP_MACHINES_FIELDS) <NEW_LINE> def del_switchmachine(session, deleter, switch_machine_id, **kwargs): <NEW_LINE> <INDENT> switch_machine = utils.get_db_object( session, models.SwitchMachine, switch_machine_id=switch_machine_id ) <NEW_LINE> return utils.del_db_object(session, switch_machine) | Delete switch machines. | 625941b307d97122c417862f |
def get_node_by_slot(self, slot, read_command=False): <NEW_LINE> <INDENT> nodes_in_slot = self.nodes.slots[slot] <NEW_LINE> if read_command: <NEW_LINE> <INDENT> random_index = random.randrange(0, len(nodes_in_slot)) <NEW_LINE> return nodes_in_slot[random_index] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return nodes_in_slot[0] | Get a random node from the slot, including master | 625941b3be383301e01b523c |
def test_meta_data_service_collection(self): <NEW_LINE> <INDENT> baseurl = '/' + version + '/meta/col1/' <NEW_LINE> argspost = '?key=testmkey&value=TestString' <NEW_LINE> argsget = '?key=testmkey' <NEW_LINE> response = self.client.post(baseurl + argspost) <NEW_LINE> self.assertEqual(response.status_code, 201) <NEW_LINE> argspost = '?key=testmkey&value=TestStringModified' <NEW_LINE> response = self.client.put(baseurl + argspost) <NEW_LINE> self.assertEqual(response.status_code, 200) <NEW_LINE> response = self.client.get(baseurl) <NEW_LINE> self.assertEqual(response.status_code, 200) <NEW_LINE> self.assertEqual(response.data['keys'][0], 'testmkey') <NEW_LINE> response = self.client.get(baseurl + argsget) <NEW_LINE> self.assertEqual(response.status_code, 200) <NEW_LINE> self.assertEqual(response.data['key'], 'testmkey') <NEW_LINE> self.assertEqual(response.data['value'], 'TestStringModified') <NEW_LINE> response = self.client.delete(baseurl + argsget) <NEW_LINE> self.assertEqual(response.status_code, 204) | Test to make sure the meta URL for get, post, delete and update with all datamodel params resolves to the meta view
:return: | 625941b3cc40096d615956ff |
@blueprint.route("") <NEW_LINE> @flaskparser.use_kwargs(FILTER) <NEW_LINE> @cache.cached(unless=lambda: bool(request.args)) <NEW_LINE> def get(name): <NEW_LINE> <INDENT> if name: <NEW_LINE> <INDENT> return redirect(route('.get_with_name', name=name)) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return _get_aliases() | Get a list of all matching aliases. | 625941b3b5575c28eb68dda2 |
def check_defaults_venvs(project): <NEW_LINE> <INDENT> assert not project.join('.tox', 'py34').exists() <NEW_LINE> assert not project.join('.tox', 'py35').exists() <NEW_LINE> assert not project.join('.tox', 'py36').isdir() <NEW_LINE> assert project.join('.tox', 'py37').isdir() <NEW_LINE> assert project.join('.tox', 'py38').isdir() <NEW_LINE> assert not project.join('.tox', 'py39').exists() | Check that the .tox folder of the default configuration exist
Must follow `check_make_test`. | 625941b38c0ade5d55d3e764 |
def sort(self, col: int, order: int = Qt.AscendingOrder) -> None: <NEW_LINE> <INDENT> if not self.listdata: <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> self.layoutAboutToBeChanged.emit() <NEW_LINE> colname = self.header_attr[col] <NEW_LINE> isfunc = callable(getattr(self.listdata[0], colname)) <NEW_LINE> if isfunc: <NEW_LINE> <INDENT> self.listdata = sorted( self.listdata, key=methodcaller_nonesort(colname)) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.listdata = sorted(self.listdata, key=attrgetter_nonesort(colname)) <NEW_LINE> <DEDENT> if order == Qt.DescendingOrder: <NEW_LINE> <INDENT> self.listdata.reverse() <NEW_LINE> <DEDENT> self.layoutChanged.emit() | Sort table on a specified column.
Args:
col: column number
order: sort order (e.g. ascending order) | 625941b3460517430c393f37 |
def __repr__(self) -> str: <NEW_LINE> <INDENT> return 'Wallet({}, [ACCESS], {})'.format(self.config, self.auto_remove) | Return representation for current object.
:return: representation for current object | 625941b376d4e153a657e8d5 |
def __enter__(self) -> "HammerSimToolTestContext": <NEW_LINE> <INDENT> self.test.assertTrue(hammer_vlsi.HammerVLSISettings.set_hammer_vlsi_path_from_environment(), "hammer_vlsi_path must exist") <NEW_LINE> temp_dir = tempfile.mkdtemp() <NEW_LINE> json_path = os.path.join(temp_dir, "project.json") <NEW_LINE> json_content = { "vlsi.core.sim_tool": "mocksim", "vlsi.core.technology": "nop", "sim.inputs.top_module": "dummy", "sim.inputs.input_files": ("/dev/null",), "sim.submit.command": "local", "sim.inputs.options": ["-debug"], "sim.inputs.level": "rtl", "sim.mocksim.temp_folder": temp_dir } <NEW_LINE> with open(json_path, "w") as f: <NEW_LINE> <INDENT> f.write(json.dumps(json_content, cls=HammerJSONEncoder, indent=4)) <NEW_LINE> <DEDENT> options = hammer_vlsi.HammerDriverOptions( environment_configs=[], project_configs=[json_path], log_file=os.path.join(temp_dir, "log.txt"), obj_dir=temp_dir ) <NEW_LINE> self._driver = hammer_vlsi.HammerDriver(options) <NEW_LINE> self.temp_dir = temp_dir <NEW_LINE> return self | Initialize context by creating the temp_dir, driver, and loading mocksim. | 625941b3b545ff76a8913bc6 |
def addmetadata(self): <NEW_LINE> <INDENT> options = self.createElement("SessionOptions") <NEW_LINE> defaults = self.session.options.getdefaultvalues() <NEW_LINE> for i, (k, v) in enumerate(self.session.options.getkeyvaluelist()): <NEW_LINE> <INDENT> if str(v) != str(defaults[i]): <NEW_LINE> <INDENT> addtextparamtoparent(self, options, k, v) <NEW_LINE> <DEDENT> <DEDENT> if options.hasChildNodes(): <NEW_LINE> <INDENT> self.meta.appendChild(options) <NEW_LINE> <DEDENT> self.addhooks() <NEW_LINE> meta = self.createElement("MetaData") <NEW_LINE> self.meta.appendChild(meta) <NEW_LINE> for (k, v) in self.session.metadata.items(): <NEW_LINE> <INDENT> addtextparamtoparent(self, meta, k, v) | Add CORE-specific session meta-data XML elements.
| 625941b307f4c71912b1122c |
def parse(self): <NEW_LINE> <INDENT> self._validate_file() <NEW_LINE> self._parse_file() <NEW_LINE> self._enrich_groups() <NEW_LINE> self._validate_groups() <NEW_LINE> return self._generate_lists() | Parses input file and returns results.
Returns:
individuals: list of unassigned individuals
groups: list of groups with assigned individuals | 625941b3656771135c3eb618 |
def execute_update(etcd_client, tree, db): <NEW_LINE> <INDENT> lock = get_exclusive_lock(etcd_client, tree, db) <NEW_LINE> try: <NEW_LINE> <INDENT> affected_rows = 0 <NEW_LINE> table_columns = get_table_columns(etcd_client, db, tree.table) <NEW_LINE> for primary_key in list_table(etcd_client, db, tree.table): <NEW_LINE> <INDENT> table_row = get_row_by_primary_key(etcd_client, db, tree.table, primary_key) <NEW_LINE> key = '/{db}/{tbl}/{pk}'.format( db=db, tbl=tree.table, pk=primary_key ) <NEW_LINE> row = {} <NEW_LINE> for column in table_columns: <NEW_LINE> <INDENT> index = table_columns.index(column) <NEW_LINE> row[str(column)] = table_row[index] <NEW_LINE> <DEDENT> for update_fields in tree.expressions: <NEW_LINE> <INDENT> field_name, field_expression = update_fields <NEW_LINE> field_value = eval_expr(table_row, field_expression) <NEW_LINE> row[field_name] = field_value[1] <NEW_LINE> <DEDENT> if tree.where: <NEW_LINE> <INDENT> if eval_expr((table_columns, table_row), tree.where)[1]: <NEW_LINE> <INDENT> _update_key(etcd_client, key, json.dumps(row)) <NEW_LINE> affected_rows += 1 <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> _update_key(etcd_client, key, json.dumps(row)) <NEW_LINE> affected_rows += 1 <NEW_LINE> <DEDENT> <DEDENT> return affected_rows <NEW_LINE> <DEDENT> finally: <NEW_LINE> <INDENT> if tree.lock is None: <NEW_LINE> <INDENT> lock.release() | Execute UPDATE query | 625941b3bde94217f3682ba4 |
def _WriteFileEntry(self, file_entry, data_stream_name, destination_file): <NEW_LINE> <INDENT> source_file_object = file_entry.GetFileObject( data_stream_name=data_stream_name) <NEW_LINE> if not source_file_object: <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> try: <NEW_LINE> <INDENT> with open(destination_file, 'wb') as destination_file_object: <NEW_LINE> <INDENT> source_file_object.seek(0, os.SEEK_SET) <NEW_LINE> data = source_file_object.read(self._COPY_BUFFER_SIZE) <NEW_LINE> while data: <NEW_LINE> <INDENT> destination_file_object.write(data) <NEW_LINE> data = source_file_object.read(self._COPY_BUFFER_SIZE) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> finally: <NEW_LINE> <INDENT> source_file_object.close() | Writes the contents of the source file entry to a destination file.
Note that this function will overwrite an existing file.
Args:
file_entry (dfvfs.FileEntry): file entry whose content is to be written.
data_stream_name (str): name of the data stream whose content is to be
written.
destination_file (str): path of the destination file. | 625941b36aa9bd52df036b48 |
def eulerError(impExp): <NEW_LINE> <INDENT> assert impExp in ['imp', 'exp'] <NEW_LINE> if impExp == 'exp': h, eeX, eeV, tVals = expEuler(1, 0, np.pi/1000) <NEW_LINE> else: h, eeX, eeV, tVals = impEuler(1, 0, np.pi/1000) <NEW_LINE> tVals2 = np.copy(tVals) <NEW_LINE> analX = np.cos(tVals) <NEW_LINE> analV = -np.sin(tVals) <NEW_LINE> errX = analX - eeX <NEW_LINE> errV = analV - eeV <NEW_LINE> plt.plot(tVals, errX, color='red', label='x error') <NEW_LINE> plt.plot(tVals, errV, color='blue', label='v error') <NEW_LINE> plt.legend() <NEW_LINE> plt.xlabel('t') <NEW_LINE> fileString = 'ErrorOsc_x0_1.0_v0_0.0_h_'+str(round(h,3))+'.png' <NEW_LINE> if impExp == 'imp': fileString = 'imp' + fileString <NEW_LINE> plt.savefig(fileString) <NEW_LINE> plt.clf() | Plots the error between the Euler solution ('imp' or 'exp') and
the analytic solution to a simple harmonic oscillator with initial
conditions x0 = 1 and v0 = 0. | 625941b3d99f1b3c44c67346 |
def rsa_sign_gen(text: str, hash_algorithm, private_pem_str: str) -> bytes: <NEW_LINE> <INDENT> privateKey = RSA.importKey(private_pem_str) <NEW_LINE> data = hash_algorithm.new(text.encode("utf-8")) <NEW_LINE> pk = sign_pk.new(privateKey) <NEW_LINE> signature = pk.sign(data) <NEW_LINE> return signature | RSA私钥签名
:param text: 消息内容
:param hash_algorithm: 哈希算法 (type: function)
:param private_pem_str: 私钥
:return: 二进制的签名 | 625941b397e22403b379cd3e |
def _validate_mic_ticker(mic_ticker: str) -> bool: <NEW_LINE> <INDENT> valid = len(mic_ticker) >= 3 and mic_ticker[1:-1].count(":") == 1 <NEW_LINE> if not valid: <NEW_LINE> <INDENT> print( "mic:ticker must contain exactly one colon (:), and both 'mic' and 'ticker' must " "contain at least one character, but got:", mic_ticker, ) <NEW_LINE> <DEDENT> return valid | Validate MIC and ticker by the presence of a single colon (:) character.
Returns:
`True` if the given MIC and ticker are valid, `False` otherwise | 625941b3596a897236089871 |
def ppfGamma(p, shape, shift, scale): <NEW_LINE> <INDENT> return stats.gamma.ppf(p, shape, loc=shift, scale=scale) | Returns the evaluation of the percent point function (inverse cumulative
distribution) evaluated at the probability p for an Gamma
distribution. Usage:
ppfGamma(p, shape, shift, scale) | 625941b324f1403a92600918 |
def s_dprimed_matrix(self, layer): <NEW_LINE> <INDENT> s_dprime = self.i_matrix(layer, layer + 1) <NEW_LINE> for j in range(layer + 1, self.num_layers - 1): <NEW_LINE> <INDENT> l = self.l_matrix(j) <NEW_LINE> i = self.i_matrix(j, j + 1) <NEW_LINE> s_dprime = s_dprime @ l @ i <NEW_LINE> <DEDENT> return s_dprime | Returns the partial system transfer matrix s_dprime (doubled prime). | 625941b3b5575c28eb68dda3 |
def update(self, *args, **kwds): <NEW_LINE> <INDENT> mapping.update_checker(self, args, kwds) <NEW_LINE> other = () <NEW_LINE> if len(args) == 1: <NEW_LINE> <INDENT> other = args[0] <NEW_LINE> <DEDENT> if isinstance(other, dict): <NEW_LINE> <INDENT> _pairwise_iterator(self, other.items()) <NEW_LINE> <DEDENT> elif hasattr(other, "keys"): <NEW_LINE> <INDENT> _single_iterator(self, other, other.keys()) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> _pairwise_iterator(self, other) <NEW_LINE> <DEDENT> _pairwise_iterator(self, kwds.items()) | Update configuration from an iterable in `args`, and keyword
arguments in `kwds` | 625941b30383005118ecf38b |
def cover_button(self): <NEW_LINE> <INDENT> t = turtle.Turtle() <NEW_LINE> t.hideturtle() <NEW_LINE> t.speed(20) <NEW_LINE> t.penup() <NEW_LINE> t.goto(190,-260) <NEW_LINE> t.setheading(0) <NEW_LINE> t.color("#696969") <NEW_LINE> t.pendown() <NEW_LINE> t.begin_fill() <NEW_LINE> for y in range(2): <NEW_LINE> <INDENT> t.forward(150) <NEW_LINE> t.left(90) <NEW_LINE> t.forward(70) <NEW_LINE> t.left(90) <NEW_LINE> <DEDENT> t.end_fill() <NEW_LINE> t.goto(0,0) | Covers the play game button for when the user starts the game of nim.
:return: | 625941b3b7558d58953c4cc7 |
@pytest.fixture <NEW_LINE> def now(): <NEW_LINE> <INDENT> return datetime.datetime.now() | Now fixture, returns current datetime object | 625941b3460517430c393f38 |
def error_handler(self, view): <NEW_LINE> <INDENT> warnings.warn(FlaskWTFDeprecationWarning( '"@csrf.error_handler" is deprecated. Use the standard Flask error ' 'system with "@app.errorhandler(CsrfError)" instead. This will be' 'removed in 1.0.' ), stacklevel=2) <NEW_LINE> @wraps(view) <NEW_LINE> def handler(reason): <NEW_LINE> <INDENT> response = current_app.make_response(view(reason)) <NEW_LINE> raise CSRFError(response.get_data(as_text=True), response=response) <NEW_LINE> <DEDENT> self._error_response = handler <NEW_LINE> return view | Register a function that will generate the response for CSRF errors.
.. deprecated:: 0.14
Use the standard Flask error system with
``@app.errorhandler(CsrfError)`` instead. This will be removed in
version 1.0.
The function will be passed one argument, ``reason``. By default it will
raise a :class:`~flask_wtf.csrf.CsrfError`. ::
@csrf.error_handler
def csrf_error(reason):
return render_template('error.html', reason=reason)
Due to historical reasons, the function may either return a response
or raise an exception with :func:`flask.abort`. | 625941b3d18da76e23532276 |
Subsets and Splits