code
stringlengths
75
104k
docstring
stringlengths
1
46.9k
text
stringlengths
164
112k
def _gotitem(self, key: Union[str, List[str]], ndim: int, subset: Optional[Union[Series, ABCDataFrame]] = None, ) -> Union[Series, ABCDataFrame]: """ Sub-classes to define. Return a sliced object. Parameters ---------- key : string / list of selections ndim : 1,2 requested ndim of result subset : object, default None subset to act on """ if subset is None: subset = self elif subset.ndim == 1: # is Series return subset # TODO: _shallow_copy(subset)? return subset[key]
Sub-classes to define. Return a sliced object. Parameters ---------- key : string / list of selections ndim : 1,2 requested ndim of result subset : object, default None subset to act on
Below is the the instruction that describes the task: ### Input: Sub-classes to define. Return a sliced object. Parameters ---------- key : string / list of selections ndim : 1,2 requested ndim of result subset : object, default None subset to act on ### Response: def _gotitem(self, key: Union[str, List[str]], ndim: int, subset: Optional[Union[Series, ABCDataFrame]] = None, ) -> Union[Series, ABCDataFrame]: """ Sub-classes to define. Return a sliced object. Parameters ---------- key : string / list of selections ndim : 1,2 requested ndim of result subset : object, default None subset to act on """ if subset is None: subset = self elif subset.ndim == 1: # is Series return subset # TODO: _shallow_copy(subset)? return subset[key]
def _model_unpickle(cls, data): """Unpickle a model by retrieving it from the database.""" auto_field_value = data['pk'] try: obj = cls.objects.get(pk=auto_field_value) except Exception as e: if isinstance(e, OperationalError): # Attempt reconnect, we've probably hit; # OperationalError(2006, 'MySQL server has gone away') logger.debug("Caught OperationalError, closing database connection.", exc_info=e) from django.db import connection connection.close() obj = cls.objects.get(pk=auto_field_value) else: raise return obj
Unpickle a model by retrieving it from the database.
Below is the the instruction that describes the task: ### Input: Unpickle a model by retrieving it from the database. ### Response: def _model_unpickle(cls, data): """Unpickle a model by retrieving it from the database.""" auto_field_value = data['pk'] try: obj = cls.objects.get(pk=auto_field_value) except Exception as e: if isinstance(e, OperationalError): # Attempt reconnect, we've probably hit; # OperationalError(2006, 'MySQL server has gone away') logger.debug("Caught OperationalError, closing database connection.", exc_info=e) from django.db import connection connection.close() obj = cls.objects.get(pk=auto_field_value) else: raise return obj
def all(cls, domain=None): """ Return all sites @param domain: The domain to filter by @type domain: Domain @rtype: list of Site """ Site = cls site = Session.query(Site) if domain: site.filter(Site.domain == domain) return site.all()
Return all sites @param domain: The domain to filter by @type domain: Domain @rtype: list of Site
Below is the the instruction that describes the task: ### Input: Return all sites @param domain: The domain to filter by @type domain: Domain @rtype: list of Site ### Response: def all(cls, domain=None): """ Return all sites @param domain: The domain to filter by @type domain: Domain @rtype: list of Site """ Site = cls site = Session.query(Site) if domain: site.filter(Site.domain == domain) return site.all()
def list(self): '''Returns the `list` representation of this Key. Note that this method assumes the key is immutable. ''' if not self._list: self._list = map(Namespace, self._string.split('/')) return self._list
Returns the `list` representation of this Key. Note that this method assumes the key is immutable.
Below is the the instruction that describes the task: ### Input: Returns the `list` representation of this Key. Note that this method assumes the key is immutable. ### Response: def list(self): '''Returns the `list` representation of this Key. Note that this method assumes the key is immutable. ''' if not self._list: self._list = map(Namespace, self._string.split('/')) return self._list
def get(self, endpoint): '''Return the result of a GET request to `endpoint` on boatd''' json_body = urlopen(self.url(endpoint)).read().decode('utf-8') return json.loads(json_body)
Return the result of a GET request to `endpoint` on boatd
Below is the the instruction that describes the task: ### Input: Return the result of a GET request to `endpoint` on boatd ### Response: def get(self, endpoint): '''Return the result of a GET request to `endpoint` on boatd''' json_body = urlopen(self.url(endpoint)).read().decode('utf-8') return json.loads(json_body)
def conversions(self): """ Returns a string showing the available conversions. Useful tool in interactive mode. """ return "\n".join(str(self.to(unit)) for unit in self.supported_units)
Returns a string showing the available conversions. Useful tool in interactive mode.
Below is the the instruction that describes the task: ### Input: Returns a string showing the available conversions. Useful tool in interactive mode. ### Response: def conversions(self): """ Returns a string showing the available conversions. Useful tool in interactive mode. """ return "\n".join(str(self.to(unit)) for unit in self.supported_units)
def _bbox(nodes): """Get the bounding box for set of points. .. note:: There is also a Fortran implementation of this function, which will be used if it can be built. Args: nodes (numpy.ndarray): A set of points. Returns: Tuple[float, float, float, float]: The left, right, bottom and top bounds for the box. """ left, bottom = np.min(nodes, axis=1) right, top = np.max(nodes, axis=1) return left, right, bottom, top
Get the bounding box for set of points. .. note:: There is also a Fortran implementation of this function, which will be used if it can be built. Args: nodes (numpy.ndarray): A set of points. Returns: Tuple[float, float, float, float]: The left, right, bottom and top bounds for the box.
Below is the the instruction that describes the task: ### Input: Get the bounding box for set of points. .. note:: There is also a Fortran implementation of this function, which will be used if it can be built. Args: nodes (numpy.ndarray): A set of points. Returns: Tuple[float, float, float, float]: The left, right, bottom and top bounds for the box. ### Response: def _bbox(nodes): """Get the bounding box for set of points. .. note:: There is also a Fortran implementation of this function, which will be used if it can be built. Args: nodes (numpy.ndarray): A set of points. Returns: Tuple[float, float, float, float]: The left, right, bottom and top bounds for the box. """ left, bottom = np.min(nodes, axis=1) right, top = np.max(nodes, axis=1) return left, right, bottom, top
def on_to_state_edited(self, renderer, path, new_state_identifier): """Connects the outcome with a transition to the newly set state :param Gtk.CellRendererText renderer: The cell renderer that was edited :param str path: The path string of the renderer :param str new_state_identifier: An identifier for the new state that was selected """ def do_self_transition_check(t_id, new_state_identifier): # add self transition meta data if 'self' in new_state_identifier.split('.'): insert_self_transition_meta_data(self.model, t_id, 'outcomes_widget', combined_action=True) outcome_id = self.list_store[path][self.ID_STORAGE_ID] if outcome_id in self.dict_to_other_state or outcome_id in self.dict_to_other_outcome: transition_parent_state = self.model.parent.state if outcome_id in self.dict_to_other_state: t_id = self.dict_to_other_state[outcome_id][2] else: t_id = self.dict_to_other_outcome[outcome_id][2] if new_state_identifier is not None: to_state_id = new_state_identifier.split('.')[1] if not transition_parent_state.transitions[t_id].to_state == to_state_id: try: transition_parent_state.transitions[t_id].modify_target(to_state=to_state_id) do_self_transition_check(t_id, new_state_identifier) except ValueError as e: logger.warning("The target of transition couldn't be modified: {0}".format(e)) else: try: transition_parent_state.remove_transition(t_id) except AttributeError as e: logger.warning("The transition couldn't be removed: {0}".format(e)) else: # there is no transition till now if new_state_identifier is not None and not self.model.state.is_root_state: transition_parent_state = self.model.parent.state to_state_id = new_state_identifier.split('.')[1] try: t_id = transition_parent_state.add_transition(from_state_id=self.model.state.state_id, from_outcome=outcome_id, to_state_id=to_state_id, to_outcome=None, transition_id=None) do_self_transition_check(t_id, new_state_identifier) except (ValueError, TypeError) as e: logger.warning("The transition couldn't be added: {0}".format(e)) return else: logger.debug("outcome-editor got None in to_state-combo-change no transition is added")
Connects the outcome with a transition to the newly set state :param Gtk.CellRendererText renderer: The cell renderer that was edited :param str path: The path string of the renderer :param str new_state_identifier: An identifier for the new state that was selected
Below is the the instruction that describes the task: ### Input: Connects the outcome with a transition to the newly set state :param Gtk.CellRendererText renderer: The cell renderer that was edited :param str path: The path string of the renderer :param str new_state_identifier: An identifier for the new state that was selected ### Response: def on_to_state_edited(self, renderer, path, new_state_identifier): """Connects the outcome with a transition to the newly set state :param Gtk.CellRendererText renderer: The cell renderer that was edited :param str path: The path string of the renderer :param str new_state_identifier: An identifier for the new state that was selected """ def do_self_transition_check(t_id, new_state_identifier): # add self transition meta data if 'self' in new_state_identifier.split('.'): insert_self_transition_meta_data(self.model, t_id, 'outcomes_widget', combined_action=True) outcome_id = self.list_store[path][self.ID_STORAGE_ID] if outcome_id in self.dict_to_other_state or outcome_id in self.dict_to_other_outcome: transition_parent_state = self.model.parent.state if outcome_id in self.dict_to_other_state: t_id = self.dict_to_other_state[outcome_id][2] else: t_id = self.dict_to_other_outcome[outcome_id][2] if new_state_identifier is not None: to_state_id = new_state_identifier.split('.')[1] if not transition_parent_state.transitions[t_id].to_state == to_state_id: try: transition_parent_state.transitions[t_id].modify_target(to_state=to_state_id) do_self_transition_check(t_id, new_state_identifier) except ValueError as e: logger.warning("The target of transition couldn't be modified: {0}".format(e)) else: try: transition_parent_state.remove_transition(t_id) except AttributeError as e: logger.warning("The transition couldn't be removed: {0}".format(e)) else: # there is no transition till now if new_state_identifier is not None and not self.model.state.is_root_state: transition_parent_state = self.model.parent.state to_state_id = new_state_identifier.split('.')[1] try: t_id = transition_parent_state.add_transition(from_state_id=self.model.state.state_id, from_outcome=outcome_id, to_state_id=to_state_id, to_outcome=None, transition_id=None) do_self_transition_check(t_id, new_state_identifier) except (ValueError, TypeError) as e: logger.warning("The transition couldn't be added: {0}".format(e)) return else: logger.debug("outcome-editor got None in to_state-combo-change no transition is added")
def run(self, subcmd_name, arg): """Run subcmd_name with args using obj for the environent""" entry=self.lookup(subcmd_name) if entry: entry['callback'](arg) else: self.cmdproc.undefined_cmd(entry.__class__.name, subcmd_name) pass return
Run subcmd_name with args using obj for the environent
Below is the the instruction that describes the task: ### Input: Run subcmd_name with args using obj for the environent ### Response: def run(self, subcmd_name, arg): """Run subcmd_name with args using obj for the environent""" entry=self.lookup(subcmd_name) if entry: entry['callback'](arg) else: self.cmdproc.undefined_cmd(entry.__class__.name, subcmd_name) pass return
def get_page_number_from_request( request, querystring_key=PAGE_LABEL, default=1): """Retrieve the current page number from *GET* or *POST* data. If the page does not exists in *request*, or is not a number, then *default* number is returned. """ try: return int(request.GET[querystring_key]) except (KeyError, TypeError, ValueError): return default
Retrieve the current page number from *GET* or *POST* data. If the page does not exists in *request*, or is not a number, then *default* number is returned.
Below is the the instruction that describes the task: ### Input: Retrieve the current page number from *GET* or *POST* data. If the page does not exists in *request*, or is not a number, then *default* number is returned. ### Response: def get_page_number_from_request( request, querystring_key=PAGE_LABEL, default=1): """Retrieve the current page number from *GET* or *POST* data. If the page does not exists in *request*, or is not a number, then *default* number is returned. """ try: return int(request.GET[querystring_key]) except (KeyError, TypeError, ValueError): return default
def _mirror_idx_cov(self, f_values, idx1): # will most likely be removed """obsolete and subject to removal (TODO), return indices for negative ("active") update of the covariance matrix assuming that ``f_values[idx1[i]]`` and ``f_values[-1-i]`` are the corresponding mirrored values computes the index of the worse solution sorted by the f-value of the better solution. TODO: when the actual mirror was rejected, it is better to return idx1 instead of idx2. Remark: this function might not be necessary at all: if the worst solution is the best mirrored, the covariance matrix updates cancel (cave: weights and learning rates), which seems what is desirable. If the mirror is bad, as strong negative update is made, again what is desirable. And the fitness--step-length correlation is in part addressed by using flat weights. """ idx2 = np.arange(len(f_values) - 1, len(f_values) - 1 - len(idx1), -1) f = [] for i in rglen((idx1)): f.append(min((f_values[idx1[i]], f_values[idx2[i]]))) # idx.append(idx1[i] if f_values[idx1[i]] > f_values[idx2[i]] else idx2[i]) return idx2[np.argsort(f)][-1::-1]
obsolete and subject to removal (TODO), return indices for negative ("active") update of the covariance matrix assuming that ``f_values[idx1[i]]`` and ``f_values[-1-i]`` are the corresponding mirrored values computes the index of the worse solution sorted by the f-value of the better solution. TODO: when the actual mirror was rejected, it is better to return idx1 instead of idx2. Remark: this function might not be necessary at all: if the worst solution is the best mirrored, the covariance matrix updates cancel (cave: weights and learning rates), which seems what is desirable. If the mirror is bad, as strong negative update is made, again what is desirable. And the fitness--step-length correlation is in part addressed by using flat weights.
Below is the the instruction that describes the task: ### Input: obsolete and subject to removal (TODO), return indices for negative ("active") update of the covariance matrix assuming that ``f_values[idx1[i]]`` and ``f_values[-1-i]`` are the corresponding mirrored values computes the index of the worse solution sorted by the f-value of the better solution. TODO: when the actual mirror was rejected, it is better to return idx1 instead of idx2. Remark: this function might not be necessary at all: if the worst solution is the best mirrored, the covariance matrix updates cancel (cave: weights and learning rates), which seems what is desirable. If the mirror is bad, as strong negative update is made, again what is desirable. And the fitness--step-length correlation is in part addressed by using flat weights. ### Response: def _mirror_idx_cov(self, f_values, idx1): # will most likely be removed """obsolete and subject to removal (TODO), return indices for negative ("active") update of the covariance matrix assuming that ``f_values[idx1[i]]`` and ``f_values[-1-i]`` are the corresponding mirrored values computes the index of the worse solution sorted by the f-value of the better solution. TODO: when the actual mirror was rejected, it is better to return idx1 instead of idx2. Remark: this function might not be necessary at all: if the worst solution is the best mirrored, the covariance matrix updates cancel (cave: weights and learning rates), which seems what is desirable. If the mirror is bad, as strong negative update is made, again what is desirable. And the fitness--step-length correlation is in part addressed by using flat weights. """ idx2 = np.arange(len(f_values) - 1, len(f_values) - 1 - len(idx1), -1) f = [] for i in rglen((idx1)): f.append(min((f_values[idx1[i]], f_values[idx2[i]]))) # idx.append(idx1[i] if f_values[idx1[i]] > f_values[idx2[i]] else idx2[i]) return idx2[np.argsort(f)][-1::-1]
async def release_cursor(self, cursor, in_transaction=False): """Release cursor coroutine. Unless in transaction, the connection is also released back to the pool. """ conn = cursor.connection await cursor.close() if not in_transaction: self.release(conn)
Release cursor coroutine. Unless in transaction, the connection is also released back to the pool.
Below is the the instruction that describes the task: ### Input: Release cursor coroutine. Unless in transaction, the connection is also released back to the pool. ### Response: async def release_cursor(self, cursor, in_transaction=False): """Release cursor coroutine. Unless in transaction, the connection is also released back to the pool. """ conn = cursor.connection await cursor.close() if not in_transaction: self.release(conn)
def union(df, other, index=False, keep='first'): """ Returns rows that appear in either DataFrame. Args: df (pandas.DataFrame): data passed in through the pipe. other (pandas.DataFrame): other DataFrame to use for set operation with the first. Kwargs: index (bool): Boolean indicating whether to consider the pandas index as part of the set operation (default `False`). keep (str): Indicates which duplicate should be kept. Options are `'first'` and `'last'`. """ validate_set_ops(df, other) stacked = df.append(other) if index: stacked_reset_indexes = stacked.reset_index() index_cols = [col for col in stacked_reset_indexes.columns if col not in df.columns] index_name = df.index.names return_df = stacked_reset_indexes.drop_duplicates(keep=keep).set_index(index_cols) return_df.index.names = index_name return return_df else: return stacked.drop_duplicates(keep=keep)
Returns rows that appear in either DataFrame. Args: df (pandas.DataFrame): data passed in through the pipe. other (pandas.DataFrame): other DataFrame to use for set operation with the first. Kwargs: index (bool): Boolean indicating whether to consider the pandas index as part of the set operation (default `False`). keep (str): Indicates which duplicate should be kept. Options are `'first'` and `'last'`.
Below is the the instruction that describes the task: ### Input: Returns rows that appear in either DataFrame. Args: df (pandas.DataFrame): data passed in through the pipe. other (pandas.DataFrame): other DataFrame to use for set operation with the first. Kwargs: index (bool): Boolean indicating whether to consider the pandas index as part of the set operation (default `False`). keep (str): Indicates which duplicate should be kept. Options are `'first'` and `'last'`. ### Response: def union(df, other, index=False, keep='first'): """ Returns rows that appear in either DataFrame. Args: df (pandas.DataFrame): data passed in through the pipe. other (pandas.DataFrame): other DataFrame to use for set operation with the first. Kwargs: index (bool): Boolean indicating whether to consider the pandas index as part of the set operation (default `False`). keep (str): Indicates which duplicate should be kept. Options are `'first'` and `'last'`. """ validate_set_ops(df, other) stacked = df.append(other) if index: stacked_reset_indexes = stacked.reset_index() index_cols = [col for col in stacked_reset_indexes.columns if col not in df.columns] index_name = df.index.names return_df = stacked_reset_indexes.drop_duplicates(keep=keep).set_index(index_cols) return_df.index.names = index_name return return_df else: return stacked.drop_duplicates(keep=keep)
def spawn_process(self, port): """Create an Application and HTTPServer for the given port. :param int port: The port to listen on :rtype: multiprocessing.Process """ return process.Process(name="ServerProcess.%i" % port, kwargs={'namespace': self.namespace, 'port': port})
Create an Application and HTTPServer for the given port. :param int port: The port to listen on :rtype: multiprocessing.Process
Below is the the instruction that describes the task: ### Input: Create an Application and HTTPServer for the given port. :param int port: The port to listen on :rtype: multiprocessing.Process ### Response: def spawn_process(self, port): """Create an Application and HTTPServer for the given port. :param int port: The port to listen on :rtype: multiprocessing.Process """ return process.Process(name="ServerProcess.%i" % port, kwargs={'namespace': self.namespace, 'port': port})
def buildingname(ddtt): """return building name""" idf = ddtt.theidf building = idf.idfobjects['building'.upper()][0] return building.Name
return building name
Below is the the instruction that describes the task: ### Input: return building name ### Response: def buildingname(ddtt): """return building name""" idf = ddtt.theidf building = idf.idfobjects['building'.upper()][0] return building.Name
def probability_of_n_purchases_up_to_time(self, t, n): r""" Compute the probability of n purchases. .. math:: P( N(t) = n | \text{model} ) where N(t) is the number of repeat purchases a customer makes in t units of time. Parameters ---------- t: float number units of time n: int number of purchases Returns ------- float: Probability to have n purchases up to t units of time """ r, alpha, a, b = self._unload_params("r", "alpha", "a", "b") first_term = ( beta(a, b + n) / beta(a, b) * gamma(r + n) / gamma(r) / gamma(n + 1) * (alpha / (alpha + t)) ** r * (t / (alpha + t)) ** n ) if n > 0: j = np.arange(0, n) finite_sum = (gamma(r + j) / gamma(r) / gamma(j + 1) * (t / (alpha + t)) ** j).sum() second_term = beta(a + 1, b + n - 1) / beta(a, b) * (1 - (alpha / (alpha + t)) ** r * finite_sum) else: second_term = 0 return first_term + second_term
r""" Compute the probability of n purchases. .. math:: P( N(t) = n | \text{model} ) where N(t) is the number of repeat purchases a customer makes in t units of time. Parameters ---------- t: float number units of time n: int number of purchases Returns ------- float: Probability to have n purchases up to t units of time
Below is the the instruction that describes the task: ### Input: r""" Compute the probability of n purchases. .. math:: P( N(t) = n | \text{model} ) where N(t) is the number of repeat purchases a customer makes in t units of time. Parameters ---------- t: float number units of time n: int number of purchases Returns ------- float: Probability to have n purchases up to t units of time ### Response: def probability_of_n_purchases_up_to_time(self, t, n): r""" Compute the probability of n purchases. .. math:: P( N(t) = n | \text{model} ) where N(t) is the number of repeat purchases a customer makes in t units of time. Parameters ---------- t: float number units of time n: int number of purchases Returns ------- float: Probability to have n purchases up to t units of time """ r, alpha, a, b = self._unload_params("r", "alpha", "a", "b") first_term = ( beta(a, b + n) / beta(a, b) * gamma(r + n) / gamma(r) / gamma(n + 1) * (alpha / (alpha + t)) ** r * (t / (alpha + t)) ** n ) if n > 0: j = np.arange(0, n) finite_sum = (gamma(r + j) / gamma(r) / gamma(j + 1) * (t / (alpha + t)) ** j).sum() second_term = beta(a + 1, b + n - 1) / beta(a, b) * (1 - (alpha / (alpha + t)) ** r * finite_sum) else: second_term = 0 return first_term + second_term
def unmount(self, cid): """ Unmounts and cleans-up after a previous mount(). """ driver = self.client.info()['Driver'] driver_unmount_fn = getattr(self, "_unmount_" + driver, self._unsupported_backend) driver_unmount_fn(cid)
Unmounts and cleans-up after a previous mount().
Below is the the instruction that describes the task: ### Input: Unmounts and cleans-up after a previous mount(). ### Response: def unmount(self, cid): """ Unmounts and cleans-up after a previous mount(). """ driver = self.client.info()['Driver'] driver_unmount_fn = getattr(self, "_unmount_" + driver, self._unsupported_backend) driver_unmount_fn(cid)
def user_method(user_event): """Decorator of the Pdb user_* methods that controls the RemoteSocket.""" def wrapper(self, *args): stdin = self.stdin is_sock = isinstance(stdin, RemoteSocket) try: try: if is_sock and not stdin.connect(): return return user_event(self, *args) except Exception: self.close() raise finally: if is_sock and stdin.closed(): self.do_detach(None) return wrapper
Decorator of the Pdb user_* methods that controls the RemoteSocket.
Below is the the instruction that describes the task: ### Input: Decorator of the Pdb user_* methods that controls the RemoteSocket. ### Response: def user_method(user_event): """Decorator of the Pdb user_* methods that controls the RemoteSocket.""" def wrapper(self, *args): stdin = self.stdin is_sock = isinstance(stdin, RemoteSocket) try: try: if is_sock and not stdin.connect(): return return user_event(self, *args) except Exception: self.close() raise finally: if is_sock and stdin.closed(): self.do_detach(None) return wrapper
def _get_contig_id(contig_str): """Tries to retrieve contig id. Returns the original string if it is unable to retrieve the id. Parameters ---------- contig_str : str Full contig string (fasta header) Returns ------- str Contig id """ contig_id = contig_str try: contig_id = re.search(".*NODE_([0-9]*)_.*", contig_str).group(1) except AttributeError: pass try: contig_id = re.search(".*Contig_([0-9]*)_.*", contig_str).group(1) except AttributeError: pass return contig_id
Tries to retrieve contig id. Returns the original string if it is unable to retrieve the id. Parameters ---------- contig_str : str Full contig string (fasta header) Returns ------- str Contig id
Below is the the instruction that describes the task: ### Input: Tries to retrieve contig id. Returns the original string if it is unable to retrieve the id. Parameters ---------- contig_str : str Full contig string (fasta header) Returns ------- str Contig id ### Response: def _get_contig_id(contig_str): """Tries to retrieve contig id. Returns the original string if it is unable to retrieve the id. Parameters ---------- contig_str : str Full contig string (fasta header) Returns ------- str Contig id """ contig_id = contig_str try: contig_id = re.search(".*NODE_([0-9]*)_.*", contig_str).group(1) except AttributeError: pass try: contig_id = re.search(".*Contig_([0-9]*)_.*", contig_str).group(1) except AttributeError: pass return contig_id
def upgrade(self, only): """Remove all package lists with changelog and checksums files and create lists again""" repositories = self.meta.repositories if only: repositories = only for repo in repositories: changelogs = "{0}{1}{2}".format(self.log_path, repo, "/ChangeLog.txt") if os.path.isfile(changelogs): os.remove(changelogs) if os.path.isdir(self.lib_path + "{0}_repo/".format(repo)): for f in (os.listdir(self.lib_path + "{0}_repo/".format( repo))): files = "{0}{1}_repo/{2}".format(self.lib_path, repo, f) if os.path.isfile(files): os.remove(files) elif os.path.isdir(files): shutil.rmtree(files) Update().repository(only)
Remove all package lists with changelog and checksums files and create lists again
Below is the the instruction that describes the task: ### Input: Remove all package lists with changelog and checksums files and create lists again ### Response: def upgrade(self, only): """Remove all package lists with changelog and checksums files and create lists again""" repositories = self.meta.repositories if only: repositories = only for repo in repositories: changelogs = "{0}{1}{2}".format(self.log_path, repo, "/ChangeLog.txt") if os.path.isfile(changelogs): os.remove(changelogs) if os.path.isdir(self.lib_path + "{0}_repo/".format(repo)): for f in (os.listdir(self.lib_path + "{0}_repo/".format( repo))): files = "{0}{1}_repo/{2}".format(self.lib_path, repo, f) if os.path.isfile(files): os.remove(files) elif os.path.isdir(files): shutil.rmtree(files) Update().repository(only)
def delete(self, request, bot_id, id, format=None): """ Delete existing Messenger Bot --- responseMessages: - code: 401 message: Not authenticated """ return super(MessengerBotDetail, self).delete(request, bot_id, id, format)
Delete existing Messenger Bot --- responseMessages: - code: 401 message: Not authenticated
Below is the the instruction that describes the task: ### Input: Delete existing Messenger Bot --- responseMessages: - code: 401 message: Not authenticated ### Response: def delete(self, request, bot_id, id, format=None): """ Delete existing Messenger Bot --- responseMessages: - code: 401 message: Not authenticated """ return super(MessengerBotDetail, self).delete(request, bot_id, id, format)
def RdatabasesBM(host=rbiomart_host): """ Lists BioMart databases through a RPY2 connection. :param host: address of the host server, default='www.ensembl.org' :returns: nothing """ biomaRt = importr("biomaRt") print(biomaRt.listMarts(host=host))
Lists BioMart databases through a RPY2 connection. :param host: address of the host server, default='www.ensembl.org' :returns: nothing
Below is the the instruction that describes the task: ### Input: Lists BioMart databases through a RPY2 connection. :param host: address of the host server, default='www.ensembl.org' :returns: nothing ### Response: def RdatabasesBM(host=rbiomart_host): """ Lists BioMart databases through a RPY2 connection. :param host: address of the host server, default='www.ensembl.org' :returns: nothing """ biomaRt = importr("biomaRt") print(biomaRt.listMarts(host=host))
def locate(connection, agent_id): ''' Return the hostname of the agency where given agent runs or None. ''' connection = IDatabaseClient(connection) log.log('locate', 'Locate called for agent_id: %r', agent_id) try: desc = yield connection.get_document(agent_id) log.log('locate', 'Got document %r', desc) if isinstance(desc, host.Descriptor): defer.returnValue(desc.hostname) elif isinstance(desc, descriptor.Descriptor): host_part = first(x for x in desc.partners if x.role == 'host') if host_part is None: log.log('locate', 'No host partner found in descriptor.') defer.returnValue(None) res = yield locate(connection, host_part.recipient.key) defer.returnValue(res) except NotFoundError: log.log('locate', 'Host with id %r not found, returning None', agent_id) defer.returnValue(None)
Return the hostname of the agency where given agent runs or None.
Below is the the instruction that describes the task: ### Input: Return the hostname of the agency where given agent runs or None. ### Response: def locate(connection, agent_id): ''' Return the hostname of the agency where given agent runs or None. ''' connection = IDatabaseClient(connection) log.log('locate', 'Locate called for agent_id: %r', agent_id) try: desc = yield connection.get_document(agent_id) log.log('locate', 'Got document %r', desc) if isinstance(desc, host.Descriptor): defer.returnValue(desc.hostname) elif isinstance(desc, descriptor.Descriptor): host_part = first(x for x in desc.partners if x.role == 'host') if host_part is None: log.log('locate', 'No host partner found in descriptor.') defer.returnValue(None) res = yield locate(connection, host_part.recipient.key) defer.returnValue(res) except NotFoundError: log.log('locate', 'Host with id %r not found, returning None', agent_id) defer.returnValue(None)
def config(key, default=None): """ Shortcut to access the application's config in your class :param key: The key to access :param default: The default value when None :returns mixed: """ return Mocha._app.config.get(key, default) if Mocha._app else default
Shortcut to access the application's config in your class :param key: The key to access :param default: The default value when None :returns mixed:
Below is the the instruction that describes the task: ### Input: Shortcut to access the application's config in your class :param key: The key to access :param default: The default value when None :returns mixed: ### Response: def config(key, default=None): """ Shortcut to access the application's config in your class :param key: The key to access :param default: The default value when None :returns mixed: """ return Mocha._app.config.get(key, default) if Mocha._app else default
def firmware_download_input_protocol_type_ftp_protocol_ftp_password(self, **kwargs): """Auto Generated Code """ config = ET.Element("config") firmware_download = ET.Element("firmware_download") config = firmware_download input = ET.SubElement(firmware_download, "input") protocol_type = ET.SubElement(input, "protocol-type") ftp_protocol = ET.SubElement(protocol_type, "ftp-protocol") ftp = ET.SubElement(ftp_protocol, "ftp") password = ET.SubElement(ftp, "password") password.text = kwargs.pop('password') callback = kwargs.pop('callback', self._callback) return callback(config)
Auto Generated Code
Below is the the instruction that describes the task: ### Input: Auto Generated Code ### Response: def firmware_download_input_protocol_type_ftp_protocol_ftp_password(self, **kwargs): """Auto Generated Code """ config = ET.Element("config") firmware_download = ET.Element("firmware_download") config = firmware_download input = ET.SubElement(firmware_download, "input") protocol_type = ET.SubElement(input, "protocol-type") ftp_protocol = ET.SubElement(protocol_type, "ftp-protocol") ftp = ET.SubElement(ftp_protocol, "ftp") password = ET.SubElement(ftp, "password") password.text = kwargs.pop('password') callback = kwargs.pop('callback', self._callback) return callback(config)
def get_resource_method(name, template): """ Creates a function that is suitable as a method for ResourceCollection. """ def rsr_meth(self, **kwargs): http_method = template['http_method'] extra_path = template.get('extra_path') if extra_path: fills = {'res_id': kwargs.pop('res_id', '')} path = self.path + (extra_path % fills) else: path = self.path response = self.client.request(http_method, path, **kwargs) loc = response.headers.get('location', None) if loc: # If the returned code is a 201, then there should be a location # header in the response that we can use to re-get the newly created # resource. loc = response.headers.get('location') response = self.client.get(loc, **kwargs) # At this point, we better have a valid JSON response object try: obj = response.json() except: # The response had no JSON ... not a resource object return if COLLECTION_TYPE in response.content_type: ret = HookList( [Resource(r, path, response, self.client) for r in obj], response=response ) else: ret = Resource(obj, path, response, self.client) return ret rsr_meth.__name__ = name return rsr_meth
Creates a function that is suitable as a method for ResourceCollection.
Below is the the instruction that describes the task: ### Input: Creates a function that is suitable as a method for ResourceCollection. ### Response: def get_resource_method(name, template): """ Creates a function that is suitable as a method for ResourceCollection. """ def rsr_meth(self, **kwargs): http_method = template['http_method'] extra_path = template.get('extra_path') if extra_path: fills = {'res_id': kwargs.pop('res_id', '')} path = self.path + (extra_path % fills) else: path = self.path response = self.client.request(http_method, path, **kwargs) loc = response.headers.get('location', None) if loc: # If the returned code is a 201, then there should be a location # header in the response that we can use to re-get the newly created # resource. loc = response.headers.get('location') response = self.client.get(loc, **kwargs) # At this point, we better have a valid JSON response object try: obj = response.json() except: # The response had no JSON ... not a resource object return if COLLECTION_TYPE in response.content_type: ret = HookList( [Resource(r, path, response, self.client) for r in obj], response=response ) else: ret = Resource(obj, path, response, self.client) return ret rsr_meth.__name__ = name return rsr_meth
def _doAction(self, action): """This function will perform a FileMaker action.""" if self._db == '': raise FMError, 'No database was selected' result = '' try: request = [ uu({'-db': self._db }) ] if self._layout != '': request.append(uu({'-lay': self._layout })) if action == '-find' and self._lop != 'and': request.append(uu({'-lop': self._lop })) if action in ['-find', '-findall']: if self._skipRecords != 0: request.append(uu({ '-skip': self._skipRecords })) if self._maxRecords != 0: request.append(uu({ '-max': self._maxRecords })) for i in range(0, len(self._sortParams)): sort = self._sortParams[i] request.append(uu({ '-sortfield.'+str(i+1): sort[0] })) if sort[1] != '': request.append(uu({ '-sortorder.'+str(i+1): sort[1] })) for dbParam in self._dbParams: if dbParam[0] == 'RECORDID': request.append(uu({ '-recid': dbParam[1] })) elif dbParam[0] == 'MODID': request.append(uu({ '-modid': dbParam[1] })) elif hasattr(dbParam[1], 'strftime'): d = dbParam[1] if (not hasattr(d, 'second')): request.append(uu({ dbParam[0]: d.strftime('%m-%d-%Y') })) else: request.append(uu({ dbParam[0]: d.strftime('%m-%d-%Y %H:%M:%S') })) del(d) else: request.append(uu({ dbParam[0]: dbParam[1] })) request.append(action) if self._extra_script: request += self._extra_script self._extra_script = None result = self._doRequest(request) try: result = FMResultset.FMResultset(result) except FMFieldError, value: realfields = FMServer(self._buildUrl(), self._db, self._layout).doView() l = [] for k, v in self._dbParams: if k[-3:] != '.op' and k[0] != '-': l.append(("'%s'" % k.replace('::','.')).encode('utf-8')) raise FMError, "Field(s) %s not found on layout '%s'" % (', '.join(l), self._layout) if action == '-view': result = result.fieldNames finally: self._dbParams = [] self._sortParams = [] self._skipRecords = 0 self._maxRecords = 0 self._lop = 'and' return result
This function will perform a FileMaker action.
Below is the the instruction that describes the task: ### Input: This function will perform a FileMaker action. ### Response: def _doAction(self, action): """This function will perform a FileMaker action.""" if self._db == '': raise FMError, 'No database was selected' result = '' try: request = [ uu({'-db': self._db }) ] if self._layout != '': request.append(uu({'-lay': self._layout })) if action == '-find' and self._lop != 'and': request.append(uu({'-lop': self._lop })) if action in ['-find', '-findall']: if self._skipRecords != 0: request.append(uu({ '-skip': self._skipRecords })) if self._maxRecords != 0: request.append(uu({ '-max': self._maxRecords })) for i in range(0, len(self._sortParams)): sort = self._sortParams[i] request.append(uu({ '-sortfield.'+str(i+1): sort[0] })) if sort[1] != '': request.append(uu({ '-sortorder.'+str(i+1): sort[1] })) for dbParam in self._dbParams: if dbParam[0] == 'RECORDID': request.append(uu({ '-recid': dbParam[1] })) elif dbParam[0] == 'MODID': request.append(uu({ '-modid': dbParam[1] })) elif hasattr(dbParam[1], 'strftime'): d = dbParam[1] if (not hasattr(d, 'second')): request.append(uu({ dbParam[0]: d.strftime('%m-%d-%Y') })) else: request.append(uu({ dbParam[0]: d.strftime('%m-%d-%Y %H:%M:%S') })) del(d) else: request.append(uu({ dbParam[0]: dbParam[1] })) request.append(action) if self._extra_script: request += self._extra_script self._extra_script = None result = self._doRequest(request) try: result = FMResultset.FMResultset(result) except FMFieldError, value: realfields = FMServer(self._buildUrl(), self._db, self._layout).doView() l = [] for k, v in self._dbParams: if k[-3:] != '.op' and k[0] != '-': l.append(("'%s'" % k.replace('::','.')).encode('utf-8')) raise FMError, "Field(s) %s not found on layout '%s'" % (', '.join(l), self._layout) if action == '-view': result = result.fieldNames finally: self._dbParams = [] self._sortParams = [] self._skipRecords = 0 self._maxRecords = 0 self._lop = 'and' return result
def __load(self): """ Loads dynamically the class that acts like a namespace for constants. """ parts = self.__class_name.split('.') module_name = ".".join(parts[:-1]) module = __import__(module_name) modules = [] for comp in parts[1:]: module = getattr(module, comp) modules.append(module) self.__module = modules[-2]
Loads dynamically the class that acts like a namespace for constants.
Below is the the instruction that describes the task: ### Input: Loads dynamically the class that acts like a namespace for constants. ### Response: def __load(self): """ Loads dynamically the class that acts like a namespace for constants. """ parts = self.__class_name.split('.') module_name = ".".join(parts[:-1]) module = __import__(module_name) modules = [] for comp in parts[1:]: module = getattr(module, comp) modules.append(module) self.__module = modules[-2]
def _get_calibration_for_mchits(hits, lookup): """Append the position, direction and t0 columns and add t0 to time""" n_hits = len(hits) cal = np.empty((n_hits, 9)) for i in range(n_hits): cal[i] = lookup[hits['pmt_id'][i]] dir_x = cal[:, 3] dir_y = cal[:, 4] dir_z = cal[:, 5] du = cal[:, 7] floor = cal[:, 8] pos_x = cal[:, 0] pos_y = cal[:, 1] pos_z = cal[:, 2] t0 = cal[:, 6] return [dir_x, dir_y, dir_z, du, floor, pos_x, pos_y, pos_z, t0]
Append the position, direction and t0 columns and add t0 to time
Below is the the instruction that describes the task: ### Input: Append the position, direction and t0 columns and add t0 to time ### Response: def _get_calibration_for_mchits(hits, lookup): """Append the position, direction and t0 columns and add t0 to time""" n_hits = len(hits) cal = np.empty((n_hits, 9)) for i in range(n_hits): cal[i] = lookup[hits['pmt_id'][i]] dir_x = cal[:, 3] dir_y = cal[:, 4] dir_z = cal[:, 5] du = cal[:, 7] floor = cal[:, 8] pos_x = cal[:, 0] pos_y = cal[:, 1] pos_z = cal[:, 2] t0 = cal[:, 6] return [dir_x, dir_y, dir_z, du, floor, pos_x, pos_y, pos_z, t0]
def _set_lsp_frr(self, v, load=False): """ Setter method for lsp_frr, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_frr (container) If this variable is read-only (config: false) in the source YANG file, then _set_lsp_frr is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_lsp_frr() directly. """ if hasattr(v, "_utype"): v = v._utype(v) try: t = YANGDynClass(v,base=lsp_frr.lsp_frr, is_container='container', presence=True, yang_name="lsp-frr", rest_name="frr", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Set Fast Reroute options', u'callpoint': u'MplsLspFrr', u'cli-full-command': None, u'cli-add-mode': None, u'alt-name': u'frr', u'cli-mode-name': u'config-router-mpls-lsp-$(lsp-name)-frr'}}, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='container', is_config=True) except (TypeError, ValueError): raise ValueError({ 'error-string': """lsp_frr must be of a type compatible with container""", 'defined-type': "container", 'generated-type': """YANGDynClass(base=lsp_frr.lsp_frr, is_container='container', presence=True, yang_name="lsp-frr", rest_name="frr", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Set Fast Reroute options', u'callpoint': u'MplsLspFrr', u'cli-full-command': None, u'cli-add-mode': None, u'alt-name': u'frr', u'cli-mode-name': u'config-router-mpls-lsp-$(lsp-name)-frr'}}, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='container', is_config=True)""", }) self.__lsp_frr = t if hasattr(self, '_set'): self._set()
Setter method for lsp_frr, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_frr (container) If this variable is read-only (config: false) in the source YANG file, then _set_lsp_frr is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_lsp_frr() directly.
Below is the the instruction that describes the task: ### Input: Setter method for lsp_frr, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_frr (container) If this variable is read-only (config: false) in the source YANG file, then _set_lsp_frr is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_lsp_frr() directly. ### Response: def _set_lsp_frr(self, v, load=False): """ Setter method for lsp_frr, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_frr (container) If this variable is read-only (config: false) in the source YANG file, then _set_lsp_frr is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_lsp_frr() directly. """ if hasattr(v, "_utype"): v = v._utype(v) try: t = YANGDynClass(v,base=lsp_frr.lsp_frr, is_container='container', presence=True, yang_name="lsp-frr", rest_name="frr", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Set Fast Reroute options', u'callpoint': u'MplsLspFrr', u'cli-full-command': None, u'cli-add-mode': None, u'alt-name': u'frr', u'cli-mode-name': u'config-router-mpls-lsp-$(lsp-name)-frr'}}, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='container', is_config=True) except (TypeError, ValueError): raise ValueError({ 'error-string': """lsp_frr must be of a type compatible with container""", 'defined-type': "container", 'generated-type': """YANGDynClass(base=lsp_frr.lsp_frr, is_container='container', presence=True, yang_name="lsp-frr", rest_name="frr", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Set Fast Reroute options', u'callpoint': u'MplsLspFrr', u'cli-full-command': None, u'cli-add-mode': None, u'alt-name': u'frr', u'cli-mode-name': u'config-router-mpls-lsp-$(lsp-name)-frr'}}, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='container', is_config=True)""", }) self.__lsp_frr = t if hasattr(self, '_set'): self._set()
def send(self, relative_path, http_method, **requests_args): """ Makes an API-key-authorized request :param relative_path: URL path relative to self.base_url :param http_method: HTTP method :param requests_args: kwargs to be sent to requests :type relative_path: str :type http_method: str :type requests_args: kwargs :return: A request response object :raise: CartoException """ try: http_method, requests_args = self.prepare_send(http_method, **requests_args) response = super(APIKeyAuthClient, self).send(relative_path, http_method, **requests_args) except Exception as e: raise CartoException(e) if CartoRateLimitException.is_rate_limited(response): raise CartoRateLimitException(response) return response
Makes an API-key-authorized request :param relative_path: URL path relative to self.base_url :param http_method: HTTP method :param requests_args: kwargs to be sent to requests :type relative_path: str :type http_method: str :type requests_args: kwargs :return: A request response object :raise: CartoException
Below is the the instruction that describes the task: ### Input: Makes an API-key-authorized request :param relative_path: URL path relative to self.base_url :param http_method: HTTP method :param requests_args: kwargs to be sent to requests :type relative_path: str :type http_method: str :type requests_args: kwargs :return: A request response object :raise: CartoException ### Response: def send(self, relative_path, http_method, **requests_args): """ Makes an API-key-authorized request :param relative_path: URL path relative to self.base_url :param http_method: HTTP method :param requests_args: kwargs to be sent to requests :type relative_path: str :type http_method: str :type requests_args: kwargs :return: A request response object :raise: CartoException """ try: http_method, requests_args = self.prepare_send(http_method, **requests_args) response = super(APIKeyAuthClient, self).send(relative_path, http_method, **requests_args) except Exception as e: raise CartoException(e) if CartoRateLimitException.is_rate_limited(response): raise CartoRateLimitException(response) return response
def open(self, tile, process, **kwargs): """ Open process output as input for other process. Parameters ---------- tile : ``Tile`` process : ``MapcheteProcess`` kwargs : keyword arguments """ return InputTile(tile, process, kwargs.get("resampling", None))
Open process output as input for other process. Parameters ---------- tile : ``Tile`` process : ``MapcheteProcess`` kwargs : keyword arguments
Below is the the instruction that describes the task: ### Input: Open process output as input for other process. Parameters ---------- tile : ``Tile`` process : ``MapcheteProcess`` kwargs : keyword arguments ### Response: def open(self, tile, process, **kwargs): """ Open process output as input for other process. Parameters ---------- tile : ``Tile`` process : ``MapcheteProcess`` kwargs : keyword arguments """ return InputTile(tile, process, kwargs.get("resampling", None))
def firstUrn(resource): """ Parse a resource to get the first URN :param resource: XML Resource :type resource: etree._Element :return: Tuple representing previous and next urn :rtype: str """ resource = xmlparser(resource) urn = resource.xpath("//ti:reply/ti:urn/text()", namespaces=XPATH_NAMESPACES, magic_string=True) if len(urn) > 0: urn = str(urn[0]) return urn.split(":")[-1]
Parse a resource to get the first URN :param resource: XML Resource :type resource: etree._Element :return: Tuple representing previous and next urn :rtype: str
Below is the the instruction that describes the task: ### Input: Parse a resource to get the first URN :param resource: XML Resource :type resource: etree._Element :return: Tuple representing previous and next urn :rtype: str ### Response: def firstUrn(resource): """ Parse a resource to get the first URN :param resource: XML Resource :type resource: etree._Element :return: Tuple representing previous and next urn :rtype: str """ resource = xmlparser(resource) urn = resource.xpath("//ti:reply/ti:urn/text()", namespaces=XPATH_NAMESPACES, magic_string=True) if len(urn) > 0: urn = str(urn[0]) return urn.split(":")[-1]
def _delete_extraneous_files(self): # type: (SyncCopy) -> None """Delete extraneous files on the remote :param SyncCopy self: this """ if not self._spec.options.delete_extraneous_destination: return # list blobs for all destinations checked = set() deleted = 0 for sa, container, _, _ in self._get_destination_paths(): key = ';'.join((sa.name, sa.endpoint, container)) if key in checked: continue logger.debug( 'attempting to delete extraneous blobs/files from: {}'.format( key)) if self._global_dest_mode_is_file(): files = blobxfer.operations.azure.file.list_all_files( sa.file_client, container) for file in files: id = blobxfer.operations.synccopy.SyncCopy.\ create_deletion_id(sa.file_client, container, file) if id not in self._delete_exclude: if self._general_options.dry_run: logger.info('[DRY RUN] deleting file: {}'.format( file)) else: if self._general_options.verbose: logger.debug('deleting file: {}'.format(file)) blobxfer.operations.azure.file.delete_file( sa.file_client, container, file) deleted += 1 else: blobs = blobxfer.operations.azure.blob.list_all_blobs( sa.block_blob_client, container) for blob in blobs: id = blobxfer.operations.synccopy.SyncCopy.\ create_deletion_id( sa.block_blob_client, container, blob.name) if id not in self._delete_exclude: if self._general_options.dry_run: logger.info('[DRY RUN] deleting blob: {}'.format( blob.name)) else: if self._general_options.verbose: logger.debug('deleting blob: {}'.format( blob.name)) blobxfer.operations.azure.blob.delete_blob( sa.block_blob_client, container, blob.name) deleted += 1 checked.add(key) logger.info('deleted {} extraneous blobs/files'.format(deleted))
Delete extraneous files on the remote :param SyncCopy self: this
Below is the the instruction that describes the task: ### Input: Delete extraneous files on the remote :param SyncCopy self: this ### Response: def _delete_extraneous_files(self): # type: (SyncCopy) -> None """Delete extraneous files on the remote :param SyncCopy self: this """ if not self._spec.options.delete_extraneous_destination: return # list blobs for all destinations checked = set() deleted = 0 for sa, container, _, _ in self._get_destination_paths(): key = ';'.join((sa.name, sa.endpoint, container)) if key in checked: continue logger.debug( 'attempting to delete extraneous blobs/files from: {}'.format( key)) if self._global_dest_mode_is_file(): files = blobxfer.operations.azure.file.list_all_files( sa.file_client, container) for file in files: id = blobxfer.operations.synccopy.SyncCopy.\ create_deletion_id(sa.file_client, container, file) if id not in self._delete_exclude: if self._general_options.dry_run: logger.info('[DRY RUN] deleting file: {}'.format( file)) else: if self._general_options.verbose: logger.debug('deleting file: {}'.format(file)) blobxfer.operations.azure.file.delete_file( sa.file_client, container, file) deleted += 1 else: blobs = blobxfer.operations.azure.blob.list_all_blobs( sa.block_blob_client, container) for blob in blobs: id = blobxfer.operations.synccopy.SyncCopy.\ create_deletion_id( sa.block_blob_client, container, blob.name) if id not in self._delete_exclude: if self._general_options.dry_run: logger.info('[DRY RUN] deleting blob: {}'.format( blob.name)) else: if self._general_options.verbose: logger.debug('deleting blob: {}'.format( blob.name)) blobxfer.operations.azure.blob.delete_blob( sa.block_blob_client, container, blob.name) deleted += 1 checked.add(key) logger.info('deleted {} extraneous blobs/files'.format(deleted))
def process_event(self, event): """ Process a new input event. This method will pass the event on to any Effects in reverse Z order so that the top-most Effect has priority. :param event: The Event that has been triggered. :returns: None if the Scene processed the event, else the original event. """ for effect in reversed(self._effects): event = effect.process_event(event) if event is None: break return event
Process a new input event. This method will pass the event on to any Effects in reverse Z order so that the top-most Effect has priority. :param event: The Event that has been triggered. :returns: None if the Scene processed the event, else the original event.
Below is the the instruction that describes the task: ### Input: Process a new input event. This method will pass the event on to any Effects in reverse Z order so that the top-most Effect has priority. :param event: The Event that has been triggered. :returns: None if the Scene processed the event, else the original event. ### Response: def process_event(self, event): """ Process a new input event. This method will pass the event on to any Effects in reverse Z order so that the top-most Effect has priority. :param event: The Event that has been triggered. :returns: None if the Scene processed the event, else the original event. """ for effect in reversed(self._effects): event = effect.process_event(event) if event is None: break return event
def _open_file(cls, writer_spec, filename_suffix, use_tmp_bucket=False): """Opens a new gcs file for writing.""" if use_tmp_bucket: bucket = cls._get_tmp_gcs_bucket(writer_spec) account_id = cls._get_tmp_account_id(writer_spec) else: bucket = cls._get_gcs_bucket(writer_spec) account_id = cls._get_account_id(writer_spec) # GoogleCloudStorage format for filenames, Initial slash is required filename = "/%s/%s" % (bucket, filename_suffix) content_type = writer_spec.get(cls.CONTENT_TYPE_PARAM, None) options = {} if cls.ACL_PARAM in writer_spec: options["x-goog-acl"] = writer_spec.get(cls.ACL_PARAM) return cloudstorage.open(filename, mode="w", content_type=content_type, options=options, _account_id=account_id)
Opens a new gcs file for writing.
Below is the the instruction that describes the task: ### Input: Opens a new gcs file for writing. ### Response: def _open_file(cls, writer_spec, filename_suffix, use_tmp_bucket=False): """Opens a new gcs file for writing.""" if use_tmp_bucket: bucket = cls._get_tmp_gcs_bucket(writer_spec) account_id = cls._get_tmp_account_id(writer_spec) else: bucket = cls._get_gcs_bucket(writer_spec) account_id = cls._get_account_id(writer_spec) # GoogleCloudStorage format for filenames, Initial slash is required filename = "/%s/%s" % (bucket, filename_suffix) content_type = writer_spec.get(cls.CONTENT_TYPE_PARAM, None) options = {} if cls.ACL_PARAM in writer_spec: options["x-goog-acl"] = writer_spec.get(cls.ACL_PARAM) return cloudstorage.open(filename, mode="w", content_type=content_type, options=options, _account_id=account_id)
def sync_tools( self, all_=False, destination=None, dry_run=False, public=False, source=None, stream=None, version=None): """Copy Juju tools into this model. :param bool all_: Copy all versions, not just the latest :param str destination: Path to local destination directory :param bool dry_run: Don't do the actual copy :param bool public: Tools are for a public cloud, so generate mirrors information :param str source: Path to local source directory :param str stream: Simplestreams stream for which to sync metadata :param str version: Copy a specific major.minor version """ raise NotImplementedError()
Copy Juju tools into this model. :param bool all_: Copy all versions, not just the latest :param str destination: Path to local destination directory :param bool dry_run: Don't do the actual copy :param bool public: Tools are for a public cloud, so generate mirrors information :param str source: Path to local source directory :param str stream: Simplestreams stream for which to sync metadata :param str version: Copy a specific major.minor version
Below is the the instruction that describes the task: ### Input: Copy Juju tools into this model. :param bool all_: Copy all versions, not just the latest :param str destination: Path to local destination directory :param bool dry_run: Don't do the actual copy :param bool public: Tools are for a public cloud, so generate mirrors information :param str source: Path to local source directory :param str stream: Simplestreams stream for which to sync metadata :param str version: Copy a specific major.minor version ### Response: def sync_tools( self, all_=False, destination=None, dry_run=False, public=False, source=None, stream=None, version=None): """Copy Juju tools into this model. :param bool all_: Copy all versions, not just the latest :param str destination: Path to local destination directory :param bool dry_run: Don't do the actual copy :param bool public: Tools are for a public cloud, so generate mirrors information :param str source: Path to local source directory :param str stream: Simplestreams stream for which to sync metadata :param str version: Copy a specific major.minor version """ raise NotImplementedError()
def remote_call(request, cls, method, args, kw): '''Command for executing remote calls on a remote object ''' actor = request.actor name = 'remote_%s' % cls.__name__ if not hasattr(actor, name): object = cls(actor) setattr(actor, name, object) else: object = getattr(actor, name) method_name = '%s%s' % (PREFIX, method) return getattr(object, method_name)(request, *args, **kw)
Command for executing remote calls on a remote object
Below is the the instruction that describes the task: ### Input: Command for executing remote calls on a remote object ### Response: def remote_call(request, cls, method, args, kw): '''Command for executing remote calls on a remote object ''' actor = request.actor name = 'remote_%s' % cls.__name__ if not hasattr(actor, name): object = cls(actor) setattr(actor, name, object) else: object = getattr(actor, name) method_name = '%s%s' % (PREFIX, method) return getattr(object, method_name)(request, *args, **kw)
def domain_list(gandi): """List domains manageable by REST API.""" domains = gandi.dns.list() for domain in domains: gandi.echo(domain['fqdn']) return domains
List domains manageable by REST API.
Below is the the instruction that describes the task: ### Input: List domains manageable by REST API. ### Response: def domain_list(gandi): """List domains manageable by REST API.""" domains = gandi.dns.list() for domain in domains: gandi.echo(domain['fqdn']) return domains
def parse(cls, args): """ Parse command line arguments to construct a dictionary of command parameters that can be used to create a command Args: `args`: sequence of arguments Returns: Dictionary that can be used in create method Raises: ParseError: when the arguments are not correct """ parsed = {} try: (options, args) = cls.optparser.parse_args(args) except OptionParsingError as e: raise ParseError(e.msg, cls.optparser.format_help()) except OptionParsingExit as e: return None parsed['label'] = options.label parsed['can_notify'] = options.can_notify parsed['name'] = options.name parsed['tags'] = options.tags parsed["command_type"] = "HadoopCommand" parsed['print_logs'] = options.print_logs parsed['print_logs_live'] = options.print_logs_live parsed['pool'] = options.pool if len(args) < 2: raise ParseError("Need at least two arguments", cls.usage) subcmd = args.pop(0) if subcmd not in cls.subcmdlist: raise ParseError("First argument must be one of <%s>" % "|".join(cls.subcmdlist)) parsed["sub_command"] = subcmd parsed["sub_command_args"] = " ".join("'" + str(a) + "'" for a in args) return parsed
Parse command line arguments to construct a dictionary of command parameters that can be used to create a command Args: `args`: sequence of arguments Returns: Dictionary that can be used in create method Raises: ParseError: when the arguments are not correct
Below is the the instruction that describes the task: ### Input: Parse command line arguments to construct a dictionary of command parameters that can be used to create a command Args: `args`: sequence of arguments Returns: Dictionary that can be used in create method Raises: ParseError: when the arguments are not correct ### Response: def parse(cls, args): """ Parse command line arguments to construct a dictionary of command parameters that can be used to create a command Args: `args`: sequence of arguments Returns: Dictionary that can be used in create method Raises: ParseError: when the arguments are not correct """ parsed = {} try: (options, args) = cls.optparser.parse_args(args) except OptionParsingError as e: raise ParseError(e.msg, cls.optparser.format_help()) except OptionParsingExit as e: return None parsed['label'] = options.label parsed['can_notify'] = options.can_notify parsed['name'] = options.name parsed['tags'] = options.tags parsed["command_type"] = "HadoopCommand" parsed['print_logs'] = options.print_logs parsed['print_logs_live'] = options.print_logs_live parsed['pool'] = options.pool if len(args) < 2: raise ParseError("Need at least two arguments", cls.usage) subcmd = args.pop(0) if subcmd not in cls.subcmdlist: raise ParseError("First argument must be one of <%s>" % "|".join(cls.subcmdlist)) parsed["sub_command"] = subcmd parsed["sub_command_args"] = " ".join("'" + str(a) + "'" for a in args) return parsed
def foreignkey(element, exceptions): ''' function to determine if each select field needs a create button or not ''' label = element.field.__dict__['label'] try: label = unicode(label) except NameError: pass if (not label) or (label in exceptions): return False else: return "_queryset" in element.field.__dict__
function to determine if each select field needs a create button or not
Below is the the instruction that describes the task: ### Input: function to determine if each select field needs a create button or not ### Response: def foreignkey(element, exceptions): ''' function to determine if each select field needs a create button or not ''' label = element.field.__dict__['label'] try: label = unicode(label) except NameError: pass if (not label) or (label in exceptions): return False else: return "_queryset" in element.field.__dict__
def next(self, fetch: bool = False, next_symbol: _NextSymbol = DEFAULT_NEXT_SYMBOL) -> _Next: """Attempts to find the next page, if there is one. If ``fetch`` is ``True`` (default), returns :class:`HTML <HTML>` object of next page. If ``fetch`` is ``False``, simply returns the next URL. """ def get_next(): candidates = self.find('a', containing=next_symbol) for candidate in candidates: if candidate.attrs.get('href'): # Support 'next' rel (e.g. reddit). if 'next' in candidate.attrs.get('rel', []): return candidate.attrs['href'] # Support 'next' in classnames. for _class in candidate.attrs.get('class', []): if 'next' in _class: return candidate.attrs['href'] if 'page' in candidate.attrs['href']: return candidate.attrs['href'] try: # Resort to the last candidate. return candidates[-1].attrs['href'] except IndexError: return None __next = get_next() if __next: url = self._make_absolute(__next) else: return None if fetch: return self.session.get(url) else: return url
Attempts to find the next page, if there is one. If ``fetch`` is ``True`` (default), returns :class:`HTML <HTML>` object of next page. If ``fetch`` is ``False``, simply returns the next URL.
Below is the the instruction that describes the task: ### Input: Attempts to find the next page, if there is one. If ``fetch`` is ``True`` (default), returns :class:`HTML <HTML>` object of next page. If ``fetch`` is ``False``, simply returns the next URL. ### Response: def next(self, fetch: bool = False, next_symbol: _NextSymbol = DEFAULT_NEXT_SYMBOL) -> _Next: """Attempts to find the next page, if there is one. If ``fetch`` is ``True`` (default), returns :class:`HTML <HTML>` object of next page. If ``fetch`` is ``False``, simply returns the next URL. """ def get_next(): candidates = self.find('a', containing=next_symbol) for candidate in candidates: if candidate.attrs.get('href'): # Support 'next' rel (e.g. reddit). if 'next' in candidate.attrs.get('rel', []): return candidate.attrs['href'] # Support 'next' in classnames. for _class in candidate.attrs.get('class', []): if 'next' in _class: return candidate.attrs['href'] if 'page' in candidate.attrs['href']: return candidate.attrs['href'] try: # Resort to the last candidate. return candidates[-1].attrs['href'] except IndexError: return None __next = get_next() if __next: url = self._make_absolute(__next) else: return None if fetch: return self.session.get(url) else: return url
def install_defaults(self): """Installs the default skills, updates all others""" def install_or_update_skill(skill): if skill.is_local: self.update(skill) else: self.install(skill, origin='default') return self.apply(install_or_update_skill, self.list_defaults())
Installs the default skills, updates all others
Below is the the instruction that describes the task: ### Input: Installs the default skills, updates all others ### Response: def install_defaults(self): """Installs the default skills, updates all others""" def install_or_update_skill(skill): if skill.is_local: self.update(skill) else: self.install(skill, origin='default') return self.apply(install_or_update_skill, self.list_defaults())
def chdir(new_dir): """ stolen from bcbio. Context manager to temporarily change to a new directory. http://lucentbeing.com/blog/context-managers-and-the-with-statement-in-python/ """ cur_dir = os.getcwd() _mkdir(new_dir) os.chdir(new_dir) try: yield finally: os.chdir(cur_dir)
stolen from bcbio. Context manager to temporarily change to a new directory. http://lucentbeing.com/blog/context-managers-and-the-with-statement-in-python/
Below is the the instruction that describes the task: ### Input: stolen from bcbio. Context manager to temporarily change to a new directory. http://lucentbeing.com/blog/context-managers-and-the-with-statement-in-python/ ### Response: def chdir(new_dir): """ stolen from bcbio. Context manager to temporarily change to a new directory. http://lucentbeing.com/blog/context-managers-and-the-with-statement-in-python/ """ cur_dir = os.getcwd() _mkdir(new_dir) os.chdir(new_dir) try: yield finally: os.chdir(cur_dir)
def clear_zone_conditions(self): """stub""" if (self.get_zone_conditions_metadata().is_read_only() or self.get_zone_conditions_metadata().is_required()): raise NoAccess() self.my_osid_object_form._my_map['zoneConditions'] = \ self._zone_conditions_metadata['default_object_values'][0]
stub
Below is the the instruction that describes the task: ### Input: stub ### Response: def clear_zone_conditions(self): """stub""" if (self.get_zone_conditions_metadata().is_read_only() or self.get_zone_conditions_metadata().is_required()): raise NoAccess() self.my_osid_object_form._my_map['zoneConditions'] = \ self._zone_conditions_metadata['default_object_values'][0]
def md5(self): """ MD5 of scene which will change when meshes or transforms are changed Returns -------- hashed: str, MD5 hash of scene """ # start with transforms hash hashes = [self.graph.md5()] for g in self.geometry.values(): if hasattr(g, 'md5'): hashes.append(g.md5()) elif hasattr(g, 'tostring'): hashes.append(str(hash(g.tostring()))) else: # try to just straight up hash # this may raise errors hashes.append(str(hash(g))) md5 = util.md5_object(''.join(hashes)) return md5
MD5 of scene which will change when meshes or transforms are changed Returns -------- hashed: str, MD5 hash of scene
Below is the the instruction that describes the task: ### Input: MD5 of scene which will change when meshes or transforms are changed Returns -------- hashed: str, MD5 hash of scene ### Response: def md5(self): """ MD5 of scene which will change when meshes or transforms are changed Returns -------- hashed: str, MD5 hash of scene """ # start with transforms hash hashes = [self.graph.md5()] for g in self.geometry.values(): if hasattr(g, 'md5'): hashes.append(g.md5()) elif hasattr(g, 'tostring'): hashes.append(str(hash(g.tostring()))) else: # try to just straight up hash # this may raise errors hashes.append(str(hash(g))) md5 = util.md5_object(''.join(hashes)) return md5
def drop_edges(self) -> None: """Drop all edges in the database.""" t = time.time() self.session.query(Edge).delete() self.session.commit() log.info('dropped all edges in %.2f seconds', time.time() - t)
Drop all edges in the database.
Below is the the instruction that describes the task: ### Input: Drop all edges in the database. ### Response: def drop_edges(self) -> None: """Drop all edges in the database.""" t = time.time() self.session.query(Edge).delete() self.session.commit() log.info('dropped all edges in %.2f seconds', time.time() - t)
def call_moses_detokenizer(workspace_dir: str, input_fname: str, output_fname: str, lang_code: Optional[str] = None): """ Call Moses detokenizer. :param workspace_dir: Workspace third-party directory where Moses tokenizer is checked out. :param input_fname: Path of tokenized input file, plain text or gzipped. :param output_fname: Path of tokenized output file, plain text. :param lang_code: Language code for rules and non-breaking prefixes. Can be None if unknown (using pre-tokenized data), which will cause the tokenizer to default to English. """ detokenizer_fname = os.path.join(workspace_dir, DIR_THIRD_PARTY, MOSES_DEST, "scripts", "tokenizer", "detokenizer.perl") with bin_open(input_fname) as inp, open(output_fname, "wb") as out, open(os.devnull, "wb") as devnull: command = ["perl", detokenizer_fname] if lang_code: command.append("-l") command.append(lang_code) detokenizer = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=devnull) detokenizer_thread = threading.Thread(target=copy_out, args=(detokenizer.stdout, out)) detokenizer_thread.start() for line in inp: detokenizer.stdin.write(line) detokenizer.stdin.close() detokenizer_thread.join() detokenizer.wait()
Call Moses detokenizer. :param workspace_dir: Workspace third-party directory where Moses tokenizer is checked out. :param input_fname: Path of tokenized input file, plain text or gzipped. :param output_fname: Path of tokenized output file, plain text. :param lang_code: Language code for rules and non-breaking prefixes. Can be None if unknown (using pre-tokenized data), which will cause the tokenizer to default to English.
Below is the the instruction that describes the task: ### Input: Call Moses detokenizer. :param workspace_dir: Workspace third-party directory where Moses tokenizer is checked out. :param input_fname: Path of tokenized input file, plain text or gzipped. :param output_fname: Path of tokenized output file, plain text. :param lang_code: Language code for rules and non-breaking prefixes. Can be None if unknown (using pre-tokenized data), which will cause the tokenizer to default to English. ### Response: def call_moses_detokenizer(workspace_dir: str, input_fname: str, output_fname: str, lang_code: Optional[str] = None): """ Call Moses detokenizer. :param workspace_dir: Workspace third-party directory where Moses tokenizer is checked out. :param input_fname: Path of tokenized input file, plain text or gzipped. :param output_fname: Path of tokenized output file, plain text. :param lang_code: Language code for rules and non-breaking prefixes. Can be None if unknown (using pre-tokenized data), which will cause the tokenizer to default to English. """ detokenizer_fname = os.path.join(workspace_dir, DIR_THIRD_PARTY, MOSES_DEST, "scripts", "tokenizer", "detokenizer.perl") with bin_open(input_fname) as inp, open(output_fname, "wb") as out, open(os.devnull, "wb") as devnull: command = ["perl", detokenizer_fname] if lang_code: command.append("-l") command.append(lang_code) detokenizer = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=devnull) detokenizer_thread = threading.Thread(target=copy_out, args=(detokenizer.stdout, out)) detokenizer_thread.start() for line in inp: detokenizer.stdin.write(line) detokenizer.stdin.close() detokenizer_thread.join() detokenizer.wait()
def Open(self): """Opens the process for reading.""" self.h_process = kernel32.OpenProcess( PROCESS_VM_READ | PROCESS_QUERY_INFORMATION, 0, self.pid) if not self.h_process: raise process_error.ProcessError( "Failed to open process (pid %d)." % self.pid) if self.Is64bit(): si = self.GetNativeSystemInfo() self.max_addr = si.lpMaximumApplicationAddress else: si = self.GetSystemInfo() self.max_addr = 2147418111 self.min_addr = si.lpMinimumApplicationAddress
Opens the process for reading.
Below is the the instruction that describes the task: ### Input: Opens the process for reading. ### Response: def Open(self): """Opens the process for reading.""" self.h_process = kernel32.OpenProcess( PROCESS_VM_READ | PROCESS_QUERY_INFORMATION, 0, self.pid) if not self.h_process: raise process_error.ProcessError( "Failed to open process (pid %d)." % self.pid) if self.Is64bit(): si = self.GetNativeSystemInfo() self.max_addr = si.lpMaximumApplicationAddress else: si = self.GetSystemInfo() self.max_addr = 2147418111 self.min_addr = si.lpMinimumApplicationAddress
def _env_filenames(filenames, env): """ Extend filenames with ennv indication of environments. :param list filenames: list of strings indicating filenames :param str env: environment indicator :returns: list of filenames extended with environment version :rtype: list """ env_filenames = [] for filename in filenames: filename_parts = filename.split('.') filename_parts.insert(1, env) env_filenames.extend([filename, '.'.join(filename_parts)]) return env_filenames
Extend filenames with ennv indication of environments. :param list filenames: list of strings indicating filenames :param str env: environment indicator :returns: list of filenames extended with environment version :rtype: list
Below is the the instruction that describes the task: ### Input: Extend filenames with ennv indication of environments. :param list filenames: list of strings indicating filenames :param str env: environment indicator :returns: list of filenames extended with environment version :rtype: list ### Response: def _env_filenames(filenames, env): """ Extend filenames with ennv indication of environments. :param list filenames: list of strings indicating filenames :param str env: environment indicator :returns: list of filenames extended with environment version :rtype: list """ env_filenames = [] for filename in filenames: filename_parts = filename.split('.') filename_parts.insert(1, env) env_filenames.extend([filename, '.'.join(filename_parts)]) return env_filenames
def get_table_metadata(engine, table): """ Extract all useful infos from the given table Args: engine: SQLAlchemy connection engine table: table name Returns: Dictionary of infos """ metadata = MetaData() metadata.reflect(bind=engine, only=[table]) table_metadata = Table(table, metadata, autoload=True) return table_metadata
Extract all useful infos from the given table Args: engine: SQLAlchemy connection engine table: table name Returns: Dictionary of infos
Below is the the instruction that describes the task: ### Input: Extract all useful infos from the given table Args: engine: SQLAlchemy connection engine table: table name Returns: Dictionary of infos ### Response: def get_table_metadata(engine, table): """ Extract all useful infos from the given table Args: engine: SQLAlchemy connection engine table: table name Returns: Dictionary of infos """ metadata = MetaData() metadata.reflect(bind=engine, only=[table]) table_metadata = Table(table, metadata, autoload=True) return table_metadata
def create(self, parties): """Create the barrier for the given number of parties. Parameters: parties(int): The number of parties to wait for. Returns: bool: Whether or not the new barrier was successfully created. """ assert parties > 0, "parties must be a positive integer." return self.backend.add(self.key, parties, self.ttl)
Create the barrier for the given number of parties. Parameters: parties(int): The number of parties to wait for. Returns: bool: Whether or not the new barrier was successfully created.
Below is the the instruction that describes the task: ### Input: Create the barrier for the given number of parties. Parameters: parties(int): The number of parties to wait for. Returns: bool: Whether or not the new barrier was successfully created. ### Response: def create(self, parties): """Create the barrier for the given number of parties. Parameters: parties(int): The number of parties to wait for. Returns: bool: Whether or not the new barrier was successfully created. """ assert parties > 0, "parties must be a positive integer." return self.backend.add(self.key, parties, self.ttl)
def monkeycache(apis): """ Feed this a dictionary of api bananas, it spits out processed cache """ if isinstance(type(apis), type(None)) or apis is None: return {} verbs = set() cache = {} cache['count'] = apis['count'] cache['asyncapis'] = [] apilist = apis['api'] if apilist is None: print("[monkeycache] Server response issue, no apis found") for api in apilist: name = getvalue(api, 'name') verb, subject = splitverbsubject(name) apidict = {} apidict['name'] = name apidict['description'] = getvalue(api, 'description') apidict['isasync'] = getvalue(api, 'isasync') if apidict['isasync']: cache['asyncapis'].append(name) apidict['related'] = splitcsvstring(getvalue(api, 'related')) required = [] apiparams = [] for param in getvalue(api, 'params'): apiparam = {} apiparam['name'] = getvalue(param, 'name') apiparam['description'] = getvalue(param, 'description') apiparam['required'] = (getvalue(param, 'required') is True) apiparam['length'] = int(getvalue(param, 'length')) apiparam['type'] = getvalue(param, 'type') apiparam['related'] = splitcsvstring(getvalue(param, 'related')) if apiparam['required']: required.append(apiparam['name']) apiparams.append(apiparam) apidict['requiredparams'] = required apidict['params'] = apiparams if verb not in cache: cache[verb] = {} cache[verb][subject] = apidict verbs.add(verb) cache['verbs'] = list(verbs) return cache
Feed this a dictionary of api bananas, it spits out processed cache
Below is the the instruction that describes the task: ### Input: Feed this a dictionary of api bananas, it spits out processed cache ### Response: def monkeycache(apis): """ Feed this a dictionary of api bananas, it spits out processed cache """ if isinstance(type(apis), type(None)) or apis is None: return {} verbs = set() cache = {} cache['count'] = apis['count'] cache['asyncapis'] = [] apilist = apis['api'] if apilist is None: print("[monkeycache] Server response issue, no apis found") for api in apilist: name = getvalue(api, 'name') verb, subject = splitverbsubject(name) apidict = {} apidict['name'] = name apidict['description'] = getvalue(api, 'description') apidict['isasync'] = getvalue(api, 'isasync') if apidict['isasync']: cache['asyncapis'].append(name) apidict['related'] = splitcsvstring(getvalue(api, 'related')) required = [] apiparams = [] for param in getvalue(api, 'params'): apiparam = {} apiparam['name'] = getvalue(param, 'name') apiparam['description'] = getvalue(param, 'description') apiparam['required'] = (getvalue(param, 'required') is True) apiparam['length'] = int(getvalue(param, 'length')) apiparam['type'] = getvalue(param, 'type') apiparam['related'] = splitcsvstring(getvalue(param, 'related')) if apiparam['required']: required.append(apiparam['name']) apiparams.append(apiparam) apidict['requiredparams'] = required apidict['params'] = apiparams if verb not in cache: cache[verb] = {} cache[verb][subject] = apidict verbs.add(verb) cache['verbs'] = list(verbs) return cache
def keyPressEvent(self, event): """Reimplement Qt methods""" if event.key() == Qt.Key_Delete: self.remove_item() elif event.key() == Qt.Key_F2: self.rename_item() elif event == QKeySequence.Copy: self.copy() elif event == QKeySequence.Paste: self.paste() else: QTableView.keyPressEvent(self, event)
Reimplement Qt methods
Below is the the instruction that describes the task: ### Input: Reimplement Qt methods ### Response: def keyPressEvent(self, event): """Reimplement Qt methods""" if event.key() == Qt.Key_Delete: self.remove_item() elif event.key() == Qt.Key_F2: self.rename_item() elif event == QKeySequence.Copy: self.copy() elif event == QKeySequence.Paste: self.paste() else: QTableView.keyPressEvent(self, event)
def channel_view(x:Tensor)->Tensor: "Make channel the first axis of `x` and flatten remaining axes" return x.transpose(0,1).contiguous().view(x.shape[1],-1)
Make channel the first axis of `x` and flatten remaining axes
Below is the the instruction that describes the task: ### Input: Make channel the first axis of `x` and flatten remaining axes ### Response: def channel_view(x:Tensor)->Tensor: "Make channel the first axis of `x` and flatten remaining axes" return x.transpose(0,1).contiguous().view(x.shape[1],-1)
def get_formatted_content(self, pyobj): '''typecode data --> text ''' u = urlencode(pyobj, self.reserved) return String.get_formatted_content(self, u)
typecode data --> text
Below is the the instruction that describes the task: ### Input: typecode data --> text ### Response: def get_formatted_content(self, pyobj): '''typecode data --> text ''' u = urlencode(pyobj, self.reserved) return String.get_formatted_content(self, u)
def draw(self, dx=0, dy=0, weighted=False, directed=False, highlight=[], traffic=None): """ Layout the graph incrementally. The graph is drawn at the center of the canvas. The weighted and directed parameters visualize edge weight and direction. The highlight specifies list of connected nodes. The path will be colored according to the "highlight" style. Clicking and dragging events are monitored. """ self.update() # Draw the graph background. s = self.styles.default s.graph_background(s) # Center the graph on the canvas. _ctx.push() _ctx.translate(self.x+dx, self.y+dy) # Indicate betweenness centrality. if traffic: if isinstance(traffic, bool): traffic = 5 for n in self.nodes_by_betweenness()[:traffic]: try: s = self.styles[n.style] except: s = self.styles.default if s.graph_traffic: s.graph_traffic(s, n, self.alpha) # Draw the edges and their labels. s = self.styles.default if s.edges: s.edges(s, self.edges, self.alpha, weighted, directed) # Draw each node in the graph. # Apply individual style to each node (or default). for n in self.nodes: try: s = self.styles[n.style] except: s = self.styles.default if s.node: s.node(s, n, self.alpha) # Highlight the given shortest path. try: s = self.styles.highlight except: s = self.styles.default if s.path: s.path(s, self, highlight) # Draw node id's as labels on each node. for n in self.nodes: try: s = self.styles[n.style] except: s = self.styles.default if s.node_label: s.node_label(s, n, self.alpha) # Events for clicked and dragged nodes. # Nodes will resist being dragged by attraction and repulsion, # put the event listener on top to get more direct feedback. #self.events.update() _ctx.pop()
Layout the graph incrementally. The graph is drawn at the center of the canvas. The weighted and directed parameters visualize edge weight and direction. The highlight specifies list of connected nodes. The path will be colored according to the "highlight" style. Clicking and dragging events are monitored.
Below is the the instruction that describes the task: ### Input: Layout the graph incrementally. The graph is drawn at the center of the canvas. The weighted and directed parameters visualize edge weight and direction. The highlight specifies list of connected nodes. The path will be colored according to the "highlight" style. Clicking and dragging events are monitored. ### Response: def draw(self, dx=0, dy=0, weighted=False, directed=False, highlight=[], traffic=None): """ Layout the graph incrementally. The graph is drawn at the center of the canvas. The weighted and directed parameters visualize edge weight and direction. The highlight specifies list of connected nodes. The path will be colored according to the "highlight" style. Clicking and dragging events are monitored. """ self.update() # Draw the graph background. s = self.styles.default s.graph_background(s) # Center the graph on the canvas. _ctx.push() _ctx.translate(self.x+dx, self.y+dy) # Indicate betweenness centrality. if traffic: if isinstance(traffic, bool): traffic = 5 for n in self.nodes_by_betweenness()[:traffic]: try: s = self.styles[n.style] except: s = self.styles.default if s.graph_traffic: s.graph_traffic(s, n, self.alpha) # Draw the edges and their labels. s = self.styles.default if s.edges: s.edges(s, self.edges, self.alpha, weighted, directed) # Draw each node in the graph. # Apply individual style to each node (or default). for n in self.nodes: try: s = self.styles[n.style] except: s = self.styles.default if s.node: s.node(s, n, self.alpha) # Highlight the given shortest path. try: s = self.styles.highlight except: s = self.styles.default if s.path: s.path(s, self, highlight) # Draw node id's as labels on each node. for n in self.nodes: try: s = self.styles[n.style] except: s = self.styles.default if s.node_label: s.node_label(s, n, self.alpha) # Events for clicked and dragged nodes. # Nodes will resist being dragged by attraction and repulsion, # put the event listener on top to get more direct feedback. #self.events.update() _ctx.pop()
def _read_bands(self): """ Reads a band with rasterio """ bands = [] try: for i, band in enumerate(self.bands): bands.append(rasterio.open(self.bands_path[i]).read_band(1)) except IOError as e: exit(e.message, 1) return bands
Reads a band with rasterio
Below is the the instruction that describes the task: ### Input: Reads a band with rasterio ### Response: def _read_bands(self): """ Reads a band with rasterio """ bands = [] try: for i, band in enumerate(self.bands): bands.append(rasterio.open(self.bands_path[i]).read_band(1)) except IOError as e: exit(e.message, 1) return bands
def add_all_from_dict(self, dictionary, **kwargs): """ Batch-add function implementations to the library. :param dictionary: A mapping from name to procedure class, i.e. the first two arguments to add() :param kwargs: Any additional kwargs will be passed to the constructors of _each_ procedure class """ for name, procedure in dictionary.items(): self.add(name, procedure, **kwargs)
Batch-add function implementations to the library. :param dictionary: A mapping from name to procedure class, i.e. the first two arguments to add() :param kwargs: Any additional kwargs will be passed to the constructors of _each_ procedure class
Below is the the instruction that describes the task: ### Input: Batch-add function implementations to the library. :param dictionary: A mapping from name to procedure class, i.e. the first two arguments to add() :param kwargs: Any additional kwargs will be passed to the constructors of _each_ procedure class ### Response: def add_all_from_dict(self, dictionary, **kwargs): """ Batch-add function implementations to the library. :param dictionary: A mapping from name to procedure class, i.e. the first two arguments to add() :param kwargs: Any additional kwargs will be passed to the constructors of _each_ procedure class """ for name, procedure in dictionary.items(): self.add(name, procedure, **kwargs)
def leaveEvent(self, event): """ Mark the hovered state as being false. :param event | <QtCore.QLeaveEvent> """ super(XViewPanelItem, self).leaveEvent(event) # store the hover state and mark for a repaint self._hovered = False self.update()
Mark the hovered state as being false. :param event | <QtCore.QLeaveEvent>
Below is the the instruction that describes the task: ### Input: Mark the hovered state as being false. :param event | <QtCore.QLeaveEvent> ### Response: def leaveEvent(self, event): """ Mark the hovered state as being false. :param event | <QtCore.QLeaveEvent> """ super(XViewPanelItem, self).leaveEvent(event) # store the hover state and mark for a repaint self._hovered = False self.update()
def parse(cls, fptr, offset, length): """Parse data entry URL box. Parameters ---------- fptr : file Open file object. offset : int Start position of box in bytes. length : int Length of the box in bytes. Returns ------- DataEntryURLbox Instance of the current data entry URL box. """ num_bytes = offset + length - fptr.tell() read_buffer = fptr.read(num_bytes) data = struct.unpack_from('>BBBB', read_buffer) version = data[0] flag = data[1:4] url = read_buffer[4:].decode('utf-8').rstrip(chr(0)) return cls(version, flag, url, length=length, offset=offset)
Parse data entry URL box. Parameters ---------- fptr : file Open file object. offset : int Start position of box in bytes. length : int Length of the box in bytes. Returns ------- DataEntryURLbox Instance of the current data entry URL box.
Below is the the instruction that describes the task: ### Input: Parse data entry URL box. Parameters ---------- fptr : file Open file object. offset : int Start position of box in bytes. length : int Length of the box in bytes. Returns ------- DataEntryURLbox Instance of the current data entry URL box. ### Response: def parse(cls, fptr, offset, length): """Parse data entry URL box. Parameters ---------- fptr : file Open file object. offset : int Start position of box in bytes. length : int Length of the box in bytes. Returns ------- DataEntryURLbox Instance of the current data entry URL box. """ num_bytes = offset + length - fptr.tell() read_buffer = fptr.read(num_bytes) data = struct.unpack_from('>BBBB', read_buffer) version = data[0] flag = data[1:4] url = read_buffer[4:].decode('utf-8').rstrip(chr(0)) return cls(version, flag, url, length=length, offset=offset)
def incoming_references(self, client=None, query={}): """Fetches all entries referencing the entry API Reference: https://www.contentful.com/developers/docs/references/content-delivery-api/#/reference/search-parameters/links-to-asset :param client Client instance :param query: (optional) Dict with API options. :return: List of :class:`Entry <contentful.entry.Entry>` objects. :rtype: List of contentful.entry.Entry Usage: >>> entries = entry.incoming_references(client) [<Entry[cat] id='happycat'>] """ if client is None: return False query.update({'links_to_entry': self.id}) return client.entries(query)
Fetches all entries referencing the entry API Reference: https://www.contentful.com/developers/docs/references/content-delivery-api/#/reference/search-parameters/links-to-asset :param client Client instance :param query: (optional) Dict with API options. :return: List of :class:`Entry <contentful.entry.Entry>` objects. :rtype: List of contentful.entry.Entry Usage: >>> entries = entry.incoming_references(client) [<Entry[cat] id='happycat'>]
Below is the the instruction that describes the task: ### Input: Fetches all entries referencing the entry API Reference: https://www.contentful.com/developers/docs/references/content-delivery-api/#/reference/search-parameters/links-to-asset :param client Client instance :param query: (optional) Dict with API options. :return: List of :class:`Entry <contentful.entry.Entry>` objects. :rtype: List of contentful.entry.Entry Usage: >>> entries = entry.incoming_references(client) [<Entry[cat] id='happycat'>] ### Response: def incoming_references(self, client=None, query={}): """Fetches all entries referencing the entry API Reference: https://www.contentful.com/developers/docs/references/content-delivery-api/#/reference/search-parameters/links-to-asset :param client Client instance :param query: (optional) Dict with API options. :return: List of :class:`Entry <contentful.entry.Entry>` objects. :rtype: List of contentful.entry.Entry Usage: >>> entries = entry.incoming_references(client) [<Entry[cat] id='happycat'>] """ if client is None: return False query.update({'links_to_entry': self.id}) return client.entries(query)
def query(name, use_kerberos=None, debug=False): """Query the Channel Information System for details on the given channel name Parameters ---------- name : `~gwpy.detector.Channel`, or `str` Name of the channel of interest Returns ------- channel : `~gwpy.detector.Channel` Channel with all details as acquired from the CIS """ url = '%s/?q=%s' % (CIS_API_URL, name) more = True out = ChannelList() while more: reply = _get(url, use_kerberos=use_kerberos, debug=debug) try: out.extend(map(parse_json, reply[u'results'])) except KeyError: pass except TypeError: # reply is a list out.extend(map(parse_json, reply)) break more = 'next' in reply and reply['next'] is not None if more: url = reply['next'] else: break out.sort(key=lambda c: c.name) return out
Query the Channel Information System for details on the given channel name Parameters ---------- name : `~gwpy.detector.Channel`, or `str` Name of the channel of interest Returns ------- channel : `~gwpy.detector.Channel` Channel with all details as acquired from the CIS
Below is the the instruction that describes the task: ### Input: Query the Channel Information System for details on the given channel name Parameters ---------- name : `~gwpy.detector.Channel`, or `str` Name of the channel of interest Returns ------- channel : `~gwpy.detector.Channel` Channel with all details as acquired from the CIS ### Response: def query(name, use_kerberos=None, debug=False): """Query the Channel Information System for details on the given channel name Parameters ---------- name : `~gwpy.detector.Channel`, or `str` Name of the channel of interest Returns ------- channel : `~gwpy.detector.Channel` Channel with all details as acquired from the CIS """ url = '%s/?q=%s' % (CIS_API_URL, name) more = True out = ChannelList() while more: reply = _get(url, use_kerberos=use_kerberos, debug=debug) try: out.extend(map(parse_json, reply[u'results'])) except KeyError: pass except TypeError: # reply is a list out.extend(map(parse_json, reply)) break more = 'next' in reply and reply['next'] is not None if more: url = reply['next'] else: break out.sort(key=lambda c: c.name) return out
def _get_files(file_patterns, top=HERE): """Expand file patterns to a list of paths. Parameters ----------- file_patterns: list or str A list of glob patterns for the data file locations. The globs can be recursive if they include a `**`. They should be relative paths from the top directory or absolute paths. top: str the directory to consider for data files Note: Files in `node_modules` are ignored. """ if not isinstance(file_patterns, (list, tuple)): file_patterns = [file_patterns] for i, p in enumerate(file_patterns): if os.path.isabs(p): file_patterns[i] = os.path.relpath(p, top) matchers = [_compile_pattern(p) for p in file_patterns] files = set() for root, dirnames, filenames in os.walk(top): # Don't recurse into node_modules if 'node_modules' in dirnames: dirnames.remove('node_modules') for m in matchers: for filename in filenames: fn = os.path.relpath(_glob_pjoin(root, filename), top) fn = fn.replace(os.sep, '/') if m(fn): files.add(fn.replace(os.sep, '/')) return list(files)
Expand file patterns to a list of paths. Parameters ----------- file_patterns: list or str A list of glob patterns for the data file locations. The globs can be recursive if they include a `**`. They should be relative paths from the top directory or absolute paths. top: str the directory to consider for data files Note: Files in `node_modules` are ignored.
Below is the the instruction that describes the task: ### Input: Expand file patterns to a list of paths. Parameters ----------- file_patterns: list or str A list of glob patterns for the data file locations. The globs can be recursive if they include a `**`. They should be relative paths from the top directory or absolute paths. top: str the directory to consider for data files Note: Files in `node_modules` are ignored. ### Response: def _get_files(file_patterns, top=HERE): """Expand file patterns to a list of paths. Parameters ----------- file_patterns: list or str A list of glob patterns for the data file locations. The globs can be recursive if they include a `**`. They should be relative paths from the top directory or absolute paths. top: str the directory to consider for data files Note: Files in `node_modules` are ignored. """ if not isinstance(file_patterns, (list, tuple)): file_patterns = [file_patterns] for i, p in enumerate(file_patterns): if os.path.isabs(p): file_patterns[i] = os.path.relpath(p, top) matchers = [_compile_pattern(p) for p in file_patterns] files = set() for root, dirnames, filenames in os.walk(top): # Don't recurse into node_modules if 'node_modules' in dirnames: dirnames.remove('node_modules') for m in matchers: for filename in filenames: fn = os.path.relpath(_glob_pjoin(root, filename), top) fn = fn.replace(os.sep, '/') if m(fn): files.add(fn.replace(os.sep, '/')) return list(files)
def empty_tree(input_list): """Recursively iterate through values in nested lists.""" for item in input_list: if not isinstance(item, list) or not empty_tree(item): return False return True
Recursively iterate through values in nested lists.
Below is the the instruction that describes the task: ### Input: Recursively iterate through values in nested lists. ### Response: def empty_tree(input_list): """Recursively iterate through values in nested lists.""" for item in input_list: if not isinstance(item, list) or not empty_tree(item): return False return True
def postprocess_input_todo(self, p_todo): """ Post-processes a parsed todo when adding it to the list. * It converts relative dates to absolute ones. * Automatically inserts a creation date if not present. * Handles more user-friendly dependencies with before:, partof: and after: tags """ def convert_date(p_tag): value = p_todo.tag_value(p_tag) if value: dateobj = relative_date_to_date(value) if dateobj: p_todo.set_tag(p_tag, dateobj.isoformat()) def add_dependencies(p_tag): for value in p_todo.tag_values(p_tag): try: dep = self.todolist.todo(value) if p_tag == 'after': self.todolist.add_dependency(p_todo, dep) elif p_tag == 'before' or p_tag == 'partof': self.todolist.add_dependency(dep, p_todo) elif p_tag.startswith('parent'): for parent in self.todolist.parents(dep): self.todolist.add_dependency(parent, p_todo) elif p_tag.startswith('child'): for child in self.todolist.children(dep): self.todolist.add_dependency(p_todo, child) except InvalidTodoException: pass p_todo.remove_tag(p_tag, value) convert_date(config().tag_start()) convert_date(config().tag_due()) keywords = [ 'after', 'before', 'child-of', 'childof', 'children-of', 'childrenof', 'parent-of', 'parentof', 'parents-of', 'parentsof', 'partof', ] for keyword in keywords: add_dependencies(keyword)
Post-processes a parsed todo when adding it to the list. * It converts relative dates to absolute ones. * Automatically inserts a creation date if not present. * Handles more user-friendly dependencies with before:, partof: and after: tags
Below is the the instruction that describes the task: ### Input: Post-processes a parsed todo when adding it to the list. * It converts relative dates to absolute ones. * Automatically inserts a creation date if not present. * Handles more user-friendly dependencies with before:, partof: and after: tags ### Response: def postprocess_input_todo(self, p_todo): """ Post-processes a parsed todo when adding it to the list. * It converts relative dates to absolute ones. * Automatically inserts a creation date if not present. * Handles more user-friendly dependencies with before:, partof: and after: tags """ def convert_date(p_tag): value = p_todo.tag_value(p_tag) if value: dateobj = relative_date_to_date(value) if dateobj: p_todo.set_tag(p_tag, dateobj.isoformat()) def add_dependencies(p_tag): for value in p_todo.tag_values(p_tag): try: dep = self.todolist.todo(value) if p_tag == 'after': self.todolist.add_dependency(p_todo, dep) elif p_tag == 'before' or p_tag == 'partof': self.todolist.add_dependency(dep, p_todo) elif p_tag.startswith('parent'): for parent in self.todolist.parents(dep): self.todolist.add_dependency(parent, p_todo) elif p_tag.startswith('child'): for child in self.todolist.children(dep): self.todolist.add_dependency(p_todo, child) except InvalidTodoException: pass p_todo.remove_tag(p_tag, value) convert_date(config().tag_start()) convert_date(config().tag_due()) keywords = [ 'after', 'before', 'child-of', 'childof', 'children-of', 'childrenof', 'parent-of', 'parentof', 'parents-of', 'parentsof', 'partof', ] for keyword in keywords: add_dependencies(keyword)
def text(self, tag, textdata, step=None): """Saves a text summary. Args: tag: str: label for this data textdata: string, or 1D/2D list/numpy array of strings step: int: training step Note: markdown formatting is rendered by tensorboard. """ if step is None: step = self._step else: self._step = step smd = SummaryMetadata( plugin_data=SummaryMetadata.PluginData(plugin_name='text')) if isinstance(textdata, (str, bytes)): tensor = tf.make_tensor_proto( values=[textdata.encode(encoding='utf_8')], shape=(1,)) else: textdata = onp.array(textdata) # convert lists, jax arrays, etc. datashape = onp.shape(textdata) if len(datashape) == 1: tensor = tf.make_tensor_proto( values=[td.encode(encoding='utf_8') for td in textdata], shape=(datashape[0],)) elif len(datashape) == 2: tensor = tf.make_tensor_proto( values=[ td.encode(encoding='utf_8') for td in onp.reshape(textdata, -1) ], shape=(datashape[0], datashape[1])) summary = Summary( value=[Summary.Value(tag=tag, metadata=smd, tensor=tensor)]) self.add_summary(summary, step)
Saves a text summary. Args: tag: str: label for this data textdata: string, or 1D/2D list/numpy array of strings step: int: training step Note: markdown formatting is rendered by tensorboard.
Below is the the instruction that describes the task: ### Input: Saves a text summary. Args: tag: str: label for this data textdata: string, or 1D/2D list/numpy array of strings step: int: training step Note: markdown formatting is rendered by tensorboard. ### Response: def text(self, tag, textdata, step=None): """Saves a text summary. Args: tag: str: label for this data textdata: string, or 1D/2D list/numpy array of strings step: int: training step Note: markdown formatting is rendered by tensorboard. """ if step is None: step = self._step else: self._step = step smd = SummaryMetadata( plugin_data=SummaryMetadata.PluginData(plugin_name='text')) if isinstance(textdata, (str, bytes)): tensor = tf.make_tensor_proto( values=[textdata.encode(encoding='utf_8')], shape=(1,)) else: textdata = onp.array(textdata) # convert lists, jax arrays, etc. datashape = onp.shape(textdata) if len(datashape) == 1: tensor = tf.make_tensor_proto( values=[td.encode(encoding='utf_8') for td in textdata], shape=(datashape[0],)) elif len(datashape) == 2: tensor = tf.make_tensor_proto( values=[ td.encode(encoding='utf_8') for td in onp.reshape(textdata, -1) ], shape=(datashape[0], datashape[1])) summary = Summary( value=[Summary.Value(tag=tag, metadata=smd, tensor=tensor)]) self.add_summary(summary, step)
def get(self, *keys, fallback=None): """Retrieve a value in the config, if the value is not available give the fallback value specified. """ section, *keys = keys out = super().get(section, fallback) while isinstance(out, dict): key = keys.pop(0) out = out.get(key, fallback) return out
Retrieve a value in the config, if the value is not available give the fallback value specified.
Below is the the instruction that describes the task: ### Input: Retrieve a value in the config, if the value is not available give the fallback value specified. ### Response: def get(self, *keys, fallback=None): """Retrieve a value in the config, if the value is not available give the fallback value specified. """ section, *keys = keys out = super().get(section, fallback) while isinstance(out, dict): key = keys.pop(0) out = out.get(key, fallback) return out
def waypoint_count_send(self, seq): '''wrapper for waypoint_count_send''' if self.mavlink10(): self.mav.mission_count_send(self.target_system, self.target_component, seq) else: self.mav.waypoint_count_send(self.target_system, self.target_component, seq)
wrapper for waypoint_count_send
Below is the the instruction that describes the task: ### Input: wrapper for waypoint_count_send ### Response: def waypoint_count_send(self, seq): '''wrapper for waypoint_count_send''' if self.mavlink10(): self.mav.mission_count_send(self.target_system, self.target_component, seq) else: self.mav.waypoint_count_send(self.target_system, self.target_component, seq)
def weeks_per_year(year): '''Number of ISO weeks in a year''' # 53 weeks: any year starting on Thursday and any leap year starting on Wednesday jan1 = jwday(gregorian.to_jd(year, 1, 1)) if jan1 == THU or (jan1 == WED and isleap(year)): return 53 else: return 52
Number of ISO weeks in a year
Below is the the instruction that describes the task: ### Input: Number of ISO weeks in a year ### Response: def weeks_per_year(year): '''Number of ISO weeks in a year''' # 53 weeks: any year starting on Thursday and any leap year starting on Wednesday jan1 = jwday(gregorian.to_jd(year, 1, 1)) if jan1 == THU or (jan1 == WED and isleap(year)): return 53 else: return 52
def default_unit_label(axis, unit): """Set default label for an axis from a `~astropy.units.Unit` If the axis already has a label, this function does nothing. Parameters ---------- axis : `~matplotlib.axis.Axis` the axis to manipulate unit : `~astropy.units.Unit` the unit to use for the label Returns ------- text : `str`, `None` the text for the new label, if set, otherwise `None` """ if not axis.isDefault_label: return label = axis.set_label_text(unit.to_string('latex_inline_dimensional')) axis.isDefault_label = True return label.get_text()
Set default label for an axis from a `~astropy.units.Unit` If the axis already has a label, this function does nothing. Parameters ---------- axis : `~matplotlib.axis.Axis` the axis to manipulate unit : `~astropy.units.Unit` the unit to use for the label Returns ------- text : `str`, `None` the text for the new label, if set, otherwise `None`
Below is the the instruction that describes the task: ### Input: Set default label for an axis from a `~astropy.units.Unit` If the axis already has a label, this function does nothing. Parameters ---------- axis : `~matplotlib.axis.Axis` the axis to manipulate unit : `~astropy.units.Unit` the unit to use for the label Returns ------- text : `str`, `None` the text for the new label, if set, otherwise `None` ### Response: def default_unit_label(axis, unit): """Set default label for an axis from a `~astropy.units.Unit` If the axis already has a label, this function does nothing. Parameters ---------- axis : `~matplotlib.axis.Axis` the axis to manipulate unit : `~astropy.units.Unit` the unit to use for the label Returns ------- text : `str`, `None` the text for the new label, if set, otherwise `None` """ if not axis.isDefault_label: return label = axis.set_label_text(unit.to_string('latex_inline_dimensional')) axis.isDefault_label = True return label.get_text()
def distributions_for_instances(self, data): """ Peforms predictions, returning the class distributions. :param data: the Instances to get the class distributions for :type data: Instances :return: the class distribution matrix, None if not a batch predictor :rtype: ndarray """ if self.is_batchpredictor: return arrays.double_matrix_to_ndarray(self.__distributions(data.jobject)) else: return None
Peforms predictions, returning the class distributions. :param data: the Instances to get the class distributions for :type data: Instances :return: the class distribution matrix, None if not a batch predictor :rtype: ndarray
Below is the the instruction that describes the task: ### Input: Peforms predictions, returning the class distributions. :param data: the Instances to get the class distributions for :type data: Instances :return: the class distribution matrix, None if not a batch predictor :rtype: ndarray ### Response: def distributions_for_instances(self, data): """ Peforms predictions, returning the class distributions. :param data: the Instances to get the class distributions for :type data: Instances :return: the class distribution matrix, None if not a batch predictor :rtype: ndarray """ if self.is_batchpredictor: return arrays.double_matrix_to_ndarray(self.__distributions(data.jobject)) else: return None
def get_motor_offsets(SERVO_OUTPUT_RAW, ofs, motor_ofs): '''calculate magnetic field strength from raw magnetometer''' import mavutil self = mavutil.mavfile_global m = SERVO_OUTPUT_RAW motor_pwm = m.servo1_raw + m.servo2_raw + m.servo3_raw + m.servo4_raw motor_pwm *= 0.25 rc3_min = self.param('RC3_MIN', 1100) rc3_max = self.param('RC3_MAX', 1900) motor = (motor_pwm - rc3_min) / (rc3_max - rc3_min) if motor > 1.0: motor = 1.0 if motor < 0.0: motor = 0.0 motor_offsets0 = motor_ofs[0] * motor motor_offsets1 = motor_ofs[1] * motor motor_offsets2 = motor_ofs[2] * motor ofs = (ofs[0] + motor_offsets0, ofs[1] + motor_offsets1, ofs[2] + motor_offsets2) return ofs
calculate magnetic field strength from raw magnetometer
Below is the the instruction that describes the task: ### Input: calculate magnetic field strength from raw magnetometer ### Response: def get_motor_offsets(SERVO_OUTPUT_RAW, ofs, motor_ofs): '''calculate magnetic field strength from raw magnetometer''' import mavutil self = mavutil.mavfile_global m = SERVO_OUTPUT_RAW motor_pwm = m.servo1_raw + m.servo2_raw + m.servo3_raw + m.servo4_raw motor_pwm *= 0.25 rc3_min = self.param('RC3_MIN', 1100) rc3_max = self.param('RC3_MAX', 1900) motor = (motor_pwm - rc3_min) / (rc3_max - rc3_min) if motor > 1.0: motor = 1.0 if motor < 0.0: motor = 0.0 motor_offsets0 = motor_ofs[0] * motor motor_offsets1 = motor_ofs[1] * motor motor_offsets2 = motor_ofs[2] * motor ofs = (ofs[0] + motor_offsets0, ofs[1] + motor_offsets1, ofs[2] + motor_offsets2) return ofs
def convert_jams(jams_file, output_prefix, csv=False, comment_char='#', namespaces=None): '''Convert jams to labs. Parameters ---------- jams_file : str The path on disk to the jams file in question output_prefix : str The file path prefix of the outputs csv : bool Whether to output in csv (True) or lab (False) format comment_char : str The character used to denote comments namespaces : list-like The set of namespace patterns to match for output ''' if namespaces is None: raise ValueError('No namespaces provided. Try ".*" for all namespaces.') jam = jams.load(jams_file) # Get all the annotations # Filter down to the unique ones # For each annotation # generate the comment string # generate the output filename # dump to csv # Make a counter object for each namespace type counter = collections.Counter() annotations = [] for query in namespaces: annotations.extend(jam.search(namespace=query)) if csv: suffix = 'csv' sep = ',' else: suffix = 'lab' sep = '\t' for ann in annotations: index = counter[ann.namespace] counter[ann.namespace] += 1 filename = os.path.extsep.join([get_output_name(output_prefix, ann.namespace, index), suffix]) comment = get_comments(jam, ann) # Dump to disk lab_dump(ann, comment, filename, sep, comment_char)
Convert jams to labs. Parameters ---------- jams_file : str The path on disk to the jams file in question output_prefix : str The file path prefix of the outputs csv : bool Whether to output in csv (True) or lab (False) format comment_char : str The character used to denote comments namespaces : list-like The set of namespace patterns to match for output
Below is the the instruction that describes the task: ### Input: Convert jams to labs. Parameters ---------- jams_file : str The path on disk to the jams file in question output_prefix : str The file path prefix of the outputs csv : bool Whether to output in csv (True) or lab (False) format comment_char : str The character used to denote comments namespaces : list-like The set of namespace patterns to match for output ### Response: def convert_jams(jams_file, output_prefix, csv=False, comment_char='#', namespaces=None): '''Convert jams to labs. Parameters ---------- jams_file : str The path on disk to the jams file in question output_prefix : str The file path prefix of the outputs csv : bool Whether to output in csv (True) or lab (False) format comment_char : str The character used to denote comments namespaces : list-like The set of namespace patterns to match for output ''' if namespaces is None: raise ValueError('No namespaces provided. Try ".*" for all namespaces.') jam = jams.load(jams_file) # Get all the annotations # Filter down to the unique ones # For each annotation # generate the comment string # generate the output filename # dump to csv # Make a counter object for each namespace type counter = collections.Counter() annotations = [] for query in namespaces: annotations.extend(jam.search(namespace=query)) if csv: suffix = 'csv' sep = ',' else: suffix = 'lab' sep = '\t' for ann in annotations: index = counter[ann.namespace] counter[ann.namespace] += 1 filename = os.path.extsep.join([get_output_name(output_prefix, ann.namespace, index), suffix]) comment = get_comments(jam, ann) # Dump to disk lab_dump(ann, comment, filename, sep, comment_char)
def fn_ceil(self, value): """ Return the ceiling of a number. :param value: The number. :return: The ceiling of the number. """ if is_ndarray(value) or isinstance(value, (list, tuple)): return numpy.ceil(self._to_ndarray(value)) else: return math.ceil(value)
Return the ceiling of a number. :param value: The number. :return: The ceiling of the number.
Below is the the instruction that describes the task: ### Input: Return the ceiling of a number. :param value: The number. :return: The ceiling of the number. ### Response: def fn_ceil(self, value): """ Return the ceiling of a number. :param value: The number. :return: The ceiling of the number. """ if is_ndarray(value) or isinstance(value, (list, tuple)): return numpy.ceil(self._to_ndarray(value)) else: return math.ceil(value)
def RelayDirectly(self, inventory): """ Relay the inventory to the remote client. Args: inventory (neo.Network.Inventory): Returns: bool: True if relayed successfully. False otherwise. """ relayed = False self.RelayCache[inventory.Hash.ToBytes()] = inventory for peer in self.Peers: relayed |= peer.Relay(inventory) if len(self.Peers) == 0: if type(BC.Default()) is TestLevelDBBlockchain: # mock a true result for tests return True logger.info("no connected peers") return relayed
Relay the inventory to the remote client. Args: inventory (neo.Network.Inventory): Returns: bool: True if relayed successfully. False otherwise.
Below is the the instruction that describes the task: ### Input: Relay the inventory to the remote client. Args: inventory (neo.Network.Inventory): Returns: bool: True if relayed successfully. False otherwise. ### Response: def RelayDirectly(self, inventory): """ Relay the inventory to the remote client. Args: inventory (neo.Network.Inventory): Returns: bool: True if relayed successfully. False otherwise. """ relayed = False self.RelayCache[inventory.Hash.ToBytes()] = inventory for peer in self.Peers: relayed |= peer.Relay(inventory) if len(self.Peers) == 0: if type(BC.Default()) is TestLevelDBBlockchain: # mock a true result for tests return True logger.info("no connected peers") return relayed
def _add_colorbar(ax: Axes, cmap: colors.Colormap, cmap_data: np.ndarray, norm: colors.Normalize): """Show a colorbar right of the plot.""" fig = ax.get_figure() mappable = cm.ScalarMappable(cmap=cmap, norm=norm) mappable.set_array(cmap_data) # TODO: Or what??? fig.colorbar(mappable, ax=ax)
Show a colorbar right of the plot.
Below is the the instruction that describes the task: ### Input: Show a colorbar right of the plot. ### Response: def _add_colorbar(ax: Axes, cmap: colors.Colormap, cmap_data: np.ndarray, norm: colors.Normalize): """Show a colorbar right of the plot.""" fig = ax.get_figure() mappable = cm.ScalarMappable(cmap=cmap, norm=norm) mappable.set_array(cmap_data) # TODO: Or what??? fig.colorbar(mappable, ax=ax)
def _skew_symmetric_translation(pos_A_in_B): """ Helper function to get a skew symmetric translation matrix for converting quantities between frames. """ return np.array( [ 0., -pos_A_in_B[2], pos_A_in_B[1], pos_A_in_B[2], 0., -pos_A_in_B[0], -pos_A_in_B[1], pos_A_in_B[0], 0., ] ).reshape((3, 3))
Helper function to get a skew symmetric translation matrix for converting quantities between frames.
Below is the the instruction that describes the task: ### Input: Helper function to get a skew symmetric translation matrix for converting quantities between frames. ### Response: def _skew_symmetric_translation(pos_A_in_B): """ Helper function to get a skew symmetric translation matrix for converting quantities between frames. """ return np.array( [ 0., -pos_A_in_B[2], pos_A_in_B[1], pos_A_in_B[2], 0., -pos_A_in_B[0], -pos_A_in_B[1], pos_A_in_B[0], 0., ] ).reshape((3, 3))
def close(self): """Close the notification.""" with self.selenium.context(self.selenium.CONTEXT_CHROME): if self.window.firefox_version > 63: self.find_primary_button().click() self.window.wait_for_notification(None) else: BaseNotification.close(self)
Close the notification.
Below is the the instruction that describes the task: ### Input: Close the notification. ### Response: def close(self): """Close the notification.""" with self.selenium.context(self.selenium.CONTEXT_CHROME): if self.window.firefox_version > 63: self.find_primary_button().click() self.window.wait_for_notification(None) else: BaseNotification.close(self)
def equals(self, other): """ Determines if two MultiIndex objects have the same labeling information (the levels themselves do not necessarily have to be the same) See Also -------- equal_levels """ if self.is_(other): return True if not isinstance(other, Index): return False if not isinstance(other, MultiIndex): other_vals = com.values_from_object(ensure_index(other)) return array_equivalent(self._ndarray_values, other_vals) if self.nlevels != other.nlevels: return False if len(self) != len(other): return False for i in range(self.nlevels): self_codes = self.codes[i] self_codes = self_codes[self_codes != -1] self_values = algos.take_nd(np.asarray(self.levels[i]._values), self_codes, allow_fill=False) other_codes = other.codes[i] other_codes = other_codes[other_codes != -1] other_values = algos.take_nd( np.asarray(other.levels[i]._values), other_codes, allow_fill=False) # since we use NaT both datetime64 and timedelta64 # we can have a situation where a level is typed say # timedelta64 in self (IOW it has other values than NaT) # but types datetime64 in other (where its all NaT) # but these are equivalent if len(self_values) == 0 and len(other_values) == 0: continue if not array_equivalent(self_values, other_values): return False return True
Determines if two MultiIndex objects have the same labeling information (the levels themselves do not necessarily have to be the same) See Also -------- equal_levels
Below is the the instruction that describes the task: ### Input: Determines if two MultiIndex objects have the same labeling information (the levels themselves do not necessarily have to be the same) See Also -------- equal_levels ### Response: def equals(self, other): """ Determines if two MultiIndex objects have the same labeling information (the levels themselves do not necessarily have to be the same) See Also -------- equal_levels """ if self.is_(other): return True if not isinstance(other, Index): return False if not isinstance(other, MultiIndex): other_vals = com.values_from_object(ensure_index(other)) return array_equivalent(self._ndarray_values, other_vals) if self.nlevels != other.nlevels: return False if len(self) != len(other): return False for i in range(self.nlevels): self_codes = self.codes[i] self_codes = self_codes[self_codes != -1] self_values = algos.take_nd(np.asarray(self.levels[i]._values), self_codes, allow_fill=False) other_codes = other.codes[i] other_codes = other_codes[other_codes != -1] other_values = algos.take_nd( np.asarray(other.levels[i]._values), other_codes, allow_fill=False) # since we use NaT both datetime64 and timedelta64 # we can have a situation where a level is typed say # timedelta64 in self (IOW it has other values than NaT) # but types datetime64 in other (where its all NaT) # but these are equivalent if len(self_values) == 0 and len(other_values) == 0: continue if not array_equivalent(self_values, other_values): return False return True
def puts(self, addr, s): """Put string of bytes at given address. Will overwrite any previous entries. """ a = array('B', asbytes(s)) for i in range_g(len(a)): self._buf[addr+i] = a[i]
Put string of bytes at given address. Will overwrite any previous entries.
Below is the the instruction that describes the task: ### Input: Put string of bytes at given address. Will overwrite any previous entries. ### Response: def puts(self, addr, s): """Put string of bytes at given address. Will overwrite any previous entries. """ a = array('B', asbytes(s)) for i in range_g(len(a)): self._buf[addr+i] = a[i]
def show_workspace(self, name): """Show specific workspace.""" if not self.workspace.exists(name): raise ValueError("Workspace `%s` doesn't exists." % name) color = Color() workspaces = self.workspace.list() self.logger.info("<== %s workspace ==>" % color.colored(name, "green")) self.logger.info("\tPath: %s" % workspaces[name]["path"]) self.logger.info("\tNumber of repositories: %s" % color.colored( len(workspaces[name]["repositories"]), "yellow")) repo_colored = color.colored("Repositories", "blue") path_colored = color.colored("Path", "blue") trepositories = PrettyTable( [repo_colored, path_colored, color.colored("+", "blue")]) trepositories.align[repo_colored] = "l" trepositories.align[path_colored] = "l" for repo_name in workspaces[name]["repositories"]: fullname = "%s/%s" % (name, repo_name) fullpath = find_path(fullname, self.config)[fullname] try: repo = Repository(fullpath) repo_scm = repo.get_scm() except RepositoryAdapterNotFound: repo_scm = None trepositories.add_row( [color.colored(repo_name, "cyan"), fullpath, repo_scm]) self.logger.info(trepositories)
Show specific workspace.
Below is the the instruction that describes the task: ### Input: Show specific workspace. ### Response: def show_workspace(self, name): """Show specific workspace.""" if not self.workspace.exists(name): raise ValueError("Workspace `%s` doesn't exists." % name) color = Color() workspaces = self.workspace.list() self.logger.info("<== %s workspace ==>" % color.colored(name, "green")) self.logger.info("\tPath: %s" % workspaces[name]["path"]) self.logger.info("\tNumber of repositories: %s" % color.colored( len(workspaces[name]["repositories"]), "yellow")) repo_colored = color.colored("Repositories", "blue") path_colored = color.colored("Path", "blue") trepositories = PrettyTable( [repo_colored, path_colored, color.colored("+", "blue")]) trepositories.align[repo_colored] = "l" trepositories.align[path_colored] = "l" for repo_name in workspaces[name]["repositories"]: fullname = "%s/%s" % (name, repo_name) fullpath = find_path(fullname, self.config)[fullname] try: repo = Repository(fullpath) repo_scm = repo.get_scm() except RepositoryAdapterNotFound: repo_scm = None trepositories.add_row( [color.colored(repo_name, "cyan"), fullpath, repo_scm]) self.logger.info(trepositories)
def generate_image_beacon(self, event_collection, event_body, timestamp=None): """ Generates an image beacon URL. :param event_collection: the name of the collection to insert the event to :param event_body: dict, the body of the event to insert the event to :param timestamp: datetime, optional, the timestamp of the event """ event = Event(self.project_id, event_collection, event_body, timestamp=timestamp) event_json = event.to_json() return "{0}/{1}/projects/{2}/events/{3}?api_key={4}&data={5}".format( self.api.base_url, self.api.api_version, self.project_id, self._url_escape(event_collection), self.api.write_key.decode(sys.getdefaultencoding()), self._base64_encode(event_json) )
Generates an image beacon URL. :param event_collection: the name of the collection to insert the event to :param event_body: dict, the body of the event to insert the event to :param timestamp: datetime, optional, the timestamp of the event
Below is the the instruction that describes the task: ### Input: Generates an image beacon URL. :param event_collection: the name of the collection to insert the event to :param event_body: dict, the body of the event to insert the event to :param timestamp: datetime, optional, the timestamp of the event ### Response: def generate_image_beacon(self, event_collection, event_body, timestamp=None): """ Generates an image beacon URL. :param event_collection: the name of the collection to insert the event to :param event_body: dict, the body of the event to insert the event to :param timestamp: datetime, optional, the timestamp of the event """ event = Event(self.project_id, event_collection, event_body, timestamp=timestamp) event_json = event.to_json() return "{0}/{1}/projects/{2}/events/{3}?api_key={4}&data={5}".format( self.api.base_url, self.api.api_version, self.project_id, self._url_escape(event_collection), self.api.write_key.decode(sys.getdefaultencoding()), self._base64_encode(event_json) )
def main(command_line=True, **kwargs): """ NAME utrecht_magic.py DESCRIPTION converts Utrecht magnetometer data files to magic_measurements files SYNTAX utrecht_magic.py [command line options] OPTIONS -h: prints the help message and quits. -f FILE: specify input file, or -F FILE: specify output file, default is magic_measurements.txt -Fsa: specify er_samples format file for appending, default is new er_samples.txt (Not working yet) -WD: output directory for MagIC files -ncn: Site Naming Convention Site to Sample naming convention: [1] XXXXY: where XXXX is an arbitrary length site designation and Y is the single character sample designation. e.g., TG001a is the first sample from site TG001. [default] [2: default] XXXX-YY: YY sample from site XXXX (XXX, YY of arbitary length) [3] XXXX.YY: YY sample from site XXXX (XXX, YY of arbitary length) [4-Z] XXXX[YYY]: YYY is sample designation with Z characters from site XXX [5] site name = sample name [6] site name entered in site_name column in the orient.txt format input file -- NOT CURRENTLY SUPPORTED [7-Z] [XXX]YYY: XXX is site designation with Z characters from samples XXXYYY -spc: number of characters to remove to generate sample names from specimen names -dmy: European date format -loc LOCNAME : specify location/study name -lat latitude of samples -lon longitude of samples -A: don't average replicate measurements -mcd: [SO-MAG,SO-SUN,SO-SIGHT...] supply how these samples were oriented -dc: B PHI THETA: dc lab field (in microTesla), phi,and theta must be input as a tuple "(DC,PHI,THETA)". If not input user will be asked for values, this is advantagious if there are differing dc fields between steps or specimens. Note: this currently only works with the decimal IZZI naming convetion (XXX.0,1,2,3 where XXX is the treatment temperature and 0 is a zero field step, 1 is in field, and 2 is a pTRM check, 3 is a tail check). All other steps are hardcoded dc_field = 0. INPUT Utrecht magnetometer data file """ # initialize some stuff sample_lat = 0.0 sample_lon = 0.0 noave = 0 er_location_name = "unknown" args = sys.argv meth_code = "LP-NO" version_num = pmag.get_version() site_num = 1 mag_file = "" dir_path = '.' MagRecs = [] SpecOuts = [] SampOuts = [] SiteOuts = [] meas_file='magic_measurements.txt' spec_file='er_specimens.txt' samp_file='er_samples.txt' site_file='er_sites.txt' meth_code = "" # # get command line arguments # if command_line: if '-WD' in sys.argv: ind = sys.argv.index('-WD') dir_path = sys.argv[ind+1] if '-ID' in sys.argv: ind = sys.argv.index('-ID') input_dir_path = sys.argv[ind+1] else: input_dir_path = dir_path output_dir_path = dir_path if "-h" in args: print(main.__doc__) return False if '-F' in args: ind = args.index("-F") meas_file = args[ind+1] if '-Fsp' in args: ind=args.index("-Fsp") spec_file=args[ind+1] if '-Fsa' in args: ind = args.index("-Fsa") samp_file = args[ind+1] if '-Fsi' in args: # LORI addition ind=args.index("-Fsi") site_file=args[ind+1] #try: # open(samp_file,'r') # ErSamps,file_type=pmag.magic_read(samp_file) # print 'sample information will be appended to ', samp_file #except: # print samp_file,' not found: sample information will be stored in new er_samples.txt file' # samp_file = output_dir_path+'/er_samples.txt' if '-f' in args: ind = args.index("-f") mag_file = args[ind+1] if "-loc" in args: ind = args.index("-loc") er_location_name = args[ind+1] if "-lat" in args: ind = args.index("-lat") site_lat = args[ind+1] if "-lon" in args: ind = args.index("-lon") site_lon = args[ind+1] if "-A" in args: noave = 1 if "-mcd" in args: ind = args.index("-mcd") meth_code = args[ind+1] #samp_con='5' if "-ncn" in args: ind=args.index("-ncn") samp_con=sys.argv[ind+1] if "4" in samp_con: if "-" not in samp_con: print("option [4] must be in form 4-Z where Z is an integer") return False, "naming convention option [4] must be in form 4-Z where Z is an integer" else: site_num=samp_con.split("-")[1] samp_con="4" elif "7" in samp_con: if "-" not in samp_con: print("option [7] must be in form 7-Z where Z is an integer") return False, "naming convention option [7] must be in form 7-Z where Z is an integer" else: site_num=samp_con.split("-")[1] samp_con="7" else: samp_con="1" if '-dc' in args: ind=args.index('-dc') DC_FIELD,DC_PHI,DC_THETA=list(map(float,args[ind+1].strip('( ) [ ]').split(','))) DC_FIELD *= 1e-6 yn='' GET_DC_PARAMS=False else: DC_FIELD,DC_PHI,DC_THETA=0,0,-90 if '-spc' in args: ind=args.index("-spc") specnum=-int(args[ind+1]) else: specnum = 0 if '-dmy' in args: ind=args.index("-dmy") dmy_flag=True else: dmy_flag=False if not command_line: dir_path = kwargs.get('dir_path', '.') input_dir_path = kwargs.get('input_dir_path', dir_path) output_dir_path = dir_path meas_file = kwargs.get('meas_file', 'magic_measurements.txt') mag_file = kwargs.get('mag_file') spec_file = kwargs.get('spec_file', 'er_specimens.txt') # specimen outfile samp_file = kwargs.get('samp_file', 'er_samples.txt') site_file = kwargs.get('site_file', 'er_sites.txt') # site outfile er_location_name = kwargs.get('location_name', '') site_lat = kwargs.get('site_lat', '') site_lon = kwargs.get('site_lon', '') #oave = kwargs.get('noave', 0) # default (0) means DO average meth_code = kwargs.get('meth_code', "LP-NO") specnum = -int(kwargs.get('specnum', 0)) samp_con = kwargs.get('samp_con', '2') if "4" in samp_con: if "-" not in samp_con: print("option [4] must be in form 4-Z where Z is an integer") return False, "naming convention option [4] must be in form 4-Z where Z is an integer" else: site_num=samp_con.split("-")[1] samp_con="4" elif "7" in samp_con: if "-" not in samp_con: print("option [7] must be in form 7-Z where Z is an integer") return False, "naming convention option [7] must be in form 7-Z where Z is an integer" else: site_num=samp_con.split("-")[1] samp_con="7" DC_FIELD,DC_PHI,DC_THETA = list(map(float, kwargs.get('dc_params', (0,0,-90)))) DC_FIELD *= 1e-6 noave = kwargs.get('avg', True) dmy_flag = kwargs.get('dmy_flag', False) # format variables if not mag_file: return False, 'You must provide a Utrecht formated file' mag_file = os.path.join(input_dir_path, mag_file) meas_file = os.path.join(output_dir_path, meas_file) spec_file = os.path.join(output_dir_path, spec_file) samp_file = os.path.join(output_dir_path, samp_file) site_file = os.path.join(output_dir_path, site_file) # parse data # Open up the Utrecht file and read the header information print('mag_file in utrecht_file', mag_file) AF_or_T = mag_file.split('.')[-1] data = open(mag_file, 'r') line = data.readline() line_items = line.split(',') operator=line_items[0] operator=operator.replace("\"","") machine=line_items[1] machine=machine.replace("\"","") machine=machine.rstrip('\n') print("operator=", operator) print("machine=", machine) #read in measurement data line = data.readline() while line != "END" and line != '"END"': ErSpecRec,ErSampRec,ErSiteRec = {},{},{} line_items = line.split(',') spec_name=line_items[0] spec_name=spec_name.replace("\"","") print("spec_name=", spec_name) free_string=line_items[1] free_string=free_string.replace("\"","") print("free_string=", free_string) dec=line_items[2] print("dec=", dec) inc=line_items[3] print("inc=", inc) volume=float(line_items[4]) volume=volume * 1e-6 # enter volume in cm^3, convert to m^3 print("volume=", volume) bed_plane=line_items[5] print("bed_plane=", bed_plane) bed_tilt=line_items[6] print("bed_tilt=", bed_tilt) # Configure et er_ tables ErSpecRec['er_specimen_name'] = spec_name if specnum==0: sample_name = spec_name else: sample_name = spec_name[:specnum] ErSampRec['er_sample_name'] = sample_name ErSpecRec['er_sample_name'] = sample_name er_site_name = pmag.parse_site(sample_name,samp_con,site_num) ErSpecRec['er_site_name']=er_site_name ErSpecRec['er_location_name']=er_location_name ErSampRec['sample_azimuth'] = dec ErSampRec['sample_dip'] = str(float(inc)-90) ErSampRec['sample_bed_dip_direction'] = bed_plane ErSampRec['sample_bed_tilt'] = bed_tilt ErSiteRec['site_lat'] = site_lat ErSiteRec['site_lon'] = site_lon ErSpecRec['magic_method_codes'] = meth_code ErSampRec['er_location_name'] = er_location_name ErSiteRec['er_location_name'] = er_location_name ErSiteRec['er_site_name'] = er_site_name ErSampRec['er_site_name'] = er_site_name ErSampRec['er_citation_names'] = 'This study' SpecOuts.append(ErSpecRec) SampOuts.append(ErSampRec) SiteOuts.append(ErSiteRec) #measurement data line = data.readline() line = line.rstrip("\n") items = line.split(",") while line != '9999': print(line) step=items[0] step=step.split('.') step_value=step[0] step_type = "" if len(step) == 2: step_type=step[1] if step_type=='5': step_value = items[0] A=float(items[1]) B=float(items[2]) C=float(items[3]) # convert to MagIC coordinates Z=-A X=-B Y=C cart = np.array([X, Y, Z]).transpose() direction = pmag.cart2dir(cart).transpose() measurement_dec = direction[0] measurement_inc = direction[1] measurement_magn_moment = direction[2] * 1.0e-12 # the data are in pico-Am^2 - this converts to Am^2 measurement_magn_volume = direction[2] * 1.0e-12 / volume # data volume normalized - converted to A/m print("measurement_magn_moment=", measurement_magn_moment) print("measurement_magn_volume=", measurement_magn_volume) error = items[4] date=items[5] date=date.strip('"') if date.count("-") > 0: date=date.split("-") elif date.count("/") > 0: date=date.split("/") else: print("date format seperator cannot be identified") print(date) time=items[6] time=time.strip('"') time=time.split(":") print(time) if dmy_flag: date_time = date[1] + ":" + date[0] + ":" + date[2] + ":" + time[0] + ":" + time[1] + ":" + "0.0" else: date_time = date[0] + ":" + date[1] + ":" + date[2] + ":" + time[0] + ":" + time[1] + ":" + "0.0" print(date_time) MagRec = {} MagRec["er_analyst_mail_names"] = operator MagRec["magic_instrument_codes"] = "Utrecht_" + machine MagRec["measurement_description"] = "free string = " + free_string MagRec["measurement_date"] = date_time MagRec["er_citation_names"] = "This study" MagRec['er_location_name'] = er_location_name MagRec['er_site_name'] = er_site_name MagRec['er_sample_name'] = sample_name MagRec['magic_software_packages'] = version_num MagRec["measurement_temp"] = '%8.3e' % (273) # room temp in kelvin MagRec["measurement_flag"] = 'g' MagRec["measurement_standard"] = 'u' MagRec["magic_experiment_name"] = er_location_name + er_site_name + spec_name MagRec["measurement_number"] = er_location_name + er_site_name + spec_name + items[0] MagRec["er_specimen_name"] = spec_name # MagRec["treatment_ac_field"] = '0' if AF_or_T.lower() == "th": MagRec["treatment_temp"] = '%8.3e' % (float(step_value)+273.) # temp in kelvin MagRec['treatment_ac_field']='0' meas_type = "LP-DIR-T:LT-T-Z" else: MagRec['treatment_temp']='273' MagRec['treatment_ac_field']='%10.3e'%(float(step_value)*1e-3) meas_type = "LP-DIR-AF:LT-AF-Z" MagRec['treatment_dc_field']='0' if step_value == '0': meas_type = "LT-NO" print("step_type=", step_type) if step_type == '0' and AF_or_T.lower() == 'th': if meas_type == "": meas_type = "LT-T-Z" else: meas_type = meas_type + ":" + "LT-T-Z" elif step_type == '1': if meas_type == "": meas_type = "LT-T-I" else: meas_type = meas_type + ":" + "LT-T-I" MagRec['treatment_dc_field']='%1.2e'%DC_FIELD elif step_type == '2': if meas_type == "": meas_type = "LT-PTRM-I" else: meas_type = meas_type + ":" + "LT-PTRM-I" MagRec['treatment_dc_field']='%1.2e'%DC_FIELD elif step_type == '3': if meas_type == "" : meas_type = "LT-PTRM-Z" else: meas_type = meas_type + ":" + "LT-PTRM-Z" print("meas_type=", meas_type) MagRec['treatment_dc_field_phi'] = '%1.2f'%DC_PHI MagRec['treatment_dc_field_theta'] = '%1.2f'%DC_THETA MagRec['magic_method_codes'] = meas_type MagRec["measurement_magn_moment"] = measurement_magn_moment MagRec["measurement_magn_volume"] = measurement_magn_volume MagRec["measurement_dec"] = measurement_dec MagRec["measurement_inc"] = measurement_inc MagRec['measurement_csd'] = error # MagRec['measurement_positions'] = '1' MagRecs.append(MagRec) line = data.readline() line = line.rstrip("\n") items = line.split(",") line = data.readline() line = line.rstrip("\n") items = line.split(",") # write out the data to MagIC data files pmag.magic_write(spec_file, SpecOuts, 'er_specimens') pmag.magic_write(samp_file, SampOuts, 'er_samples') pmag.magic_write(site_file, SiteOuts, 'er_sites') # MagOuts = pmag.measurements_methods(MagRecs, noave) # pmag.magic_write(meas_file, MagOuts, 'magic_measurements') pmag.magic_write(meas_file, MagRecs, 'magic_measurements') print("results put in ", meas_file) print("exit!") return True, meas_file
NAME utrecht_magic.py DESCRIPTION converts Utrecht magnetometer data files to magic_measurements files SYNTAX utrecht_magic.py [command line options] OPTIONS -h: prints the help message and quits. -f FILE: specify input file, or -F FILE: specify output file, default is magic_measurements.txt -Fsa: specify er_samples format file for appending, default is new er_samples.txt (Not working yet) -WD: output directory for MagIC files -ncn: Site Naming Convention Site to Sample naming convention: [1] XXXXY: where XXXX is an arbitrary length site designation and Y is the single character sample designation. e.g., TG001a is the first sample from site TG001. [default] [2: default] XXXX-YY: YY sample from site XXXX (XXX, YY of arbitary length) [3] XXXX.YY: YY sample from site XXXX (XXX, YY of arbitary length) [4-Z] XXXX[YYY]: YYY is sample designation with Z characters from site XXX [5] site name = sample name [6] site name entered in site_name column in the orient.txt format input file -- NOT CURRENTLY SUPPORTED [7-Z] [XXX]YYY: XXX is site designation with Z characters from samples XXXYYY -spc: number of characters to remove to generate sample names from specimen names -dmy: European date format -loc LOCNAME : specify location/study name -lat latitude of samples -lon longitude of samples -A: don't average replicate measurements -mcd: [SO-MAG,SO-SUN,SO-SIGHT...] supply how these samples were oriented -dc: B PHI THETA: dc lab field (in microTesla), phi,and theta must be input as a tuple "(DC,PHI,THETA)". If not input user will be asked for values, this is advantagious if there are differing dc fields between steps or specimens. Note: this currently only works with the decimal IZZI naming convetion (XXX.0,1,2,3 where XXX is the treatment temperature and 0 is a zero field step, 1 is in field, and 2 is a pTRM check, 3 is a tail check). All other steps are hardcoded dc_field = 0. INPUT Utrecht magnetometer data file
Below is the the instruction that describes the task: ### Input: NAME utrecht_magic.py DESCRIPTION converts Utrecht magnetometer data files to magic_measurements files SYNTAX utrecht_magic.py [command line options] OPTIONS -h: prints the help message and quits. -f FILE: specify input file, or -F FILE: specify output file, default is magic_measurements.txt -Fsa: specify er_samples format file for appending, default is new er_samples.txt (Not working yet) -WD: output directory for MagIC files -ncn: Site Naming Convention Site to Sample naming convention: [1] XXXXY: where XXXX is an arbitrary length site designation and Y is the single character sample designation. e.g., TG001a is the first sample from site TG001. [default] [2: default] XXXX-YY: YY sample from site XXXX (XXX, YY of arbitary length) [3] XXXX.YY: YY sample from site XXXX (XXX, YY of arbitary length) [4-Z] XXXX[YYY]: YYY is sample designation with Z characters from site XXX [5] site name = sample name [6] site name entered in site_name column in the orient.txt format input file -- NOT CURRENTLY SUPPORTED [7-Z] [XXX]YYY: XXX is site designation with Z characters from samples XXXYYY -spc: number of characters to remove to generate sample names from specimen names -dmy: European date format -loc LOCNAME : specify location/study name -lat latitude of samples -lon longitude of samples -A: don't average replicate measurements -mcd: [SO-MAG,SO-SUN,SO-SIGHT...] supply how these samples were oriented -dc: B PHI THETA: dc lab field (in microTesla), phi,and theta must be input as a tuple "(DC,PHI,THETA)". If not input user will be asked for values, this is advantagious if there are differing dc fields between steps or specimens. Note: this currently only works with the decimal IZZI naming convetion (XXX.0,1,2,3 where XXX is the treatment temperature and 0 is a zero field step, 1 is in field, and 2 is a pTRM check, 3 is a tail check). All other steps are hardcoded dc_field = 0. INPUT Utrecht magnetometer data file ### Response: def main(command_line=True, **kwargs): """ NAME utrecht_magic.py DESCRIPTION converts Utrecht magnetometer data files to magic_measurements files SYNTAX utrecht_magic.py [command line options] OPTIONS -h: prints the help message and quits. -f FILE: specify input file, or -F FILE: specify output file, default is magic_measurements.txt -Fsa: specify er_samples format file for appending, default is new er_samples.txt (Not working yet) -WD: output directory for MagIC files -ncn: Site Naming Convention Site to Sample naming convention: [1] XXXXY: where XXXX is an arbitrary length site designation and Y is the single character sample designation. e.g., TG001a is the first sample from site TG001. [default] [2: default] XXXX-YY: YY sample from site XXXX (XXX, YY of arbitary length) [3] XXXX.YY: YY sample from site XXXX (XXX, YY of arbitary length) [4-Z] XXXX[YYY]: YYY is sample designation with Z characters from site XXX [5] site name = sample name [6] site name entered in site_name column in the orient.txt format input file -- NOT CURRENTLY SUPPORTED [7-Z] [XXX]YYY: XXX is site designation with Z characters from samples XXXYYY -spc: number of characters to remove to generate sample names from specimen names -dmy: European date format -loc LOCNAME : specify location/study name -lat latitude of samples -lon longitude of samples -A: don't average replicate measurements -mcd: [SO-MAG,SO-SUN,SO-SIGHT...] supply how these samples were oriented -dc: B PHI THETA: dc lab field (in microTesla), phi,and theta must be input as a tuple "(DC,PHI,THETA)". If not input user will be asked for values, this is advantagious if there are differing dc fields between steps or specimens. Note: this currently only works with the decimal IZZI naming convetion (XXX.0,1,2,3 where XXX is the treatment temperature and 0 is a zero field step, 1 is in field, and 2 is a pTRM check, 3 is a tail check). All other steps are hardcoded dc_field = 0. INPUT Utrecht magnetometer data file """ # initialize some stuff sample_lat = 0.0 sample_lon = 0.0 noave = 0 er_location_name = "unknown" args = sys.argv meth_code = "LP-NO" version_num = pmag.get_version() site_num = 1 mag_file = "" dir_path = '.' MagRecs = [] SpecOuts = [] SampOuts = [] SiteOuts = [] meas_file='magic_measurements.txt' spec_file='er_specimens.txt' samp_file='er_samples.txt' site_file='er_sites.txt' meth_code = "" # # get command line arguments # if command_line: if '-WD' in sys.argv: ind = sys.argv.index('-WD') dir_path = sys.argv[ind+1] if '-ID' in sys.argv: ind = sys.argv.index('-ID') input_dir_path = sys.argv[ind+1] else: input_dir_path = dir_path output_dir_path = dir_path if "-h" in args: print(main.__doc__) return False if '-F' in args: ind = args.index("-F") meas_file = args[ind+1] if '-Fsp' in args: ind=args.index("-Fsp") spec_file=args[ind+1] if '-Fsa' in args: ind = args.index("-Fsa") samp_file = args[ind+1] if '-Fsi' in args: # LORI addition ind=args.index("-Fsi") site_file=args[ind+1] #try: # open(samp_file,'r') # ErSamps,file_type=pmag.magic_read(samp_file) # print 'sample information will be appended to ', samp_file #except: # print samp_file,' not found: sample information will be stored in new er_samples.txt file' # samp_file = output_dir_path+'/er_samples.txt' if '-f' in args: ind = args.index("-f") mag_file = args[ind+1] if "-loc" in args: ind = args.index("-loc") er_location_name = args[ind+1] if "-lat" in args: ind = args.index("-lat") site_lat = args[ind+1] if "-lon" in args: ind = args.index("-lon") site_lon = args[ind+1] if "-A" in args: noave = 1 if "-mcd" in args: ind = args.index("-mcd") meth_code = args[ind+1] #samp_con='5' if "-ncn" in args: ind=args.index("-ncn") samp_con=sys.argv[ind+1] if "4" in samp_con: if "-" not in samp_con: print("option [4] must be in form 4-Z where Z is an integer") return False, "naming convention option [4] must be in form 4-Z where Z is an integer" else: site_num=samp_con.split("-")[1] samp_con="4" elif "7" in samp_con: if "-" not in samp_con: print("option [7] must be in form 7-Z where Z is an integer") return False, "naming convention option [7] must be in form 7-Z where Z is an integer" else: site_num=samp_con.split("-")[1] samp_con="7" else: samp_con="1" if '-dc' in args: ind=args.index('-dc') DC_FIELD,DC_PHI,DC_THETA=list(map(float,args[ind+1].strip('( ) [ ]').split(','))) DC_FIELD *= 1e-6 yn='' GET_DC_PARAMS=False else: DC_FIELD,DC_PHI,DC_THETA=0,0,-90 if '-spc' in args: ind=args.index("-spc") specnum=-int(args[ind+1]) else: specnum = 0 if '-dmy' in args: ind=args.index("-dmy") dmy_flag=True else: dmy_flag=False if not command_line: dir_path = kwargs.get('dir_path', '.') input_dir_path = kwargs.get('input_dir_path', dir_path) output_dir_path = dir_path meas_file = kwargs.get('meas_file', 'magic_measurements.txt') mag_file = kwargs.get('mag_file') spec_file = kwargs.get('spec_file', 'er_specimens.txt') # specimen outfile samp_file = kwargs.get('samp_file', 'er_samples.txt') site_file = kwargs.get('site_file', 'er_sites.txt') # site outfile er_location_name = kwargs.get('location_name', '') site_lat = kwargs.get('site_lat', '') site_lon = kwargs.get('site_lon', '') #oave = kwargs.get('noave', 0) # default (0) means DO average meth_code = kwargs.get('meth_code', "LP-NO") specnum = -int(kwargs.get('specnum', 0)) samp_con = kwargs.get('samp_con', '2') if "4" in samp_con: if "-" not in samp_con: print("option [4] must be in form 4-Z where Z is an integer") return False, "naming convention option [4] must be in form 4-Z where Z is an integer" else: site_num=samp_con.split("-")[1] samp_con="4" elif "7" in samp_con: if "-" not in samp_con: print("option [7] must be in form 7-Z where Z is an integer") return False, "naming convention option [7] must be in form 7-Z where Z is an integer" else: site_num=samp_con.split("-")[1] samp_con="7" DC_FIELD,DC_PHI,DC_THETA = list(map(float, kwargs.get('dc_params', (0,0,-90)))) DC_FIELD *= 1e-6 noave = kwargs.get('avg', True) dmy_flag = kwargs.get('dmy_flag', False) # format variables if not mag_file: return False, 'You must provide a Utrecht formated file' mag_file = os.path.join(input_dir_path, mag_file) meas_file = os.path.join(output_dir_path, meas_file) spec_file = os.path.join(output_dir_path, spec_file) samp_file = os.path.join(output_dir_path, samp_file) site_file = os.path.join(output_dir_path, site_file) # parse data # Open up the Utrecht file and read the header information print('mag_file in utrecht_file', mag_file) AF_or_T = mag_file.split('.')[-1] data = open(mag_file, 'r') line = data.readline() line_items = line.split(',') operator=line_items[0] operator=operator.replace("\"","") machine=line_items[1] machine=machine.replace("\"","") machine=machine.rstrip('\n') print("operator=", operator) print("machine=", machine) #read in measurement data line = data.readline() while line != "END" and line != '"END"': ErSpecRec,ErSampRec,ErSiteRec = {},{},{} line_items = line.split(',') spec_name=line_items[0] spec_name=spec_name.replace("\"","") print("spec_name=", spec_name) free_string=line_items[1] free_string=free_string.replace("\"","") print("free_string=", free_string) dec=line_items[2] print("dec=", dec) inc=line_items[3] print("inc=", inc) volume=float(line_items[4]) volume=volume * 1e-6 # enter volume in cm^3, convert to m^3 print("volume=", volume) bed_plane=line_items[5] print("bed_plane=", bed_plane) bed_tilt=line_items[6] print("bed_tilt=", bed_tilt) # Configure et er_ tables ErSpecRec['er_specimen_name'] = spec_name if specnum==0: sample_name = spec_name else: sample_name = spec_name[:specnum] ErSampRec['er_sample_name'] = sample_name ErSpecRec['er_sample_name'] = sample_name er_site_name = pmag.parse_site(sample_name,samp_con,site_num) ErSpecRec['er_site_name']=er_site_name ErSpecRec['er_location_name']=er_location_name ErSampRec['sample_azimuth'] = dec ErSampRec['sample_dip'] = str(float(inc)-90) ErSampRec['sample_bed_dip_direction'] = bed_plane ErSampRec['sample_bed_tilt'] = bed_tilt ErSiteRec['site_lat'] = site_lat ErSiteRec['site_lon'] = site_lon ErSpecRec['magic_method_codes'] = meth_code ErSampRec['er_location_name'] = er_location_name ErSiteRec['er_location_name'] = er_location_name ErSiteRec['er_site_name'] = er_site_name ErSampRec['er_site_name'] = er_site_name ErSampRec['er_citation_names'] = 'This study' SpecOuts.append(ErSpecRec) SampOuts.append(ErSampRec) SiteOuts.append(ErSiteRec) #measurement data line = data.readline() line = line.rstrip("\n") items = line.split(",") while line != '9999': print(line) step=items[0] step=step.split('.') step_value=step[0] step_type = "" if len(step) == 2: step_type=step[1] if step_type=='5': step_value = items[0] A=float(items[1]) B=float(items[2]) C=float(items[3]) # convert to MagIC coordinates Z=-A X=-B Y=C cart = np.array([X, Y, Z]).transpose() direction = pmag.cart2dir(cart).transpose() measurement_dec = direction[0] measurement_inc = direction[1] measurement_magn_moment = direction[2] * 1.0e-12 # the data are in pico-Am^2 - this converts to Am^2 measurement_magn_volume = direction[2] * 1.0e-12 / volume # data volume normalized - converted to A/m print("measurement_magn_moment=", measurement_magn_moment) print("measurement_magn_volume=", measurement_magn_volume) error = items[4] date=items[5] date=date.strip('"') if date.count("-") > 0: date=date.split("-") elif date.count("/") > 0: date=date.split("/") else: print("date format seperator cannot be identified") print(date) time=items[6] time=time.strip('"') time=time.split(":") print(time) if dmy_flag: date_time = date[1] + ":" + date[0] + ":" + date[2] + ":" + time[0] + ":" + time[1] + ":" + "0.0" else: date_time = date[0] + ":" + date[1] + ":" + date[2] + ":" + time[0] + ":" + time[1] + ":" + "0.0" print(date_time) MagRec = {} MagRec["er_analyst_mail_names"] = operator MagRec["magic_instrument_codes"] = "Utrecht_" + machine MagRec["measurement_description"] = "free string = " + free_string MagRec["measurement_date"] = date_time MagRec["er_citation_names"] = "This study" MagRec['er_location_name'] = er_location_name MagRec['er_site_name'] = er_site_name MagRec['er_sample_name'] = sample_name MagRec['magic_software_packages'] = version_num MagRec["measurement_temp"] = '%8.3e' % (273) # room temp in kelvin MagRec["measurement_flag"] = 'g' MagRec["measurement_standard"] = 'u' MagRec["magic_experiment_name"] = er_location_name + er_site_name + spec_name MagRec["measurement_number"] = er_location_name + er_site_name + spec_name + items[0] MagRec["er_specimen_name"] = spec_name # MagRec["treatment_ac_field"] = '0' if AF_or_T.lower() == "th": MagRec["treatment_temp"] = '%8.3e' % (float(step_value)+273.) # temp in kelvin MagRec['treatment_ac_field']='0' meas_type = "LP-DIR-T:LT-T-Z" else: MagRec['treatment_temp']='273' MagRec['treatment_ac_field']='%10.3e'%(float(step_value)*1e-3) meas_type = "LP-DIR-AF:LT-AF-Z" MagRec['treatment_dc_field']='0' if step_value == '0': meas_type = "LT-NO" print("step_type=", step_type) if step_type == '0' and AF_or_T.lower() == 'th': if meas_type == "": meas_type = "LT-T-Z" else: meas_type = meas_type + ":" + "LT-T-Z" elif step_type == '1': if meas_type == "": meas_type = "LT-T-I" else: meas_type = meas_type + ":" + "LT-T-I" MagRec['treatment_dc_field']='%1.2e'%DC_FIELD elif step_type == '2': if meas_type == "": meas_type = "LT-PTRM-I" else: meas_type = meas_type + ":" + "LT-PTRM-I" MagRec['treatment_dc_field']='%1.2e'%DC_FIELD elif step_type == '3': if meas_type == "" : meas_type = "LT-PTRM-Z" else: meas_type = meas_type + ":" + "LT-PTRM-Z" print("meas_type=", meas_type) MagRec['treatment_dc_field_phi'] = '%1.2f'%DC_PHI MagRec['treatment_dc_field_theta'] = '%1.2f'%DC_THETA MagRec['magic_method_codes'] = meas_type MagRec["measurement_magn_moment"] = measurement_magn_moment MagRec["measurement_magn_volume"] = measurement_magn_volume MagRec["measurement_dec"] = measurement_dec MagRec["measurement_inc"] = measurement_inc MagRec['measurement_csd'] = error # MagRec['measurement_positions'] = '1' MagRecs.append(MagRec) line = data.readline() line = line.rstrip("\n") items = line.split(",") line = data.readline() line = line.rstrip("\n") items = line.split(",") # write out the data to MagIC data files pmag.magic_write(spec_file, SpecOuts, 'er_specimens') pmag.magic_write(samp_file, SampOuts, 'er_samples') pmag.magic_write(site_file, SiteOuts, 'er_sites') # MagOuts = pmag.measurements_methods(MagRecs, noave) # pmag.magic_write(meas_file, MagOuts, 'magic_measurements') pmag.magic_write(meas_file, MagRecs, 'magic_measurements') print("results put in ", meas_file) print("exit!") return True, meas_file
def slice_by_component( self, component_index, start, end ): """ Return a slice of the alignment, corresponding to an coordinate interval in a specific component. component_index is one of an integer offset into the components list a string indicating the src of the desired component a component start and end are relative to the + strand, regardless of the component's strand. """ if type( component_index ) == type( 0 ): ref = self.components[ component_index ] elif type( component_index ) == type( "" ): ref = self.get_component_by_src( component_index ) elif type( component_index ) == Component: ref = component_index else: raise ValueError( "can't figure out what to do" ) start_col = ref.coord_to_col( start ) end_col = ref.coord_to_col( end ) if (ref.strand == '-'): (start_col,end_col) = (end_col,start_col) return self.slice( start_col, end_col )
Return a slice of the alignment, corresponding to an coordinate interval in a specific component. component_index is one of an integer offset into the components list a string indicating the src of the desired component a component start and end are relative to the + strand, regardless of the component's strand.
Below is the the instruction that describes the task: ### Input: Return a slice of the alignment, corresponding to an coordinate interval in a specific component. component_index is one of an integer offset into the components list a string indicating the src of the desired component a component start and end are relative to the + strand, regardless of the component's strand. ### Response: def slice_by_component( self, component_index, start, end ): """ Return a slice of the alignment, corresponding to an coordinate interval in a specific component. component_index is one of an integer offset into the components list a string indicating the src of the desired component a component start and end are relative to the + strand, regardless of the component's strand. """ if type( component_index ) == type( 0 ): ref = self.components[ component_index ] elif type( component_index ) == type( "" ): ref = self.get_component_by_src( component_index ) elif type( component_index ) == Component: ref = component_index else: raise ValueError( "can't figure out what to do" ) start_col = ref.coord_to_col( start ) end_col = ref.coord_to_col( end ) if (ref.strand == '-'): (start_col,end_col) = (end_col,start_col) return self.slice( start_col, end_col )
def summarize_dataframe(self): """Summarize default dataframe for this cohort using a hash function. Useful for confirming the version of data used in various reports, e.g. ipynbs """ if self.dataframe_hash: return(self.dataframe_hash) else: df = self._as_dataframe_unmodified() return(self.dataframe_hash)
Summarize default dataframe for this cohort using a hash function. Useful for confirming the version of data used in various reports, e.g. ipynbs
Below is the the instruction that describes the task: ### Input: Summarize default dataframe for this cohort using a hash function. Useful for confirming the version of data used in various reports, e.g. ipynbs ### Response: def summarize_dataframe(self): """Summarize default dataframe for this cohort using a hash function. Useful for confirming the version of data used in various reports, e.g. ipynbs """ if self.dataframe_hash: return(self.dataframe_hash) else: df = self._as_dataframe_unmodified() return(self.dataframe_hash)
def Query(self, query, parameters=None): """Queries the database file. Args: query (str): SQL query. parameters (Optional[dict|tuple]): query parameters. Returns: list[sqlite3.Row]: rows resulting from the query. """ # TODO: catch Warning and return None. # Note that we cannot pass parameters as a keyword argument here. # A parameters value of None is not supported. if parameters: self._cursor.execute(query, parameters) else: self._cursor.execute(query) return self._cursor.fetchall()
Queries the database file. Args: query (str): SQL query. parameters (Optional[dict|tuple]): query parameters. Returns: list[sqlite3.Row]: rows resulting from the query.
Below is the the instruction that describes the task: ### Input: Queries the database file. Args: query (str): SQL query. parameters (Optional[dict|tuple]): query parameters. Returns: list[sqlite3.Row]: rows resulting from the query. ### Response: def Query(self, query, parameters=None): """Queries the database file. Args: query (str): SQL query. parameters (Optional[dict|tuple]): query parameters. Returns: list[sqlite3.Row]: rows resulting from the query. """ # TODO: catch Warning and return None. # Note that we cannot pass parameters as a keyword argument here. # A parameters value of None is not supported. if parameters: self._cursor.execute(query, parameters) else: self._cursor.execute(query) return self._cursor.fetchall()
def file_uptodate(fname, cmp_fname): """Check if a file exists, is non-empty and is more recent than cmp_fname. """ try: return (file_exists(fname) and file_exists(cmp_fname) and getmtime(fname) >= getmtime(cmp_fname)) except OSError: return False
Check if a file exists, is non-empty and is more recent than cmp_fname.
Below is the the instruction that describes the task: ### Input: Check if a file exists, is non-empty and is more recent than cmp_fname. ### Response: def file_uptodate(fname, cmp_fname): """Check if a file exists, is non-empty and is more recent than cmp_fname. """ try: return (file_exists(fname) and file_exists(cmp_fname) and getmtime(fname) >= getmtime(cmp_fname)) except OSError: return False
def current_version(self, object, relations_as_of=None, check_db=False): """ Return the current version of the given object. The current version is the one having its version_end_date set to NULL. If there is not such a version then it means the object has been 'deleted' and so there is no current version available. In this case the function returns None. Note that if check_db is False and object's version_end_date is None, this does not check the database to see if there is a newer version (perhaps created by some other code), it simply returns the passed object. ``relations_as_of`` is used to fix the point in time for the version; this affects which related objects are returned when querying for object relations. See ``VersionManager.version_as_of`` for details on valid ``relations_as_of`` values. :param Versionable object: object whose current version will be returned. :param mixed relations_as_of: determines point in time used to access relations. 'start'|'end'|datetime|None :param bool check_db: Whether or not to look in the database for a more recent version :return: Versionable """ if object.version_end_date is None and not check_db: current = object else: current = self.current.filter(identity=object.identity).first() return self.adjust_version_as_of(current, relations_as_of)
Return the current version of the given object. The current version is the one having its version_end_date set to NULL. If there is not such a version then it means the object has been 'deleted' and so there is no current version available. In this case the function returns None. Note that if check_db is False and object's version_end_date is None, this does not check the database to see if there is a newer version (perhaps created by some other code), it simply returns the passed object. ``relations_as_of`` is used to fix the point in time for the version; this affects which related objects are returned when querying for object relations. See ``VersionManager.version_as_of`` for details on valid ``relations_as_of`` values. :param Versionable object: object whose current version will be returned. :param mixed relations_as_of: determines point in time used to access relations. 'start'|'end'|datetime|None :param bool check_db: Whether or not to look in the database for a more recent version :return: Versionable
Below is the the instruction that describes the task: ### Input: Return the current version of the given object. The current version is the one having its version_end_date set to NULL. If there is not such a version then it means the object has been 'deleted' and so there is no current version available. In this case the function returns None. Note that if check_db is False and object's version_end_date is None, this does not check the database to see if there is a newer version (perhaps created by some other code), it simply returns the passed object. ``relations_as_of`` is used to fix the point in time for the version; this affects which related objects are returned when querying for object relations. See ``VersionManager.version_as_of`` for details on valid ``relations_as_of`` values. :param Versionable object: object whose current version will be returned. :param mixed relations_as_of: determines point in time used to access relations. 'start'|'end'|datetime|None :param bool check_db: Whether or not to look in the database for a more recent version :return: Versionable ### Response: def current_version(self, object, relations_as_of=None, check_db=False): """ Return the current version of the given object. The current version is the one having its version_end_date set to NULL. If there is not such a version then it means the object has been 'deleted' and so there is no current version available. In this case the function returns None. Note that if check_db is False and object's version_end_date is None, this does not check the database to see if there is a newer version (perhaps created by some other code), it simply returns the passed object. ``relations_as_of`` is used to fix the point in time for the version; this affects which related objects are returned when querying for object relations. See ``VersionManager.version_as_of`` for details on valid ``relations_as_of`` values. :param Versionable object: object whose current version will be returned. :param mixed relations_as_of: determines point in time used to access relations. 'start'|'end'|datetime|None :param bool check_db: Whether or not to look in the database for a more recent version :return: Versionable """ if object.version_end_date is None and not check_db: current = object else: current = self.current.filter(identity=object.identity).first() return self.adjust_version_as_of(current, relations_as_of)
def axes_off(ax): """Get rid of all axis ticks, lines, etc. """ ax.set_frame_on(False) ax.axes.get_yaxis().set_visible(False) ax.axes.get_xaxis().set_visible(False)
Get rid of all axis ticks, lines, etc.
Below is the the instruction that describes the task: ### Input: Get rid of all axis ticks, lines, etc. ### Response: def axes_off(ax): """Get rid of all axis ticks, lines, etc. """ ax.set_frame_on(False) ax.axes.get_yaxis().set_visible(False) ax.axes.get_xaxis().set_visible(False)
def rewrite_to_secure_url(url, secure_base=None): """ Rewrite URL to a Secure URL @param url URL to be rewritten to a secure URL. @param secure_base: Base URL of secure site (defaults to CFG_SITE_SECURE_URL). """ if secure_base is None: secure_base = cfg.get('CFG_SITE_SECURE_URL') url_parts = list(urlparse(url)) url_secure_parts = urlparse(secure_base) url_parts[0] = url_secure_parts[0] url_parts[1] = url_secure_parts[1] return urlunparse(url_parts)
Rewrite URL to a Secure URL @param url URL to be rewritten to a secure URL. @param secure_base: Base URL of secure site (defaults to CFG_SITE_SECURE_URL).
Below is the the instruction that describes the task: ### Input: Rewrite URL to a Secure URL @param url URL to be rewritten to a secure URL. @param secure_base: Base URL of secure site (defaults to CFG_SITE_SECURE_URL). ### Response: def rewrite_to_secure_url(url, secure_base=None): """ Rewrite URL to a Secure URL @param url URL to be rewritten to a secure URL. @param secure_base: Base URL of secure site (defaults to CFG_SITE_SECURE_URL). """ if secure_base is None: secure_base = cfg.get('CFG_SITE_SECURE_URL') url_parts = list(urlparse(url)) url_secure_parts = urlparse(secure_base) url_parts[0] = url_secure_parts[0] url_parts[1] = url_secure_parts[1] return urlunparse(url_parts)
def finalize_filename(filename, file_format=None): """ Replaces invalid characters in filename string, adds image extension and reduces filename length :param filename: Incomplete filename string :type filename: str :param file_format: Format which will be used for filename extension :type file_format: MimeType :return: Final filename string :rtype: str """ for char in [' ', '/', '\\', '|', ';', ':', '\n', '\t']: filename = filename.replace(char, '') if file_format: suffix = str(file_format.value) if file_format.is_tiff_format() and file_format is not MimeType.TIFF: suffix = str(MimeType.TIFF.value) filename = '_'.join([filename, str(file_format.value).replace(';', '_')]) filename = '.'.join([filename[:254 - len(suffix)], suffix]) LOGGER.debug("filename=%s", filename) return filename
Replaces invalid characters in filename string, adds image extension and reduces filename length :param filename: Incomplete filename string :type filename: str :param file_format: Format which will be used for filename extension :type file_format: MimeType :return: Final filename string :rtype: str
Below is the the instruction that describes the task: ### Input: Replaces invalid characters in filename string, adds image extension and reduces filename length :param filename: Incomplete filename string :type filename: str :param file_format: Format which will be used for filename extension :type file_format: MimeType :return: Final filename string :rtype: str ### Response: def finalize_filename(filename, file_format=None): """ Replaces invalid characters in filename string, adds image extension and reduces filename length :param filename: Incomplete filename string :type filename: str :param file_format: Format which will be used for filename extension :type file_format: MimeType :return: Final filename string :rtype: str """ for char in [' ', '/', '\\', '|', ';', ':', '\n', '\t']: filename = filename.replace(char, '') if file_format: suffix = str(file_format.value) if file_format.is_tiff_format() and file_format is not MimeType.TIFF: suffix = str(MimeType.TIFF.value) filename = '_'.join([filename, str(file_format.value).replace(';', '_')]) filename = '.'.join([filename[:254 - len(suffix)], suffix]) LOGGER.debug("filename=%s", filename) return filename
def _check_cpd_inputs(X, rank): """Checks that inputs to optimization function are appropriate. Parameters ---------- X : ndarray Tensor used for fitting CP decomposition. rank : int Rank of low rank decomposition. Raises ------ ValueError: If inputs are not suited for CP decomposition. """ if X.ndim < 3: raise ValueError("Array with X.ndim > 2 expected.") if rank <= 0 or not isinstance(rank, int): raise ValueError("Rank is invalid.")
Checks that inputs to optimization function are appropriate. Parameters ---------- X : ndarray Tensor used for fitting CP decomposition. rank : int Rank of low rank decomposition. Raises ------ ValueError: If inputs are not suited for CP decomposition.
Below is the the instruction that describes the task: ### Input: Checks that inputs to optimization function are appropriate. Parameters ---------- X : ndarray Tensor used for fitting CP decomposition. rank : int Rank of low rank decomposition. Raises ------ ValueError: If inputs are not suited for CP decomposition. ### Response: def _check_cpd_inputs(X, rank): """Checks that inputs to optimization function are appropriate. Parameters ---------- X : ndarray Tensor used for fitting CP decomposition. rank : int Rank of low rank decomposition. Raises ------ ValueError: If inputs are not suited for CP decomposition. """ if X.ndim < 3: raise ValueError("Array with X.ndim > 2 expected.") if rank <= 0 or not isinstance(rank, int): raise ValueError("Rank is invalid.")
def get_dip(self): """ Compute dip of each surface element and return area-weighted average value (in range ``(0, 90]``). Given that dip values are constrained in the range (0, 90], the simple formula for weighted mean is used. """ areas = self._get_areas() dips = numpy.array([surf.get_dip() for surf in self.surfaces]) return numpy.sum(areas * dips) / numpy.sum(areas)
Compute dip of each surface element and return area-weighted average value (in range ``(0, 90]``). Given that dip values are constrained in the range (0, 90], the simple formula for weighted mean is used.
Below is the the instruction that describes the task: ### Input: Compute dip of each surface element and return area-weighted average value (in range ``(0, 90]``). Given that dip values are constrained in the range (0, 90], the simple formula for weighted mean is used. ### Response: def get_dip(self): """ Compute dip of each surface element and return area-weighted average value (in range ``(0, 90]``). Given that dip values are constrained in the range (0, 90], the simple formula for weighted mean is used. """ areas = self._get_areas() dips = numpy.array([surf.get_dip() for surf in self.surfaces]) return numpy.sum(areas * dips) / numpy.sum(areas)
def listFiles(self, dataset = "", block_name = "", logical_file_name = "", release_version="", pset_hash="", app_name="", output_module_label="", run_num=-1, origin_site_name="", lumi_list="", detail=False, validFileOnly=0, sumOverLumi=0): """ API to list files in DBS. Either non-wildcarded logical_file_name, non-wildcarded dataset or non-wildcarded block_name is required. The combination of a non-wildcarded dataset or block_name with an wildcarded logical_file_name is supported. * For lumi_list the following two json formats are supported: - [a1, a2, a3,] - [[a,b], [c, d],] * lumi_list can be either a list of lumi section numbers as [a1, a2, a3,] or a list of lumi section range as [[a,b], [c, d],]. Thay cannot be mixed. * If lumi_list is provided run only run_num=single-run-number is allowed * When lfn list is present, no run or lumi list is allowed. *There are five dataset access types: VALID, INVALID, PRODUCTION, DEPRECATED and DELETED. * One file status: IS_FILE_VALID: 1 or 0. * When a dataset is INVALID/ DEPRECATED/ DELETED, DBS will consider all the files under it is invalid not matter what value is_file_valid has. In general, when the dataset is in one of INVALID/ DEPRECATED/ DELETED, is_file_valid should all marked as 0, but some old DBS2 data was not. * When Dataset is VALID/PRODUCTION, by default is_file_valid is all 1. But if individual file is invalid, then the file's is_file_valid is set to 0. * DBS use this logical in its APIs that have validFileOnly variable. *There are five dataset access types: VALID, INVALID, PRODUCTION, DEPRECATED and DELETED. * One file status: IS_FILE_VALID: 1 or 0. * When a dataset is INVALID/ DEPRECATED/ DELETED, DBS will consider all the files under it is invalid not matter what value is_file_valid has. In general, when the dataset is in one of INVALID/ DEPRECATED/ DELETED, is_file_valid should all marked as 0, but some old DBS2 data was not. * When Dataset is VALID/PRODUCTION, by default is_file_valid is all 1. But if individual file is invalid, then the file's is_file_valid is set to 0. * DBS use this logical in its APIs that have validFileOnly variable. :param logical_file_name: logical_file_name of the file :type logical_file_name: str :param dataset: dataset :type dataset: str :param block_name: block name :type block_name: str :param release_version: release version :type release_version: str :param pset_hash: parameter set hash :type pset_hash: str :param app_name: Name of the application :type app_name: str :param output_module_label: name of the used output module :type output_module_label: str :param run_num: run , run ranges, and run list. Possible format are: run_num, 'run_min-run_max' or ['run_min-run_max', run1, run2, ...]. :type run_num: int, list, string :param origin_site_name: site where the file was created :type origin_site_name: str :param lumi_list: List containing luminosity sections :type lumi_list: list :param detail: Get detailed information about a file :type detail: bool :param validFileOnly: default=0 return all the files. when =1, only return files with is_file_valid=1 or dataset_access_type=PRODUCTION or VALID :type validFileOnly: int :param sumOverLumi: default=0 event_count is the event_count/file. When sumOverLumi=1 and run_num is specified, the event_count is sum of the event_count/lumi for that run; When sumOverLumi = 1, no other input can be a list, for example no run_num list, lumi list or lfn list. :type sumOverLumi: int :returns: List of dictionaries containing the following keys (logical_file_name). If detail parameter is true, the dictionaries contain the following keys (check_sum, branch_hash_id, adler32, block_id, event_count, file_type, create_by, logical_file_name, creation_date, last_modified_by, dataset, block_name, file_id, file_size, last_modification_date, dataset_id, file_type_id, auto_cross_section, md5, is_file_valid) :rtype: list of dicts """ logical_file_name = logical_file_name.replace("*", "%") release_version = release_version.replace("*", "%") pset_hash = pset_hash.replace("*", "%") app_name = app_name.replace("*", "%") block_name = block_name.replace("*", "%") origin_site_name = origin_site_name.replace("*", "%") dataset = dataset.replace("*", "%") # # run_num=1 caused full table scan and CERN DBS reported some of the queries ran more than 50 hours # We will disbale all the run_num=1 calls in DBS. Run_num=1 will be OK when logical_file_name is given. # YG Jan. 15 2019 # if (run_num != -1 and logical_file_name ==''): for r in parseRunRange(run_num): if isinstance(r, basestring) or isinstance(r, int) or isinstance(r, long): if r == 1 or r == '1': dbsExceptionHandler("dbsException-invalid-input", "Run_num=1 is not a valid input.", self.logger.exception) elif isinstance(r, run_tuple): if r[0] == r[1]: dbsExceptionHandler("dbsException-invalid-input", "DBS run range must be apart at least by 1.", self.logger.exception) elif r[0] <= 1 <= r[1]: dbsExceptionHandler("dbsException-invalid-input", "Run_num=1 is not a valid input.", self.logger.exception) if lumi_list: if run_num ==-1 or not run_num : dbsExceptionHandler("dbsException-invalid-input", "When lumi_list is given, require a single run_num.", self.logger.exception) elif sumOverLumi == 1: dbsExceptionHandler("dbsException-invalid-input", "lumi_list and sumOverLumi=1 cannot be set at the same time becaue nesting of WITH clause within WITH clause not supported yet by Oracle. ", self.logger.exception) else: try: lumi_list = self.dbsUtils2.decodeLumiIntervals(lumi_list) except Exception as de: dbsExceptionHandler("dbsException-invalid-input", "Invalid lumi_list input: "+ str(de), self.logger.exception) else: if not isinstance(run_num, list): if run_num ==1 or run_num == '1': dbsExceptionHandler("dbsException-invalid-input", "files API does not supprt run_num=1 when no lumi.", self.logger.exception) else: if 1 in run_num or '1' in run_num : dbsExceptionHandler("dbsException-invalid-input", "files API does not supprt run_num=1 when no lumi.", self.logger.exception) if int(sumOverLumi) == 1 and (isinstance(run_num, list) or isinstance(logical_file_name, list)): dbsExceptionHandler("dbsException-invalid-input", "When sumOverLumi=1, no lfn list or run_num list allowed becaue nesting of WITH clause within WITH clause not supported yet by Oracle. ", self.logger.exception) detail = detail in (True, 1, "True", "1", 'true') output_module_label = output_module_label.replace("*", "%") try: result = self.dbsFile.listFiles(dataset, block_name, logical_file_name, release_version, pset_hash, app_name, output_module_label, run_num, origin_site_name, lumi_list, detail, validFileOnly, sumOverLumi) for item in result: yield item except HTTPError as he: raise he except dbsException as de: dbsExceptionHandler(de.eCode, de.message, self.logger.exception, de.serverError) except Exception as ex: sError = "DBSReaderModel/listFiles. %s \n Exception trace: \n %s" % (ex, traceback.format_exc()) dbsExceptionHandler('dbsException-server-error', ex.message, self.logger.exception, sError)
API to list files in DBS. Either non-wildcarded logical_file_name, non-wildcarded dataset or non-wildcarded block_name is required. The combination of a non-wildcarded dataset or block_name with an wildcarded logical_file_name is supported. * For lumi_list the following two json formats are supported: - [a1, a2, a3,] - [[a,b], [c, d],] * lumi_list can be either a list of lumi section numbers as [a1, a2, a3,] or a list of lumi section range as [[a,b], [c, d],]. Thay cannot be mixed. * If lumi_list is provided run only run_num=single-run-number is allowed * When lfn list is present, no run or lumi list is allowed. *There are five dataset access types: VALID, INVALID, PRODUCTION, DEPRECATED and DELETED. * One file status: IS_FILE_VALID: 1 or 0. * When a dataset is INVALID/ DEPRECATED/ DELETED, DBS will consider all the files under it is invalid not matter what value is_file_valid has. In general, when the dataset is in one of INVALID/ DEPRECATED/ DELETED, is_file_valid should all marked as 0, but some old DBS2 data was not. * When Dataset is VALID/PRODUCTION, by default is_file_valid is all 1. But if individual file is invalid, then the file's is_file_valid is set to 0. * DBS use this logical in its APIs that have validFileOnly variable. *There are five dataset access types: VALID, INVALID, PRODUCTION, DEPRECATED and DELETED. * One file status: IS_FILE_VALID: 1 or 0. * When a dataset is INVALID/ DEPRECATED/ DELETED, DBS will consider all the files under it is invalid not matter what value is_file_valid has. In general, when the dataset is in one of INVALID/ DEPRECATED/ DELETED, is_file_valid should all marked as 0, but some old DBS2 data was not. * When Dataset is VALID/PRODUCTION, by default is_file_valid is all 1. But if individual file is invalid, then the file's is_file_valid is set to 0. * DBS use this logical in its APIs that have validFileOnly variable. :param logical_file_name: logical_file_name of the file :type logical_file_name: str :param dataset: dataset :type dataset: str :param block_name: block name :type block_name: str :param release_version: release version :type release_version: str :param pset_hash: parameter set hash :type pset_hash: str :param app_name: Name of the application :type app_name: str :param output_module_label: name of the used output module :type output_module_label: str :param run_num: run , run ranges, and run list. Possible format are: run_num, 'run_min-run_max' or ['run_min-run_max', run1, run2, ...]. :type run_num: int, list, string :param origin_site_name: site where the file was created :type origin_site_name: str :param lumi_list: List containing luminosity sections :type lumi_list: list :param detail: Get detailed information about a file :type detail: bool :param validFileOnly: default=0 return all the files. when =1, only return files with is_file_valid=1 or dataset_access_type=PRODUCTION or VALID :type validFileOnly: int :param sumOverLumi: default=0 event_count is the event_count/file. When sumOverLumi=1 and run_num is specified, the event_count is sum of the event_count/lumi for that run; When sumOverLumi = 1, no other input can be a list, for example no run_num list, lumi list or lfn list. :type sumOverLumi: int :returns: List of dictionaries containing the following keys (logical_file_name). If detail parameter is true, the dictionaries contain the following keys (check_sum, branch_hash_id, adler32, block_id, event_count, file_type, create_by, logical_file_name, creation_date, last_modified_by, dataset, block_name, file_id, file_size, last_modification_date, dataset_id, file_type_id, auto_cross_section, md5, is_file_valid) :rtype: list of dicts
Below is the the instruction that describes the task: ### Input: API to list files in DBS. Either non-wildcarded logical_file_name, non-wildcarded dataset or non-wildcarded block_name is required. The combination of a non-wildcarded dataset or block_name with an wildcarded logical_file_name is supported. * For lumi_list the following two json formats are supported: - [a1, a2, a3,] - [[a,b], [c, d],] * lumi_list can be either a list of lumi section numbers as [a1, a2, a3,] or a list of lumi section range as [[a,b], [c, d],]. Thay cannot be mixed. * If lumi_list is provided run only run_num=single-run-number is allowed * When lfn list is present, no run or lumi list is allowed. *There are five dataset access types: VALID, INVALID, PRODUCTION, DEPRECATED and DELETED. * One file status: IS_FILE_VALID: 1 or 0. * When a dataset is INVALID/ DEPRECATED/ DELETED, DBS will consider all the files under it is invalid not matter what value is_file_valid has. In general, when the dataset is in one of INVALID/ DEPRECATED/ DELETED, is_file_valid should all marked as 0, but some old DBS2 data was not. * When Dataset is VALID/PRODUCTION, by default is_file_valid is all 1. But if individual file is invalid, then the file's is_file_valid is set to 0. * DBS use this logical in its APIs that have validFileOnly variable. *There are five dataset access types: VALID, INVALID, PRODUCTION, DEPRECATED and DELETED. * One file status: IS_FILE_VALID: 1 or 0. * When a dataset is INVALID/ DEPRECATED/ DELETED, DBS will consider all the files under it is invalid not matter what value is_file_valid has. In general, when the dataset is in one of INVALID/ DEPRECATED/ DELETED, is_file_valid should all marked as 0, but some old DBS2 data was not. * When Dataset is VALID/PRODUCTION, by default is_file_valid is all 1. But if individual file is invalid, then the file's is_file_valid is set to 0. * DBS use this logical in its APIs that have validFileOnly variable. :param logical_file_name: logical_file_name of the file :type logical_file_name: str :param dataset: dataset :type dataset: str :param block_name: block name :type block_name: str :param release_version: release version :type release_version: str :param pset_hash: parameter set hash :type pset_hash: str :param app_name: Name of the application :type app_name: str :param output_module_label: name of the used output module :type output_module_label: str :param run_num: run , run ranges, and run list. Possible format are: run_num, 'run_min-run_max' or ['run_min-run_max', run1, run2, ...]. :type run_num: int, list, string :param origin_site_name: site where the file was created :type origin_site_name: str :param lumi_list: List containing luminosity sections :type lumi_list: list :param detail: Get detailed information about a file :type detail: bool :param validFileOnly: default=0 return all the files. when =1, only return files with is_file_valid=1 or dataset_access_type=PRODUCTION or VALID :type validFileOnly: int :param sumOverLumi: default=0 event_count is the event_count/file. When sumOverLumi=1 and run_num is specified, the event_count is sum of the event_count/lumi for that run; When sumOverLumi = 1, no other input can be a list, for example no run_num list, lumi list or lfn list. :type sumOverLumi: int :returns: List of dictionaries containing the following keys (logical_file_name). If detail parameter is true, the dictionaries contain the following keys (check_sum, branch_hash_id, adler32, block_id, event_count, file_type, create_by, logical_file_name, creation_date, last_modified_by, dataset, block_name, file_id, file_size, last_modification_date, dataset_id, file_type_id, auto_cross_section, md5, is_file_valid) :rtype: list of dicts ### Response: def listFiles(self, dataset = "", block_name = "", logical_file_name = "", release_version="", pset_hash="", app_name="", output_module_label="", run_num=-1, origin_site_name="", lumi_list="", detail=False, validFileOnly=0, sumOverLumi=0): """ API to list files in DBS. Either non-wildcarded logical_file_name, non-wildcarded dataset or non-wildcarded block_name is required. The combination of a non-wildcarded dataset or block_name with an wildcarded logical_file_name is supported. * For lumi_list the following two json formats are supported: - [a1, a2, a3,] - [[a,b], [c, d],] * lumi_list can be either a list of lumi section numbers as [a1, a2, a3,] or a list of lumi section range as [[a,b], [c, d],]. Thay cannot be mixed. * If lumi_list is provided run only run_num=single-run-number is allowed * When lfn list is present, no run or lumi list is allowed. *There are five dataset access types: VALID, INVALID, PRODUCTION, DEPRECATED and DELETED. * One file status: IS_FILE_VALID: 1 or 0. * When a dataset is INVALID/ DEPRECATED/ DELETED, DBS will consider all the files under it is invalid not matter what value is_file_valid has. In general, when the dataset is in one of INVALID/ DEPRECATED/ DELETED, is_file_valid should all marked as 0, but some old DBS2 data was not. * When Dataset is VALID/PRODUCTION, by default is_file_valid is all 1. But if individual file is invalid, then the file's is_file_valid is set to 0. * DBS use this logical in its APIs that have validFileOnly variable. *There are five dataset access types: VALID, INVALID, PRODUCTION, DEPRECATED and DELETED. * One file status: IS_FILE_VALID: 1 or 0. * When a dataset is INVALID/ DEPRECATED/ DELETED, DBS will consider all the files under it is invalid not matter what value is_file_valid has. In general, when the dataset is in one of INVALID/ DEPRECATED/ DELETED, is_file_valid should all marked as 0, but some old DBS2 data was not. * When Dataset is VALID/PRODUCTION, by default is_file_valid is all 1. But if individual file is invalid, then the file's is_file_valid is set to 0. * DBS use this logical in its APIs that have validFileOnly variable. :param logical_file_name: logical_file_name of the file :type logical_file_name: str :param dataset: dataset :type dataset: str :param block_name: block name :type block_name: str :param release_version: release version :type release_version: str :param pset_hash: parameter set hash :type pset_hash: str :param app_name: Name of the application :type app_name: str :param output_module_label: name of the used output module :type output_module_label: str :param run_num: run , run ranges, and run list. Possible format are: run_num, 'run_min-run_max' or ['run_min-run_max', run1, run2, ...]. :type run_num: int, list, string :param origin_site_name: site where the file was created :type origin_site_name: str :param lumi_list: List containing luminosity sections :type lumi_list: list :param detail: Get detailed information about a file :type detail: bool :param validFileOnly: default=0 return all the files. when =1, only return files with is_file_valid=1 or dataset_access_type=PRODUCTION or VALID :type validFileOnly: int :param sumOverLumi: default=0 event_count is the event_count/file. When sumOverLumi=1 and run_num is specified, the event_count is sum of the event_count/lumi for that run; When sumOverLumi = 1, no other input can be a list, for example no run_num list, lumi list or lfn list. :type sumOverLumi: int :returns: List of dictionaries containing the following keys (logical_file_name). If detail parameter is true, the dictionaries contain the following keys (check_sum, branch_hash_id, adler32, block_id, event_count, file_type, create_by, logical_file_name, creation_date, last_modified_by, dataset, block_name, file_id, file_size, last_modification_date, dataset_id, file_type_id, auto_cross_section, md5, is_file_valid) :rtype: list of dicts """ logical_file_name = logical_file_name.replace("*", "%") release_version = release_version.replace("*", "%") pset_hash = pset_hash.replace("*", "%") app_name = app_name.replace("*", "%") block_name = block_name.replace("*", "%") origin_site_name = origin_site_name.replace("*", "%") dataset = dataset.replace("*", "%") # # run_num=1 caused full table scan and CERN DBS reported some of the queries ran more than 50 hours # We will disbale all the run_num=1 calls in DBS. Run_num=1 will be OK when logical_file_name is given. # YG Jan. 15 2019 # if (run_num != -1 and logical_file_name ==''): for r in parseRunRange(run_num): if isinstance(r, basestring) or isinstance(r, int) or isinstance(r, long): if r == 1 or r == '1': dbsExceptionHandler("dbsException-invalid-input", "Run_num=1 is not a valid input.", self.logger.exception) elif isinstance(r, run_tuple): if r[0] == r[1]: dbsExceptionHandler("dbsException-invalid-input", "DBS run range must be apart at least by 1.", self.logger.exception) elif r[0] <= 1 <= r[1]: dbsExceptionHandler("dbsException-invalid-input", "Run_num=1 is not a valid input.", self.logger.exception) if lumi_list: if run_num ==-1 or not run_num : dbsExceptionHandler("dbsException-invalid-input", "When lumi_list is given, require a single run_num.", self.logger.exception) elif sumOverLumi == 1: dbsExceptionHandler("dbsException-invalid-input", "lumi_list and sumOverLumi=1 cannot be set at the same time becaue nesting of WITH clause within WITH clause not supported yet by Oracle. ", self.logger.exception) else: try: lumi_list = self.dbsUtils2.decodeLumiIntervals(lumi_list) except Exception as de: dbsExceptionHandler("dbsException-invalid-input", "Invalid lumi_list input: "+ str(de), self.logger.exception) else: if not isinstance(run_num, list): if run_num ==1 or run_num == '1': dbsExceptionHandler("dbsException-invalid-input", "files API does not supprt run_num=1 when no lumi.", self.logger.exception) else: if 1 in run_num or '1' in run_num : dbsExceptionHandler("dbsException-invalid-input", "files API does not supprt run_num=1 when no lumi.", self.logger.exception) if int(sumOverLumi) == 1 and (isinstance(run_num, list) or isinstance(logical_file_name, list)): dbsExceptionHandler("dbsException-invalid-input", "When sumOverLumi=1, no lfn list or run_num list allowed becaue nesting of WITH clause within WITH clause not supported yet by Oracle. ", self.logger.exception) detail = detail in (True, 1, "True", "1", 'true') output_module_label = output_module_label.replace("*", "%") try: result = self.dbsFile.listFiles(dataset, block_name, logical_file_name, release_version, pset_hash, app_name, output_module_label, run_num, origin_site_name, lumi_list, detail, validFileOnly, sumOverLumi) for item in result: yield item except HTTPError as he: raise he except dbsException as de: dbsExceptionHandler(de.eCode, de.message, self.logger.exception, de.serverError) except Exception as ex: sError = "DBSReaderModel/listFiles. %s \n Exception trace: \n %s" % (ex, traceback.format_exc()) dbsExceptionHandler('dbsException-server-error', ex.message, self.logger.exception, sError)
def _rebuild_entries(self): """ Recreates the entries master list based on the groups hierarchy (order matters here, since the parser uses order to determine lineage). """ self.entries = [] def collapse_entries(group): for entry in group.entries: self.entries.append(entry) for subgroup in group.children: collapse_entries(subgroup) collapse_entries(self.root)
Recreates the entries master list based on the groups hierarchy (order matters here, since the parser uses order to determine lineage).
Below is the the instruction that describes the task: ### Input: Recreates the entries master list based on the groups hierarchy (order matters here, since the parser uses order to determine lineage). ### Response: def _rebuild_entries(self): """ Recreates the entries master list based on the groups hierarchy (order matters here, since the parser uses order to determine lineage). """ self.entries = [] def collapse_entries(group): for entry in group.entries: self.entries.append(entry) for subgroup in group.children: collapse_entries(subgroup) collapse_entries(self.root)
def getDescriptor(self, desc_type, desc_index, length, endpoint = -1): r"""Retrieves a descriptor from the device identified by the type and index of the descriptor. Arguments: desc_type: descriptor type. desc_index: index of the descriptor. len: descriptor length. endpoint: ignored. """ return control.get_descriptor(self.dev, length, desc_type, desc_index)
r"""Retrieves a descriptor from the device identified by the type and index of the descriptor. Arguments: desc_type: descriptor type. desc_index: index of the descriptor. len: descriptor length. endpoint: ignored.
Below is the the instruction that describes the task: ### Input: r"""Retrieves a descriptor from the device identified by the type and index of the descriptor. Arguments: desc_type: descriptor type. desc_index: index of the descriptor. len: descriptor length. endpoint: ignored. ### Response: def getDescriptor(self, desc_type, desc_index, length, endpoint = -1): r"""Retrieves a descriptor from the device identified by the type and index of the descriptor. Arguments: desc_type: descriptor type. desc_index: index of the descriptor. len: descriptor length. endpoint: ignored. """ return control.get_descriptor(self.dev, length, desc_type, desc_index)
def geo_shape(self, sides=5, center=None, distance=None): """ Return a WKT string for a POLYGON with given amount of sides. The polygon is defined by its center (random point if not provided) and the distance (random distance if not provided; in km) of the points to its center. """ assert isinstance(sides, int) if distance is None: distance = self.random_int(100, 1000) else: # 6371 => earth radius in km # assert that shape radius is maximum half of earth's circumference assert isinstance(distance, int) assert distance <= EARTH_RADIUS * math.pi, \ 'distance must not be greater than half of earth\'s circumference' if center is None: # required minimal spherical distance from north/southpole dp = distance * 180.0 / EARTH_RADIUS / math.pi center = self.geo_point(lat_min=-90.0 + dp, lat_max=90.0 - dp) else: assert -180.0 <= center[0] <= 180.0, 'Longitude out of bounds' assert -90.0 <= center[1] <= 90.0, 'Latitude out of bounds' angles = list(self.random_sample(range(360), sides)) angles.sort() points = [_dest_point(center, distance, bearing, EARTH_RADIUS) for bearing in angles] # close polygon points.append(points[0]) path = ', '.join([' '.join(p) for p in ([str(lon), str(lat)] for lon, lat in points)]) return f'POLYGON (( {path} ))'
Return a WKT string for a POLYGON with given amount of sides. The polygon is defined by its center (random point if not provided) and the distance (random distance if not provided; in km) of the points to its center.
Below is the the instruction that describes the task: ### Input: Return a WKT string for a POLYGON with given amount of sides. The polygon is defined by its center (random point if not provided) and the distance (random distance if not provided; in km) of the points to its center. ### Response: def geo_shape(self, sides=5, center=None, distance=None): """ Return a WKT string for a POLYGON with given amount of sides. The polygon is defined by its center (random point if not provided) and the distance (random distance if not provided; in km) of the points to its center. """ assert isinstance(sides, int) if distance is None: distance = self.random_int(100, 1000) else: # 6371 => earth radius in km # assert that shape radius is maximum half of earth's circumference assert isinstance(distance, int) assert distance <= EARTH_RADIUS * math.pi, \ 'distance must not be greater than half of earth\'s circumference' if center is None: # required minimal spherical distance from north/southpole dp = distance * 180.0 / EARTH_RADIUS / math.pi center = self.geo_point(lat_min=-90.0 + dp, lat_max=90.0 - dp) else: assert -180.0 <= center[0] <= 180.0, 'Longitude out of bounds' assert -90.0 <= center[1] <= 90.0, 'Latitude out of bounds' angles = list(self.random_sample(range(360), sides)) angles.sort() points = [_dest_point(center, distance, bearing, EARTH_RADIUS) for bearing in angles] # close polygon points.append(points[0]) path = ', '.join([' '.join(p) for p in ([str(lon), str(lat)] for lon, lat in points)]) return f'POLYGON (( {path} ))'
def share(self, accounts): """ Create a share """ if not isinstance(accounts, (list, tuple)): msg = "Video.share expects an iterable argument" raise exceptions.PyBrightcoveError(msg) raise exceptions.PyBrightcoveError("Not yet implemented")
Create a share
Below is the the instruction that describes the task: ### Input: Create a share ### Response: def share(self, accounts): """ Create a share """ if not isinstance(accounts, (list, tuple)): msg = "Video.share expects an iterable argument" raise exceptions.PyBrightcoveError(msg) raise exceptions.PyBrightcoveError("Not yet implemented")
def poly2poly(line): """ Parse a string of text containing a DS9 description of a polygon. This function works but is not very robust due to the constraints of healpy. Parameters ---------- line : str A string containing a DS9 region command for a polygon. Returns ------- poly : [ra, dec, ...] The coordinates of the polygon. """ words = re.split('[(\s,)]', line) ras = np.array(words[1::2]) decs = np.array(words[2::2]) coords = [] for ra, dec in zip(ras, decs): if ra.strip() == '' or dec.strip() == '': continue if ":" in ra: pos = SkyCoord(Angle(ra, unit=u.hour), Angle(dec, unit=u.degree)) else: pos = SkyCoord(Angle(ra, unit=u.degree), Angle(dec, unit=u.degree)) # only add this point if it is some distance from the previous one coords.extend([pos.ra.degree, pos.dec.degree]) return coords
Parse a string of text containing a DS9 description of a polygon. This function works but is not very robust due to the constraints of healpy. Parameters ---------- line : str A string containing a DS9 region command for a polygon. Returns ------- poly : [ra, dec, ...] The coordinates of the polygon.
Below is the the instruction that describes the task: ### Input: Parse a string of text containing a DS9 description of a polygon. This function works but is not very robust due to the constraints of healpy. Parameters ---------- line : str A string containing a DS9 region command for a polygon. Returns ------- poly : [ra, dec, ...] The coordinates of the polygon. ### Response: def poly2poly(line): """ Parse a string of text containing a DS9 description of a polygon. This function works but is not very robust due to the constraints of healpy. Parameters ---------- line : str A string containing a DS9 region command for a polygon. Returns ------- poly : [ra, dec, ...] The coordinates of the polygon. """ words = re.split('[(\s,)]', line) ras = np.array(words[1::2]) decs = np.array(words[2::2]) coords = [] for ra, dec in zip(ras, decs): if ra.strip() == '' or dec.strip() == '': continue if ":" in ra: pos = SkyCoord(Angle(ra, unit=u.hour), Angle(dec, unit=u.degree)) else: pos = SkyCoord(Angle(ra, unit=u.degree), Angle(dec, unit=u.degree)) # only add this point if it is some distance from the previous one coords.extend([pos.ra.degree, pos.dec.degree]) return coords