code
stringlengths
75
104k
docstring
stringlengths
1
46.9k
text
stringlengths
164
112k
def create_network(batch_size, update_freq): """Create a linear regression network for performing SVRG optimization. Parameters ---------- batch_size: int Size of data split update_freq: int Update Frequency for calculating full gradients Returns ---------- di: mx.io.NDArrayIter Data iterator update_freq: SVRGModule An instance of SVRGModule for performing SVRG optimization """ import logging head = '%(asctime)-15s %(message)s' logging.basicConfig(level=logging.INFO, format=head) train_data = np.random.randint(1, 5, [1000, 2]) weights = np.array([1.0, 2.0]) train_label = train_data.dot(weights) di = mx.io.NDArrayIter(train_data, train_label, batch_size=batch_size, shuffle=True, label_name='lin_reg_label') X = mx.sym.Variable('data') Y = mx.symbol.Variable('lin_reg_label') fully_connected_layer = mx.sym.FullyConnected(data=X, name='fc1', num_hidden=1) lro = mx.sym.LinearRegressionOutput(data=fully_connected_layer, label=Y, name="lro") mod = SVRGModule( symbol=lro, data_names=['data'], label_names=['lin_reg_label'], update_freq=update_freq, logger=logging ) return di, mod
Create a linear regression network for performing SVRG optimization. Parameters ---------- batch_size: int Size of data split update_freq: int Update Frequency for calculating full gradients Returns ---------- di: mx.io.NDArrayIter Data iterator update_freq: SVRGModule An instance of SVRGModule for performing SVRG optimization
Below is the the instruction that describes the task: ### Input: Create a linear regression network for performing SVRG optimization. Parameters ---------- batch_size: int Size of data split update_freq: int Update Frequency for calculating full gradients Returns ---------- di: mx.io.NDArrayIter Data iterator update_freq: SVRGModule An instance of SVRGModule for performing SVRG optimization ### Response: def create_network(batch_size, update_freq): """Create a linear regression network for performing SVRG optimization. Parameters ---------- batch_size: int Size of data split update_freq: int Update Frequency for calculating full gradients Returns ---------- di: mx.io.NDArrayIter Data iterator update_freq: SVRGModule An instance of SVRGModule for performing SVRG optimization """ import logging head = '%(asctime)-15s %(message)s' logging.basicConfig(level=logging.INFO, format=head) train_data = np.random.randint(1, 5, [1000, 2]) weights = np.array([1.0, 2.0]) train_label = train_data.dot(weights) di = mx.io.NDArrayIter(train_data, train_label, batch_size=batch_size, shuffle=True, label_name='lin_reg_label') X = mx.sym.Variable('data') Y = mx.symbol.Variable('lin_reg_label') fully_connected_layer = mx.sym.FullyConnected(data=X, name='fc1', num_hidden=1) lro = mx.sym.LinearRegressionOutput(data=fully_connected_layer, label=Y, name="lro") mod = SVRGModule( symbol=lro, data_names=['data'], label_names=['lin_reg_label'], update_freq=update_freq, logger=logging ) return di, mod
def _rotated_files(path): """Generator. Yields the next rotated file as a tuple: (path, rotation_id) """ for globbed_path in iglob(path + FILE_NAME_GLOB): match = re.search(FILE_NAME_REGEX, globbed_path) if match: yield globbed_path, int(match.group('rotation_id'))
Generator. Yields the next rotated file as a tuple: (path, rotation_id)
Below is the the instruction that describes the task: ### Input: Generator. Yields the next rotated file as a tuple: (path, rotation_id) ### Response: def _rotated_files(path): """Generator. Yields the next rotated file as a tuple: (path, rotation_id) """ for globbed_path in iglob(path + FILE_NAME_GLOB): match = re.search(FILE_NAME_REGEX, globbed_path) if match: yield globbed_path, int(match.group('rotation_id'))
def md( self, url, width="original"): """*generate a multimarkdown image link viewable anywhere (no sign-in needed for private photos)* **Key Arguments:** - ``url`` -- the share URL for the flickr image (or just the unique photoid) - ``width`` -- the pixel width of the fully resolved image. Default *original*. [75, 100, 150, 240, 320, 500, 640, 800, 1024, 1600, 2048] **Return:** - ``md`` -- the image reference link in multi-markdown syntax **Usage:** To return the markdown markup for an image at a given Flickr share URL: .. code-block:: python from picaxe import picaxe Flickr = picaxe( log=log, settings=settings ) mdLink = Flickr.md( url="https://www.flickr.com/photos/92344916@N06/30455211086" width=1024 ) """ self.log.info('starting the ``md_image`` method') images, title, desc, photoId = self.get_photo_metadata(url) if len(title) == 0: tag = photoId else: tag = "%(title)s %(photoId)s" % locals() image = images[str(width)] if width == "original": pxWidth = 1024 else: pxWidth = width md = """![%(title)s][%(tag)s] [%(tag)s]: %(image)s title="%(title)s" width=600px """ % locals() self.log.info('completed the ``md_image`` method') return md
*generate a multimarkdown image link viewable anywhere (no sign-in needed for private photos)* **Key Arguments:** - ``url`` -- the share URL for the flickr image (or just the unique photoid) - ``width`` -- the pixel width of the fully resolved image. Default *original*. [75, 100, 150, 240, 320, 500, 640, 800, 1024, 1600, 2048] **Return:** - ``md`` -- the image reference link in multi-markdown syntax **Usage:** To return the markdown markup for an image at a given Flickr share URL: .. code-block:: python from picaxe import picaxe Flickr = picaxe( log=log, settings=settings ) mdLink = Flickr.md( url="https://www.flickr.com/photos/92344916@N06/30455211086" width=1024 )
Below is the the instruction that describes the task: ### Input: *generate a multimarkdown image link viewable anywhere (no sign-in needed for private photos)* **Key Arguments:** - ``url`` -- the share URL for the flickr image (or just the unique photoid) - ``width`` -- the pixel width of the fully resolved image. Default *original*. [75, 100, 150, 240, 320, 500, 640, 800, 1024, 1600, 2048] **Return:** - ``md`` -- the image reference link in multi-markdown syntax **Usage:** To return the markdown markup for an image at a given Flickr share URL: .. code-block:: python from picaxe import picaxe Flickr = picaxe( log=log, settings=settings ) mdLink = Flickr.md( url="https://www.flickr.com/photos/92344916@N06/30455211086" width=1024 ) ### Response: def md( self, url, width="original"): """*generate a multimarkdown image link viewable anywhere (no sign-in needed for private photos)* **Key Arguments:** - ``url`` -- the share URL for the flickr image (or just the unique photoid) - ``width`` -- the pixel width of the fully resolved image. Default *original*. [75, 100, 150, 240, 320, 500, 640, 800, 1024, 1600, 2048] **Return:** - ``md`` -- the image reference link in multi-markdown syntax **Usage:** To return the markdown markup for an image at a given Flickr share URL: .. code-block:: python from picaxe import picaxe Flickr = picaxe( log=log, settings=settings ) mdLink = Flickr.md( url="https://www.flickr.com/photos/92344916@N06/30455211086" width=1024 ) """ self.log.info('starting the ``md_image`` method') images, title, desc, photoId = self.get_photo_metadata(url) if len(title) == 0: tag = photoId else: tag = "%(title)s %(photoId)s" % locals() image = images[str(width)] if width == "original": pxWidth = 1024 else: pxWidth = width md = """![%(title)s][%(tag)s] [%(tag)s]: %(image)s title="%(title)s" width=600px """ % locals() self.log.info('completed the ``md_image`` method') return md
def get_reversed_statuses(context): """Return a mapping of exit codes to status strings. Args: context (scriptworker.context.Context): the scriptworker context Returns: dict: the mapping of exit codes to status strings. """ _rev = {v: k for k, v in STATUSES.items()} _rev.update(dict(context.config['reversed_statuses'])) return _rev
Return a mapping of exit codes to status strings. Args: context (scriptworker.context.Context): the scriptworker context Returns: dict: the mapping of exit codes to status strings.
Below is the the instruction that describes the task: ### Input: Return a mapping of exit codes to status strings. Args: context (scriptworker.context.Context): the scriptworker context Returns: dict: the mapping of exit codes to status strings. ### Response: def get_reversed_statuses(context): """Return a mapping of exit codes to status strings. Args: context (scriptworker.context.Context): the scriptworker context Returns: dict: the mapping of exit codes to status strings. """ _rev = {v: k for k, v in STATUSES.items()} _rev.update(dict(context.config['reversed_statuses'])) return _rev
def robot_wireless(max_iters=100, kernel=None, optimize=True, plot=True): """Predict the location of a robot given wirelss signal strength readings.""" try:import pods except ImportError: print('pods unavailable, see https://github.com/sods/ods for example datasets') return data = pods.datasets.robot_wireless() # create simple GP Model m = GPy.models.GPRegression(data['Y'], data['X'], kernel=kernel) # optimize if optimize: m.optimize(max_iters=max_iters) Xpredict = m.predict(data['Ytest'])[0] if plot: pb.plot(data['Xtest'][:, 0], data['Xtest'][:, 1], 'r-') pb.plot(Xpredict[:, 0], Xpredict[:, 1], 'b-') pb.axis('equal') pb.title('WiFi Localization with Gaussian Processes') pb.legend(('True Location', 'Predicted Location')) sse = ((data['Xtest'] - Xpredict)**2).sum() print(('Sum of squares error on test data: ' + str(sse))) return m
Predict the location of a robot given wirelss signal strength readings.
Below is the the instruction that describes the task: ### Input: Predict the location of a robot given wirelss signal strength readings. ### Response: def robot_wireless(max_iters=100, kernel=None, optimize=True, plot=True): """Predict the location of a robot given wirelss signal strength readings.""" try:import pods except ImportError: print('pods unavailable, see https://github.com/sods/ods for example datasets') return data = pods.datasets.robot_wireless() # create simple GP Model m = GPy.models.GPRegression(data['Y'], data['X'], kernel=kernel) # optimize if optimize: m.optimize(max_iters=max_iters) Xpredict = m.predict(data['Ytest'])[0] if plot: pb.plot(data['Xtest'][:, 0], data['Xtest'][:, 1], 'r-') pb.plot(Xpredict[:, 0], Xpredict[:, 1], 'b-') pb.axis('equal') pb.title('WiFi Localization with Gaussian Processes') pb.legend(('True Location', 'Predicted Location')) sse = ((data['Xtest'] - Xpredict)**2).sum() print(('Sum of squares error on test data: ' + str(sse))) return m
def fix_simple_errors(self): ''' This attempts to fix the easy errors raised by ValidationError. This includes removing items from the cart that are no longer available, recalculating all of the discounts, and removing voucher codes that are no longer available. ''' # Fix vouchers first (this affects available discounts) to_remove = [] for voucher in self.cart.vouchers.all(): try: self._test_voucher(voucher) except ValidationError: to_remove.append(voucher) for voucher in to_remove: self.cart.vouchers.remove(voucher) # Fix products and discounts items = commerce.ProductItem.objects.filter(cart=self.cart) items = items.select_related("product") products = set(i.product for i in items) available = set(ProductController.available_products( self.cart.user, products=products, )) not_available = products - available zeros = [(product, 0) for product in not_available] self.set_quantities(zeros)
This attempts to fix the easy errors raised by ValidationError. This includes removing items from the cart that are no longer available, recalculating all of the discounts, and removing voucher codes that are no longer available.
Below is the the instruction that describes the task: ### Input: This attempts to fix the easy errors raised by ValidationError. This includes removing items from the cart that are no longer available, recalculating all of the discounts, and removing voucher codes that are no longer available. ### Response: def fix_simple_errors(self): ''' This attempts to fix the easy errors raised by ValidationError. This includes removing items from the cart that are no longer available, recalculating all of the discounts, and removing voucher codes that are no longer available. ''' # Fix vouchers first (this affects available discounts) to_remove = [] for voucher in self.cart.vouchers.all(): try: self._test_voucher(voucher) except ValidationError: to_remove.append(voucher) for voucher in to_remove: self.cart.vouchers.remove(voucher) # Fix products and discounts items = commerce.ProductItem.objects.filter(cart=self.cart) items = items.select_related("product") products = set(i.product for i in items) available = set(ProductController.available_products( self.cart.user, products=products, )) not_available = products - available zeros = [(product, 0) for product in not_available] self.set_quantities(zeros)
def audioread(filename): """Reads an audio signal from file. Supported formats : wav :param filename: filename of the audiofile to load :type filename: str :returns: int, numpy.ndarray -- samplerate, array containing the audio signal """ try: if '.wav' in filename.lower(): fs, signal = wv.read(filename) elif '.call' in filename.lower(): with open(filename, 'rb') as f: signal = np.fromfile(f, dtype=np.int16) fs = 333333 else: raise IOError("Unsupported audio format for file: {}".format(filename)) except: print u"Problem reading wav file" raise signal = signal.astype(float) return fs, signal
Reads an audio signal from file. Supported formats : wav :param filename: filename of the audiofile to load :type filename: str :returns: int, numpy.ndarray -- samplerate, array containing the audio signal
Below is the the instruction that describes the task: ### Input: Reads an audio signal from file. Supported formats : wav :param filename: filename of the audiofile to load :type filename: str :returns: int, numpy.ndarray -- samplerate, array containing the audio signal ### Response: def audioread(filename): """Reads an audio signal from file. Supported formats : wav :param filename: filename of the audiofile to load :type filename: str :returns: int, numpy.ndarray -- samplerate, array containing the audio signal """ try: if '.wav' in filename.lower(): fs, signal = wv.read(filename) elif '.call' in filename.lower(): with open(filename, 'rb') as f: signal = np.fromfile(f, dtype=np.int16) fs = 333333 else: raise IOError("Unsupported audio format for file: {}".format(filename)) except: print u"Problem reading wav file" raise signal = signal.astype(float) return fs, signal
def sortByNamespacePrefix(urisList, nsList): """ Given an ordered list of namespaces prefixes, order a list of uris based on that. Eg In [7]: ll Out[7]: [rdflib.term.URIRef(u'http://www.w3.org/1999/02/22-rdf-syntax-ns#type'), rdflib.term.URIRef(u'printGenericTreeorg/2000/01/rdf-schema#comment'), rdflib.term.URIRef(u'http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.URIRef(u'http://www.w3.org/2002/07/owl#equivalentClass')] In [8]: sortByNamespacePrefix(ll, [OWL.OWLNS, RDFS]) Out[8]: [rdflib.term.URIRef(u'http://www.w3.org/2002/07/owl#equivalentClass'), rdflib.term.URIRef(u'http://www.w3.org/2000/01/rdf-schema#comment'), rdflib.term.URIRef(u'http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.URIRef(u'http://www.w3.org/1999/02/22-rdf-syntax-ns#type')] """ exit = [] urisList = sort_uri_list_by_name(urisList) for ns in nsList: innerexit = [] for uri in urisList: if str(uri).startswith(str(ns)): innerexit += [uri] exit += innerexit # add remaining uris (if any) for uri in urisList: if uri not in exit: exit += [uri] return exit
Given an ordered list of namespaces prefixes, order a list of uris based on that. Eg In [7]: ll Out[7]: [rdflib.term.URIRef(u'http://www.w3.org/1999/02/22-rdf-syntax-ns#type'), rdflib.term.URIRef(u'printGenericTreeorg/2000/01/rdf-schema#comment'), rdflib.term.URIRef(u'http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.URIRef(u'http://www.w3.org/2002/07/owl#equivalentClass')] In [8]: sortByNamespacePrefix(ll, [OWL.OWLNS, RDFS]) Out[8]: [rdflib.term.URIRef(u'http://www.w3.org/2002/07/owl#equivalentClass'), rdflib.term.URIRef(u'http://www.w3.org/2000/01/rdf-schema#comment'), rdflib.term.URIRef(u'http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.URIRef(u'http://www.w3.org/1999/02/22-rdf-syntax-ns#type')]
Below is the the instruction that describes the task: ### Input: Given an ordered list of namespaces prefixes, order a list of uris based on that. Eg In [7]: ll Out[7]: [rdflib.term.URIRef(u'http://www.w3.org/1999/02/22-rdf-syntax-ns#type'), rdflib.term.URIRef(u'printGenericTreeorg/2000/01/rdf-schema#comment'), rdflib.term.URIRef(u'http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.URIRef(u'http://www.w3.org/2002/07/owl#equivalentClass')] In [8]: sortByNamespacePrefix(ll, [OWL.OWLNS, RDFS]) Out[8]: [rdflib.term.URIRef(u'http://www.w3.org/2002/07/owl#equivalentClass'), rdflib.term.URIRef(u'http://www.w3.org/2000/01/rdf-schema#comment'), rdflib.term.URIRef(u'http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.URIRef(u'http://www.w3.org/1999/02/22-rdf-syntax-ns#type')] ### Response: def sortByNamespacePrefix(urisList, nsList): """ Given an ordered list of namespaces prefixes, order a list of uris based on that. Eg In [7]: ll Out[7]: [rdflib.term.URIRef(u'http://www.w3.org/1999/02/22-rdf-syntax-ns#type'), rdflib.term.URIRef(u'printGenericTreeorg/2000/01/rdf-schema#comment'), rdflib.term.URIRef(u'http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.URIRef(u'http://www.w3.org/2002/07/owl#equivalentClass')] In [8]: sortByNamespacePrefix(ll, [OWL.OWLNS, RDFS]) Out[8]: [rdflib.term.URIRef(u'http://www.w3.org/2002/07/owl#equivalentClass'), rdflib.term.URIRef(u'http://www.w3.org/2000/01/rdf-schema#comment'), rdflib.term.URIRef(u'http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.URIRef(u'http://www.w3.org/1999/02/22-rdf-syntax-ns#type')] """ exit = [] urisList = sort_uri_list_by_name(urisList) for ns in nsList: innerexit = [] for uri in urisList: if str(uri).startswith(str(ns)): innerexit += [uri] exit += innerexit # add remaining uris (if any) for uri in urisList: if uri not in exit: exit += [uri] return exit
def adjust_contrast_gamma(arr, gamma): """ Adjust contrast by scaling each pixel value to ``255 * ((I_ij/255)**gamma)``. dtype support:: * ``uint8``: yes; fully tested (1) (2) (3) * ``uint16``: yes; tested (2) (3) * ``uint32``: yes; tested (2) (3) * ``uint64``: yes; tested (2) (3) (4) * ``int8``: limited; tested (2) (3) (5) * ``int16``: limited; tested (2) (3) (5) * ``int32``: limited; tested (2) (3) (5) * ``int64``: limited; tested (2) (3) (4) (5) * ``float16``: limited; tested (5) * ``float32``: limited; tested (5) * ``float64``: limited; tested (5) * ``float128``: no (6) * ``bool``: no (7) - (1) Handled by ``cv2``. Other dtypes are handled by ``skimage``. - (2) Normalization is done as ``I_ij/max``, where ``max`` is the maximum value of the dtype, e.g. 255 for ``uint8``. The normalization is reversed afterwards, e.g. ``result*255`` for ``uint8``. - (3) Integer-like values are not rounded after applying the contrast adjustment equation (before inverting the normalization to 0.0-1.0 space), i.e. projection from continuous space to discrete happens according to floor function. - (4) Note that scikit-image doc says that integers are converted to ``float64`` values before applying the contrast normalization method. This might lead to inaccuracies for large 64bit integer values. Tests showed no indication of that happening though. - (5) Must not contain negative values. Values >=0 are fully supported. - (6) Leads to error in scikit-image. - (7) Does not make sense for contrast adjustments. Parameters ---------- arr : numpy.ndarray Array for which to adjust the contrast. Dtype ``uint8`` is fastest. gamma : number Exponent for the contrast adjustment. Higher values darken the image. Returns ------- numpy.ndarray Array with adjusted contrast. """ # int8 is also possible according to docs # https://docs.opencv.org/3.0-beta/modules/core/doc/operations_on_arrays.html#cv2.LUT , but here it seemed # like `d` was 0 for CV_8S, causing that to fail if arr.dtype.name == "uint8": min_value, _center_value, max_value = iadt.get_value_range_of_dtype(arr.dtype) dynamic_range = max_value - min_value value_range = np.linspace(0, 1.0, num=dynamic_range+1, dtype=np.float32) # 255 * ((I_ij/255)**gamma) # using np.float32(.) here still works when the input is a numpy array of size 1 table = (min_value + (value_range ** np.float32(gamma)) * dynamic_range) arr_aug = cv2.LUT(arr, np.clip(table, min_value, max_value).astype(arr.dtype)) if arr.ndim == 3 and arr_aug.ndim == 2: return arr_aug[..., np.newaxis] return arr_aug else: return ski_exposure.adjust_gamma(arr, gamma)
Adjust contrast by scaling each pixel value to ``255 * ((I_ij/255)**gamma)``. dtype support:: * ``uint8``: yes; fully tested (1) (2) (3) * ``uint16``: yes; tested (2) (3) * ``uint32``: yes; tested (2) (3) * ``uint64``: yes; tested (2) (3) (4) * ``int8``: limited; tested (2) (3) (5) * ``int16``: limited; tested (2) (3) (5) * ``int32``: limited; tested (2) (3) (5) * ``int64``: limited; tested (2) (3) (4) (5) * ``float16``: limited; tested (5) * ``float32``: limited; tested (5) * ``float64``: limited; tested (5) * ``float128``: no (6) * ``bool``: no (7) - (1) Handled by ``cv2``. Other dtypes are handled by ``skimage``. - (2) Normalization is done as ``I_ij/max``, where ``max`` is the maximum value of the dtype, e.g. 255 for ``uint8``. The normalization is reversed afterwards, e.g. ``result*255`` for ``uint8``. - (3) Integer-like values are not rounded after applying the contrast adjustment equation (before inverting the normalization to 0.0-1.0 space), i.e. projection from continuous space to discrete happens according to floor function. - (4) Note that scikit-image doc says that integers are converted to ``float64`` values before applying the contrast normalization method. This might lead to inaccuracies for large 64bit integer values. Tests showed no indication of that happening though. - (5) Must not contain negative values. Values >=0 are fully supported. - (6) Leads to error in scikit-image. - (7) Does not make sense for contrast adjustments. Parameters ---------- arr : numpy.ndarray Array for which to adjust the contrast. Dtype ``uint8`` is fastest. gamma : number Exponent for the contrast adjustment. Higher values darken the image. Returns ------- numpy.ndarray Array with adjusted contrast.
Below is the the instruction that describes the task: ### Input: Adjust contrast by scaling each pixel value to ``255 * ((I_ij/255)**gamma)``. dtype support:: * ``uint8``: yes; fully tested (1) (2) (3) * ``uint16``: yes; tested (2) (3) * ``uint32``: yes; tested (2) (3) * ``uint64``: yes; tested (2) (3) (4) * ``int8``: limited; tested (2) (3) (5) * ``int16``: limited; tested (2) (3) (5) * ``int32``: limited; tested (2) (3) (5) * ``int64``: limited; tested (2) (3) (4) (5) * ``float16``: limited; tested (5) * ``float32``: limited; tested (5) * ``float64``: limited; tested (5) * ``float128``: no (6) * ``bool``: no (7) - (1) Handled by ``cv2``. Other dtypes are handled by ``skimage``. - (2) Normalization is done as ``I_ij/max``, where ``max`` is the maximum value of the dtype, e.g. 255 for ``uint8``. The normalization is reversed afterwards, e.g. ``result*255`` for ``uint8``. - (3) Integer-like values are not rounded after applying the contrast adjustment equation (before inverting the normalization to 0.0-1.0 space), i.e. projection from continuous space to discrete happens according to floor function. - (4) Note that scikit-image doc says that integers are converted to ``float64`` values before applying the contrast normalization method. This might lead to inaccuracies for large 64bit integer values. Tests showed no indication of that happening though. - (5) Must not contain negative values. Values >=0 are fully supported. - (6) Leads to error in scikit-image. - (7) Does not make sense for contrast adjustments. Parameters ---------- arr : numpy.ndarray Array for which to adjust the contrast. Dtype ``uint8`` is fastest. gamma : number Exponent for the contrast adjustment. Higher values darken the image. Returns ------- numpy.ndarray Array with adjusted contrast. ### Response: def adjust_contrast_gamma(arr, gamma): """ Adjust contrast by scaling each pixel value to ``255 * ((I_ij/255)**gamma)``. dtype support:: * ``uint8``: yes; fully tested (1) (2) (3) * ``uint16``: yes; tested (2) (3) * ``uint32``: yes; tested (2) (3) * ``uint64``: yes; tested (2) (3) (4) * ``int8``: limited; tested (2) (3) (5) * ``int16``: limited; tested (2) (3) (5) * ``int32``: limited; tested (2) (3) (5) * ``int64``: limited; tested (2) (3) (4) (5) * ``float16``: limited; tested (5) * ``float32``: limited; tested (5) * ``float64``: limited; tested (5) * ``float128``: no (6) * ``bool``: no (7) - (1) Handled by ``cv2``. Other dtypes are handled by ``skimage``. - (2) Normalization is done as ``I_ij/max``, where ``max`` is the maximum value of the dtype, e.g. 255 for ``uint8``. The normalization is reversed afterwards, e.g. ``result*255`` for ``uint8``. - (3) Integer-like values are not rounded after applying the contrast adjustment equation (before inverting the normalization to 0.0-1.0 space), i.e. projection from continuous space to discrete happens according to floor function. - (4) Note that scikit-image doc says that integers are converted to ``float64`` values before applying the contrast normalization method. This might lead to inaccuracies for large 64bit integer values. Tests showed no indication of that happening though. - (5) Must not contain negative values. Values >=0 are fully supported. - (6) Leads to error in scikit-image. - (7) Does not make sense for contrast adjustments. Parameters ---------- arr : numpy.ndarray Array for which to adjust the contrast. Dtype ``uint8`` is fastest. gamma : number Exponent for the contrast adjustment. Higher values darken the image. Returns ------- numpy.ndarray Array with adjusted contrast. """ # int8 is also possible according to docs # https://docs.opencv.org/3.0-beta/modules/core/doc/operations_on_arrays.html#cv2.LUT , but here it seemed # like `d` was 0 for CV_8S, causing that to fail if arr.dtype.name == "uint8": min_value, _center_value, max_value = iadt.get_value_range_of_dtype(arr.dtype) dynamic_range = max_value - min_value value_range = np.linspace(0, 1.0, num=dynamic_range+1, dtype=np.float32) # 255 * ((I_ij/255)**gamma) # using np.float32(.) here still works when the input is a numpy array of size 1 table = (min_value + (value_range ** np.float32(gamma)) * dynamic_range) arr_aug = cv2.LUT(arr, np.clip(table, min_value, max_value).astype(arr.dtype)) if arr.ndim == 3 and arr_aug.ndim == 2: return arr_aug[..., np.newaxis] return arr_aug else: return ski_exposure.adjust_gamma(arr, gamma)
def no_exception(on_exception, logger=None): """ 处理函数抛出异常的装饰器, ATT: on_exception必填 :param on_exception: 遇到异常时函数返回什么内容 """ def decorator(function): def wrapper(*args, **kwargs): try: result = function(*args, **kwargs) except Exception, e: if hasattr(logger, 'exception'): logger.exception(e) else: print traceback.format_exc() result = on_exception return result return wrapper return decorator
处理函数抛出异常的装饰器, ATT: on_exception必填 :param on_exception: 遇到异常时函数返回什么内容
Below is the the instruction that describes the task: ### Input: 处理函数抛出异常的装饰器, ATT: on_exception必填 :param on_exception: 遇到异常时函数返回什么内容 ### Response: def no_exception(on_exception, logger=None): """ 处理函数抛出异常的装饰器, ATT: on_exception必填 :param on_exception: 遇到异常时函数返回什么内容 """ def decorator(function): def wrapper(*args, **kwargs): try: result = function(*args, **kwargs) except Exception, e: if hasattr(logger, 'exception'): logger.exception(e) else: print traceback.format_exc() result = on_exception return result return wrapper return decorator
def signature(self, block_size=None): "Calculates signature for local file." kwargs = {} if block_size: kwargs['block_size'] = block_size return librsync.signature(open(self.path, 'rb'), **kwargs)
Calculates signature for local file.
Below is the the instruction that describes the task: ### Input: Calculates signature for local file. ### Response: def signature(self, block_size=None): "Calculates signature for local file." kwargs = {} if block_size: kwargs['block_size'] = block_size return librsync.signature(open(self.path, 'rb'), **kwargs)
def from_string(locale, strict=True): """ Return an instance ``Locale`` corresponding to the string representation of a locale. @param locale: a string representation of a locale, i.e., a ISO 639-3 alpha-3 code (or alpha-2 code), optionally followed by a dash character ``-`` and a ISO 3166-1 alpha-2 code. @param strict: indicate whether the string representation of a locale has to be strictly compliant with RFC 4646, or whether a Java-style locale (character ``_`` instead of ``-``) is accepted. @return: an instance ``Locale``. """ (language_code, country_code) = Locale.decompose_locale(locale, strict) return Locale(language_code, country_code)
Return an instance ``Locale`` corresponding to the string representation of a locale. @param locale: a string representation of a locale, i.e., a ISO 639-3 alpha-3 code (or alpha-2 code), optionally followed by a dash character ``-`` and a ISO 3166-1 alpha-2 code. @param strict: indicate whether the string representation of a locale has to be strictly compliant with RFC 4646, or whether a Java-style locale (character ``_`` instead of ``-``) is accepted. @return: an instance ``Locale``.
Below is the the instruction that describes the task: ### Input: Return an instance ``Locale`` corresponding to the string representation of a locale. @param locale: a string representation of a locale, i.e., a ISO 639-3 alpha-3 code (or alpha-2 code), optionally followed by a dash character ``-`` and a ISO 3166-1 alpha-2 code. @param strict: indicate whether the string representation of a locale has to be strictly compliant with RFC 4646, or whether a Java-style locale (character ``_`` instead of ``-``) is accepted. @return: an instance ``Locale``. ### Response: def from_string(locale, strict=True): """ Return an instance ``Locale`` corresponding to the string representation of a locale. @param locale: a string representation of a locale, i.e., a ISO 639-3 alpha-3 code (or alpha-2 code), optionally followed by a dash character ``-`` and a ISO 3166-1 alpha-2 code. @param strict: indicate whether the string representation of a locale has to be strictly compliant with RFC 4646, or whether a Java-style locale (character ``_`` instead of ``-``) is accepted. @return: an instance ``Locale``. """ (language_code, country_code) = Locale.decompose_locale(locale, strict) return Locale(language_code, country_code)
def write(self, row, col, data, style=None): """ Write data to row, col of worksheet (ws) using the style information. Again, I'm wrapping this because you'll have to do it if you create large amounts of formatted entries in your spreadsheet (else Excel, but probably not OOo will crash). """ ws = self.ws if not ws: raise Exception('you must use set_sheet() before write()') if style: if isinstance(style, xlwt.Style.XFStyle): s = style else: s = self.get_style(style) ws.write(row, col, data, s) else: ws.write(row, col, data)
Write data to row, col of worksheet (ws) using the style information. Again, I'm wrapping this because you'll have to do it if you create large amounts of formatted entries in your spreadsheet (else Excel, but probably not OOo will crash).
Below is the the instruction that describes the task: ### Input: Write data to row, col of worksheet (ws) using the style information. Again, I'm wrapping this because you'll have to do it if you create large amounts of formatted entries in your spreadsheet (else Excel, but probably not OOo will crash). ### Response: def write(self, row, col, data, style=None): """ Write data to row, col of worksheet (ws) using the style information. Again, I'm wrapping this because you'll have to do it if you create large amounts of formatted entries in your spreadsheet (else Excel, but probably not OOo will crash). """ ws = self.ws if not ws: raise Exception('you must use set_sheet() before write()') if style: if isinstance(style, xlwt.Style.XFStyle): s = style else: s = self.get_style(style) ws.write(row, col, data, s) else: ws.write(row, col, data)
def add_term(self, t): """Add a term to this section and set it's ownership. Should only be used on root level terms""" if t not in self.terms: if t.parent_term_lc == 'root': self.terms.append(t) self.doc.add_term(t, add_section=False) t.set_ownership() else: raise GenerateError("Can only add or move root-level terms. Term '{}' parent is '{}' " .format(t, t.parent_term_lc)) assert t.section or t.join_lc == 'root.root', t
Add a term to this section and set it's ownership. Should only be used on root level terms
Below is the the instruction that describes the task: ### Input: Add a term to this section and set it's ownership. Should only be used on root level terms ### Response: def add_term(self, t): """Add a term to this section and set it's ownership. Should only be used on root level terms""" if t not in self.terms: if t.parent_term_lc == 'root': self.terms.append(t) self.doc.add_term(t, add_section=False) t.set_ownership() else: raise GenerateError("Can only add or move root-level terms. Term '{}' parent is '{}' " .format(t, t.parent_term_lc)) assert t.section or t.join_lc == 'root.root', t
def lock_input_target_config_target_running_running(self, **kwargs): """Auto Generated Code """ config = ET.Element("config") lock = ET.Element("lock") config = lock input = ET.SubElement(lock, "input") target = ET.SubElement(input, "target") config_target = ET.SubElement(target, "config-target") running = ET.SubElement(config_target, "running") running = ET.SubElement(running, "running") 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 lock_input_target_config_target_running_running(self, **kwargs): """Auto Generated Code """ config = ET.Element("config") lock = ET.Element("lock") config = lock input = ET.SubElement(lock, "input") target = ET.SubElement(input, "target") config_target = ET.SubElement(target, "config-target") running = ET.SubElement(config_target, "running") running = ET.SubElement(running, "running") callback = kwargs.pop('callback', self._callback) return callback(config)
def get_probs(self, x): """ :param x: A symbolic representation of the network input. :return: A symbolic representation of the probs """ name = self._get_softmax_name() return self.get_layer(x, name)
:param x: A symbolic representation of the network input. :return: A symbolic representation of the probs
Below is the the instruction that describes the task: ### Input: :param x: A symbolic representation of the network input. :return: A symbolic representation of the probs ### Response: def get_probs(self, x): """ :param x: A symbolic representation of the network input. :return: A symbolic representation of the probs """ name = self._get_softmax_name() return self.get_layer(x, name)
def parse_property(self, tup_tree): """ Parse PROPERTY into a CIMProperty object. VAL is just the pcdata of the enclosed VALUE node. :: <!ELEMENT PROPERTY (QUALIFIER*, VALUE?)> <!ATTLIST PROPERTY %CIMName; %CIMType; #REQUIRED %ClassOrigin; %Propagated; %EmbeddedObject; xml:lang NMTOKEN #IMPLIED> """ self.check_node(tup_tree, 'PROPERTY', ('TYPE', 'NAME'), ('CLASSORIGIN', 'PROPAGATED', 'EmbeddedObject', 'EMBEDDEDOBJECT', 'xml:lang'), ('QUALIFIER', 'VALUE')) # The 'xml:lang' attribute is tolerated but ignored. attrl = attrs(tup_tree) try: val = self.unpack_value(tup_tree) except ValueError as exc: msg = str(exc) raise CIMXMLParseError( _format("Cannot parse content of 'VALUE' child element of " "'PROPERTY' element with name {0!A}: {1}", attrl['NAME'], msg), conn_id=self.conn_id) qualifiers = self.list_of_matching(tup_tree, ('QUALIFIER',)) embedded_object = False if 'EmbeddedObject' in attrl or 'EMBEDDEDOBJECT' in attrl: try: embedded_object = attrl['EmbeddedObject'] except KeyError: embedded_object = attrl['EMBEDDEDOBJECT'] if embedded_object: val = self.parse_embeddedObject(val) return CIMProperty(attrl['NAME'], val, type=attrl['TYPE'], is_array=False, class_origin=attrl.get('CLASSORIGIN', None), propagated=self.unpack_boolean( attrl.get('PROPAGATED', 'false')), qualifiers=qualifiers, embedded_object=embedded_object)
Parse PROPERTY into a CIMProperty object. VAL is just the pcdata of the enclosed VALUE node. :: <!ELEMENT PROPERTY (QUALIFIER*, VALUE?)> <!ATTLIST PROPERTY %CIMName; %CIMType; #REQUIRED %ClassOrigin; %Propagated; %EmbeddedObject; xml:lang NMTOKEN #IMPLIED>
Below is the the instruction that describes the task: ### Input: Parse PROPERTY into a CIMProperty object. VAL is just the pcdata of the enclosed VALUE node. :: <!ELEMENT PROPERTY (QUALIFIER*, VALUE?)> <!ATTLIST PROPERTY %CIMName; %CIMType; #REQUIRED %ClassOrigin; %Propagated; %EmbeddedObject; xml:lang NMTOKEN #IMPLIED> ### Response: def parse_property(self, tup_tree): """ Parse PROPERTY into a CIMProperty object. VAL is just the pcdata of the enclosed VALUE node. :: <!ELEMENT PROPERTY (QUALIFIER*, VALUE?)> <!ATTLIST PROPERTY %CIMName; %CIMType; #REQUIRED %ClassOrigin; %Propagated; %EmbeddedObject; xml:lang NMTOKEN #IMPLIED> """ self.check_node(tup_tree, 'PROPERTY', ('TYPE', 'NAME'), ('CLASSORIGIN', 'PROPAGATED', 'EmbeddedObject', 'EMBEDDEDOBJECT', 'xml:lang'), ('QUALIFIER', 'VALUE')) # The 'xml:lang' attribute is tolerated but ignored. attrl = attrs(tup_tree) try: val = self.unpack_value(tup_tree) except ValueError as exc: msg = str(exc) raise CIMXMLParseError( _format("Cannot parse content of 'VALUE' child element of " "'PROPERTY' element with name {0!A}: {1}", attrl['NAME'], msg), conn_id=self.conn_id) qualifiers = self.list_of_matching(tup_tree, ('QUALIFIER',)) embedded_object = False if 'EmbeddedObject' in attrl or 'EMBEDDEDOBJECT' in attrl: try: embedded_object = attrl['EmbeddedObject'] except KeyError: embedded_object = attrl['EMBEDDEDOBJECT'] if embedded_object: val = self.parse_embeddedObject(val) return CIMProperty(attrl['NAME'], val, type=attrl['TYPE'], is_array=False, class_origin=attrl.get('CLASSORIGIN', None), propagated=self.unpack_boolean( attrl.get('PROPAGATED', 'false')), qualifiers=qualifiers, embedded_object=embedded_object)
def list_users_in_group_category(self, group_category_id, search_term=None, unassigned=None): """ List users in group category. Returns a list of users in the group category. """ path = {} data = {} params = {} # REQUIRED - PATH - group_category_id """ID""" path["group_category_id"] = group_category_id # OPTIONAL - search_term """The partial name or full ID of the users to match and return in the results list. Must be at least 3 characters.""" if search_term is not None: params["search_term"] = search_term # OPTIONAL - unassigned """Set this value to true if you wish only to search unassigned users in the group category.""" if unassigned is not None: params["unassigned"] = unassigned self.logger.debug("GET /api/v1/group_categories/{group_category_id}/users with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("GET", "/api/v1/group_categories/{group_category_id}/users".format(**path), data=data, params=params, all_pages=True)
List users in group category. Returns a list of users in the group category.
Below is the the instruction that describes the task: ### Input: List users in group category. Returns a list of users in the group category. ### Response: def list_users_in_group_category(self, group_category_id, search_term=None, unassigned=None): """ List users in group category. Returns a list of users in the group category. """ path = {} data = {} params = {} # REQUIRED - PATH - group_category_id """ID""" path["group_category_id"] = group_category_id # OPTIONAL - search_term """The partial name or full ID of the users to match and return in the results list. Must be at least 3 characters.""" if search_term is not None: params["search_term"] = search_term # OPTIONAL - unassigned """Set this value to true if you wish only to search unassigned users in the group category.""" if unassigned is not None: params["unassigned"] = unassigned self.logger.debug("GET /api/v1/group_categories/{group_category_id}/users with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("GET", "/api/v1/group_categories/{group_category_id}/users".format(**path), data=data, params=params, all_pages=True)
def mate_bottom(self): " bottom of the stator" return Mate(self, CoordSystem( origin=(0, 0, -self.length/2), xDir=(1, 0, 0), normal=(0, 0, -1) ))
bottom of the stator
Below is the the instruction that describes the task: ### Input: bottom of the stator ### Response: def mate_bottom(self): " bottom of the stator" return Mate(self, CoordSystem( origin=(0, 0, -self.length/2), xDir=(1, 0, 0), normal=(0, 0, -1) ))
def _two_point_interp(times, altitudes, horizon=0*u.deg): """ Do linear interpolation between two ``altitudes`` at two ``times`` to determine the time where the altitude goes through zero. Parameters ---------- times : `~astropy.time.Time` Two times for linear interpolation between altitudes : array of `~astropy.units.Quantity` Two altitudes for linear interpolation between horizon : `~astropy.units.Quantity` Solve for the time when the altitude is equal to reference_alt. Returns ------- t : `~astropy.time.Time` Time when target crosses the horizon """ if not isinstance(times, Time): return MAGIC_TIME else: slope = (altitudes[1] - altitudes[0])/(times[1].jd - times[0].jd) return Time(times[1].jd - ((altitudes[1] - horizon)/slope).value, format='jd')
Do linear interpolation between two ``altitudes`` at two ``times`` to determine the time where the altitude goes through zero. Parameters ---------- times : `~astropy.time.Time` Two times for linear interpolation between altitudes : array of `~astropy.units.Quantity` Two altitudes for linear interpolation between horizon : `~astropy.units.Quantity` Solve for the time when the altitude is equal to reference_alt. Returns ------- t : `~astropy.time.Time` Time when target crosses the horizon
Below is the the instruction that describes the task: ### Input: Do linear interpolation between two ``altitudes`` at two ``times`` to determine the time where the altitude goes through zero. Parameters ---------- times : `~astropy.time.Time` Two times for linear interpolation between altitudes : array of `~astropy.units.Quantity` Two altitudes for linear interpolation between horizon : `~astropy.units.Quantity` Solve for the time when the altitude is equal to reference_alt. Returns ------- t : `~astropy.time.Time` Time when target crosses the horizon ### Response: def _two_point_interp(times, altitudes, horizon=0*u.deg): """ Do linear interpolation between two ``altitudes`` at two ``times`` to determine the time where the altitude goes through zero. Parameters ---------- times : `~astropy.time.Time` Two times for linear interpolation between altitudes : array of `~astropy.units.Quantity` Two altitudes for linear interpolation between horizon : `~astropy.units.Quantity` Solve for the time when the altitude is equal to reference_alt. Returns ------- t : `~astropy.time.Time` Time when target crosses the horizon """ if not isinstance(times, Time): return MAGIC_TIME else: slope = (altitudes[1] - altitudes[0])/(times[1].jd - times[0].jd) return Time(times[1].jd - ((altitudes[1] - horizon)/slope).value, format='jd')
def get_gfe(self, annotation, locus): """ creates GFE from a sequence annotation :param locus: The gene locus :type locus: ``str`` :param annotation: An sequence annotation object :type annotation: ``List`` :rtype: ``List`` Returns: The GFE notation and the associated features in an array """ features = [] accessions = {} for feat in annotation.annotation: if isinstance(annotation.annotation[feat], DBSeq) \ or isinstance(annotation.annotation[feat], Seq): seq = str(annotation.annotation[feat]) else: seq = str(annotation.annotation[feat].seq) # TODO: Drop this if statement if isutr(feat): feat_str = ":".join([locus, str(1), feat, seq]) # If the feature has been loaded or stored # then use that instead of making a feature request if self.verbose and self.verbosity > 2: self.logger.info("Getting accession " + feat_str) if feat_str in self.all_feats[locus]: if self.verbose and self.verbosity > 2: self.logger.info("Feature found " + feat_str) accession = self.all_feats[locus][feat_str] feature = Feature(term=feat, rank=1, locus=locus, sequence=seq, accession=accession) accessions.update({feat: accession}) features.append(feature) else: if self.verbose and self.verbosity > 2: self.logger.info(self.logname + "Making FeatureRequest " + feat_str) # Create FeatureRequest object request = FeatureRequest(locus=locus, term=feat, rank=1, sequence=seq) # Attempt to make feature request try: feature = self.api.create_feature(body=request) accessions.update({feat: feature.accession}) features.append(feature) except ApiException as e: self.logger.error(self.logname + "Exception when calling DefaultApi->create_feature" + e) blank_feat = Feature(term=feat, rank=1, locus=locus, sequence=seq) accessions.update({feat: 0}) features.append(blank_feat) # Store new features for quick retrieval if flag passed if self.store_features: # Adding new feature to all_feats self.all_feats[locus].update({feat_str: feature.accession}) # Calculating memory size of all_feats if self.verbose and self.verbosity > 1: self.logger.info(self.logname + "Storing new feature " + feat_str) mem = "{:4.4f}".format(sys.getsizeof(self.all_feats) / 1000000) self.logger.info(self.logname + "Updated * all_feats " + mem + " MB *") else: term, rank = feat.split("_") feat_str = ":".join([locus, str(rank), term, seq]) # If the feature has been loaded or stored # then use that instead of making a feature request if feat_str in self.all_feats[locus]: if self.verbose and self.verbosity > 2: self.logger.info(self.logname + "Feature found " + feat_str) accession = self.all_feats[locus][feat_str] feature = Feature(term=term, rank=rank, locus=locus, sequence=seq, accession=accession) accessions.update({feat: accession}) features.append(feature) else: if self.verbose and self.verbosity > 2: self.logger.info(self.logname + "Making FeatureRequest " + feat_str) # Create FeatureRequest object request = FeatureRequest(locus=locus, term=term, rank=rank, sequence=seq) # Attempt to make feature request try: feature = self.api.create_feature(body=request) accessions.update({feat: feature.accession}) features.append(feature) except ApiException as e: self.logger.error(self.logname + "Exception when calling DefaultApi->create_feature %e" + e) blank_feat = Feature(term=term, rank=rank, locus=locus, sequence=seq) accessions.update({feat: 0}) features.append(blank_feat) # Store new features for quick retrieval if flag passed if self.store_features: # Adding new feature to all_feats self.all_feats[locus].update({feat_str: feature.accession}) # Calculating memory size of all_feats if self.verbose and self.verbosity > 1: self.logger.info(self.logname + "Storing new feature " + feat_str) mem = "{:4.4f}".format(sys.getsizeof(self.all_feats) / 1000000) self.logger.info(self.logname + "Updated * all_feats " + mem + " MB *") # Creating GFE gfe = self._make_gfe(accessions, locus) if self.verbose: self.logger.info("GFE = " + gfe) return features, gfe
creates GFE from a sequence annotation :param locus: The gene locus :type locus: ``str`` :param annotation: An sequence annotation object :type annotation: ``List`` :rtype: ``List`` Returns: The GFE notation and the associated features in an array
Below is the the instruction that describes the task: ### Input: creates GFE from a sequence annotation :param locus: The gene locus :type locus: ``str`` :param annotation: An sequence annotation object :type annotation: ``List`` :rtype: ``List`` Returns: The GFE notation and the associated features in an array ### Response: def get_gfe(self, annotation, locus): """ creates GFE from a sequence annotation :param locus: The gene locus :type locus: ``str`` :param annotation: An sequence annotation object :type annotation: ``List`` :rtype: ``List`` Returns: The GFE notation and the associated features in an array """ features = [] accessions = {} for feat in annotation.annotation: if isinstance(annotation.annotation[feat], DBSeq) \ or isinstance(annotation.annotation[feat], Seq): seq = str(annotation.annotation[feat]) else: seq = str(annotation.annotation[feat].seq) # TODO: Drop this if statement if isutr(feat): feat_str = ":".join([locus, str(1), feat, seq]) # If the feature has been loaded or stored # then use that instead of making a feature request if self.verbose and self.verbosity > 2: self.logger.info("Getting accession " + feat_str) if feat_str in self.all_feats[locus]: if self.verbose and self.verbosity > 2: self.logger.info("Feature found " + feat_str) accession = self.all_feats[locus][feat_str] feature = Feature(term=feat, rank=1, locus=locus, sequence=seq, accession=accession) accessions.update({feat: accession}) features.append(feature) else: if self.verbose and self.verbosity > 2: self.logger.info(self.logname + "Making FeatureRequest " + feat_str) # Create FeatureRequest object request = FeatureRequest(locus=locus, term=feat, rank=1, sequence=seq) # Attempt to make feature request try: feature = self.api.create_feature(body=request) accessions.update({feat: feature.accession}) features.append(feature) except ApiException as e: self.logger.error(self.logname + "Exception when calling DefaultApi->create_feature" + e) blank_feat = Feature(term=feat, rank=1, locus=locus, sequence=seq) accessions.update({feat: 0}) features.append(blank_feat) # Store new features for quick retrieval if flag passed if self.store_features: # Adding new feature to all_feats self.all_feats[locus].update({feat_str: feature.accession}) # Calculating memory size of all_feats if self.verbose and self.verbosity > 1: self.logger.info(self.logname + "Storing new feature " + feat_str) mem = "{:4.4f}".format(sys.getsizeof(self.all_feats) / 1000000) self.logger.info(self.logname + "Updated * all_feats " + mem + " MB *") else: term, rank = feat.split("_") feat_str = ":".join([locus, str(rank), term, seq]) # If the feature has been loaded or stored # then use that instead of making a feature request if feat_str in self.all_feats[locus]: if self.verbose and self.verbosity > 2: self.logger.info(self.logname + "Feature found " + feat_str) accession = self.all_feats[locus][feat_str] feature = Feature(term=term, rank=rank, locus=locus, sequence=seq, accession=accession) accessions.update({feat: accession}) features.append(feature) else: if self.verbose and self.verbosity > 2: self.logger.info(self.logname + "Making FeatureRequest " + feat_str) # Create FeatureRequest object request = FeatureRequest(locus=locus, term=term, rank=rank, sequence=seq) # Attempt to make feature request try: feature = self.api.create_feature(body=request) accessions.update({feat: feature.accession}) features.append(feature) except ApiException as e: self.logger.error(self.logname + "Exception when calling DefaultApi->create_feature %e" + e) blank_feat = Feature(term=term, rank=rank, locus=locus, sequence=seq) accessions.update({feat: 0}) features.append(blank_feat) # Store new features for quick retrieval if flag passed if self.store_features: # Adding new feature to all_feats self.all_feats[locus].update({feat_str: feature.accession}) # Calculating memory size of all_feats if self.verbose and self.verbosity > 1: self.logger.info(self.logname + "Storing new feature " + feat_str) mem = "{:4.4f}".format(sys.getsizeof(self.all_feats) / 1000000) self.logger.info(self.logname + "Updated * all_feats " + mem + " MB *") # Creating GFE gfe = self._make_gfe(accessions, locus) if self.verbose: self.logger.info("GFE = " + gfe) return features, gfe
def indexes_some(ol,value,*seqs): ''' from elist.elist import * ol = [1,'a',3,'a',4,'a',5] indexes_some(ol,'a',0,2) indexes_some(ol,'a',0,1) indexes_some(ol,'a',1,2) indexes_some(ol,'a',3,4) ''' seqs = list(seqs) length = ol.__len__() indexes =[] seq = -1 for i in range(0,length): if(value == ol[i]): seq = seq + 1 if(seq in seqs): indexes.append(i) else: pass else: pass return(indexes)
from elist.elist import * ol = [1,'a',3,'a',4,'a',5] indexes_some(ol,'a',0,2) indexes_some(ol,'a',0,1) indexes_some(ol,'a',1,2) indexes_some(ol,'a',3,4)
Below is the the instruction that describes the task: ### Input: from elist.elist import * ol = [1,'a',3,'a',4,'a',5] indexes_some(ol,'a',0,2) indexes_some(ol,'a',0,1) indexes_some(ol,'a',1,2) indexes_some(ol,'a',3,4) ### Response: def indexes_some(ol,value,*seqs): ''' from elist.elist import * ol = [1,'a',3,'a',4,'a',5] indexes_some(ol,'a',0,2) indexes_some(ol,'a',0,1) indexes_some(ol,'a',1,2) indexes_some(ol,'a',3,4) ''' seqs = list(seqs) length = ol.__len__() indexes =[] seq = -1 for i in range(0,length): if(value == ol[i]): seq = seq + 1 if(seq in seqs): indexes.append(i) else: pass else: pass return(indexes)
def pending(self): ''' Returns an array of updates that are currently in the buffer for an individual social media profile. ''' pending_updates = [] url = PATHS['GET_PENDING'] % self.profile_id response = self.api.get(url=url) for update in response['updates']: pending_updates.append(Update(api=self.api, raw_response=update)) self.__pending = pending_updates return self.__pending
Returns an array of updates that are currently in the buffer for an individual social media profile.
Below is the the instruction that describes the task: ### Input: Returns an array of updates that are currently in the buffer for an individual social media profile. ### Response: def pending(self): ''' Returns an array of updates that are currently in the buffer for an individual social media profile. ''' pending_updates = [] url = PATHS['GET_PENDING'] % self.profile_id response = self.api.get(url=url) for update in response['updates']: pending_updates.append(Update(api=self.api, raw_response=update)) self.__pending = pending_updates return self.__pending
def make_rpc_call(func_name, args=None, remote=None): """Performs an RPC function call (local or remote) with the given arguments. :param str|unicode func_name: RPC function name to call. :param Iterable args: Function arguments. :param str|unicode remote: :rtype: bytes|str :raises ValueError: If unable to call RPC function. """ args = args or [] args = [encode(str(arg)) for arg in args] if remote: result = uwsgi.rpc(remote, func_name, *args) else: result = uwsgi.call(func_name, *args) return decode(result)
Performs an RPC function call (local or remote) with the given arguments. :param str|unicode func_name: RPC function name to call. :param Iterable args: Function arguments. :param str|unicode remote: :rtype: bytes|str :raises ValueError: If unable to call RPC function.
Below is the the instruction that describes the task: ### Input: Performs an RPC function call (local or remote) with the given arguments. :param str|unicode func_name: RPC function name to call. :param Iterable args: Function arguments. :param str|unicode remote: :rtype: bytes|str :raises ValueError: If unable to call RPC function. ### Response: def make_rpc_call(func_name, args=None, remote=None): """Performs an RPC function call (local or remote) with the given arguments. :param str|unicode func_name: RPC function name to call. :param Iterable args: Function arguments. :param str|unicode remote: :rtype: bytes|str :raises ValueError: If unable to call RPC function. """ args = args or [] args = [encode(str(arg)) for arg in args] if remote: result = uwsgi.rpc(remote, func_name, *args) else: result = uwsgi.call(func_name, *args) return decode(result)
def symm_block_tridiag_matmul(H_diag, H_upper_diag, v): """ Compute matrix-vector product with a symmetric block tridiagonal matrix H and vector v. :param H_diag: block diagonal terms of H :param H_upper_diag: upper block diagonal terms of H :param v: vector to multiple :return: H * v """ T, D, _ = H_diag.shape assert H_diag.ndim == 3 and H_diag.shape[2] == D assert H_upper_diag.shape == (T-1, D, D) assert v.shape == (T, D) out = np.matmul(H_diag, v[:, :, None])[:, :, 0] out[:-1] += np.matmul(H_upper_diag, v[1:][:, :, None])[:, :, 0] out[1:] += np.matmul(np.swapaxes(H_upper_diag, -2, -1), v[:-1][:, :, None])[:, :, 0] return out
Compute matrix-vector product with a symmetric block tridiagonal matrix H and vector v. :param H_diag: block diagonal terms of H :param H_upper_diag: upper block diagonal terms of H :param v: vector to multiple :return: H * v
Below is the the instruction that describes the task: ### Input: Compute matrix-vector product with a symmetric block tridiagonal matrix H and vector v. :param H_diag: block diagonal terms of H :param H_upper_diag: upper block diagonal terms of H :param v: vector to multiple :return: H * v ### Response: def symm_block_tridiag_matmul(H_diag, H_upper_diag, v): """ Compute matrix-vector product with a symmetric block tridiagonal matrix H and vector v. :param H_diag: block diagonal terms of H :param H_upper_diag: upper block diagonal terms of H :param v: vector to multiple :return: H * v """ T, D, _ = H_diag.shape assert H_diag.ndim == 3 and H_diag.shape[2] == D assert H_upper_diag.shape == (T-1, D, D) assert v.shape == (T, D) out = np.matmul(H_diag, v[:, :, None])[:, :, 0] out[:-1] += np.matmul(H_upper_diag, v[1:][:, :, None])[:, :, 0] out[1:] += np.matmul(np.swapaxes(H_upper_diag, -2, -1), v[:-1][:, :, None])[:, :, 0] return out
def create_label(label_tuple, extra_label=None): """Return a label based on my_tuple (a,b) and extra label. a and b are string. The output will be something like: [a - b] extra_label """ if extra_label is not None: return '[' + ' - '.join(label_tuple) + '] ' + str(extra_label) else: return '[' + ' - '.join(label_tuple) + ']'
Return a label based on my_tuple (a,b) and extra label. a and b are string. The output will be something like: [a - b] extra_label
Below is the the instruction that describes the task: ### Input: Return a label based on my_tuple (a,b) and extra label. a and b are string. The output will be something like: [a - b] extra_label ### Response: def create_label(label_tuple, extra_label=None): """Return a label based on my_tuple (a,b) and extra label. a and b are string. The output will be something like: [a - b] extra_label """ if extra_label is not None: return '[' + ' - '.join(label_tuple) + '] ' + str(extra_label) else: return '[' + ' - '.join(label_tuple) + ']'
def _call(self, path, method, body=None, headers=None): """ Wrapper around http.do_call that transforms some HTTPError into our own exceptions """ try: resp = self.http.do_call(path, method, body, headers) except http.HTTPError as err: if err.status == 401: raise PermissionError('Insufficient permissions to query ' + '%s with user %s :%s' % (path, self.user, err)) raise return resp
Wrapper around http.do_call that transforms some HTTPError into our own exceptions
Below is the the instruction that describes the task: ### Input: Wrapper around http.do_call that transforms some HTTPError into our own exceptions ### Response: def _call(self, path, method, body=None, headers=None): """ Wrapper around http.do_call that transforms some HTTPError into our own exceptions """ try: resp = self.http.do_call(path, method, body, headers) except http.HTTPError as err: if err.status == 401: raise PermissionError('Insufficient permissions to query ' + '%s with user %s :%s' % (path, self.user, err)) raise return resp
def add_vcenter(self, **kwargs): """ Add vCenter on the switch Args: id(str) : Name of an established vCenter url (bool) : vCenter URL username (str): Username of the vCenter password (str): Password of the vCenter callback (function): A function executed upon completion of the method. Returns: Return value of `callback`. Raises: None """ config = ET.Element("config") vcenter = ET.SubElement(config, "vcenter", xmlns="urn:brocade.com:mgmt:brocade-vswitch") id = ET.SubElement(vcenter, "id") id.text = kwargs.pop('id') credentials = ET.SubElement(vcenter, "credentials") url = ET.SubElement(credentials, "url") url.text = kwargs.pop('url') username = ET.SubElement(credentials, "username") username.text = kwargs.pop('username') password = ET.SubElement(credentials, "password") password.text = kwargs.pop('password') try: self._callback(config) return True except Exception as error: logging.error(error) return False
Add vCenter on the switch Args: id(str) : Name of an established vCenter url (bool) : vCenter URL username (str): Username of the vCenter password (str): Password of the vCenter callback (function): A function executed upon completion of the method. Returns: Return value of `callback`. Raises: None
Below is the the instruction that describes the task: ### Input: Add vCenter on the switch Args: id(str) : Name of an established vCenter url (bool) : vCenter URL username (str): Username of the vCenter password (str): Password of the vCenter callback (function): A function executed upon completion of the method. Returns: Return value of `callback`. Raises: None ### Response: def add_vcenter(self, **kwargs): """ Add vCenter on the switch Args: id(str) : Name of an established vCenter url (bool) : vCenter URL username (str): Username of the vCenter password (str): Password of the vCenter callback (function): A function executed upon completion of the method. Returns: Return value of `callback`. Raises: None """ config = ET.Element("config") vcenter = ET.SubElement(config, "vcenter", xmlns="urn:brocade.com:mgmt:brocade-vswitch") id = ET.SubElement(vcenter, "id") id.text = kwargs.pop('id') credentials = ET.SubElement(vcenter, "credentials") url = ET.SubElement(credentials, "url") url.text = kwargs.pop('url') username = ET.SubElement(credentials, "username") username.text = kwargs.pop('username') password = ET.SubElement(credentials, "password") password.text = kwargs.pop('password') try: self._callback(config) return True except Exception as error: logging.error(error) return False
def _convert_service_properties_to_xml(logging, hour_metrics, minute_metrics, cors, target_version=None, delete_retention_policy=None, static_website=None): ''' <?xml version="1.0" encoding="utf-8"?> <StorageServiceProperties> <Logging> <Version>version-number</Version> <Delete>true|false</Delete> <Read>true|false</Read> <Write>true|false</Write> <RetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </RetentionPolicy> </Logging> <HourMetrics> <Version>version-number</Version> <Enabled>true|false</Enabled> <IncludeAPIs>true|false</IncludeAPIs> <RetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </RetentionPolicy> </HourMetrics> <MinuteMetrics> <Version>version-number</Version> <Enabled>true|false</Enabled> <IncludeAPIs>true|false</IncludeAPIs> <RetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </RetentionPolicy> </MinuteMetrics> <Cors> <CorsRule> <AllowedOrigins>comma-separated-list-of-allowed-origins</AllowedOrigins> <AllowedMethods>comma-separated-list-of-HTTP-verb</AllowedMethods> <MaxAgeInSeconds>max-caching-age-in-seconds</MaxAgeInSeconds> <ExposedHeaders>comma-seperated-list-of-response-headers</ExposedHeaders> <AllowedHeaders>comma-seperated-list-of-request-headers</AllowedHeaders> </CorsRule> </Cors> <DeleteRetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </DeleteRetentionPolicy> <StaticWebsite> <Enabled>true|false</Enabled> <IndexDocument></IndexDocument> <ErrorDocument404Path></ErrorDocument404Path> </StaticWebsite> </StorageServiceProperties> ''' service_properties_element = ETree.Element('StorageServiceProperties') # Logging if logging: logging_element = ETree.SubElement(service_properties_element, 'Logging') ETree.SubElement(logging_element, 'Version').text = logging.version ETree.SubElement(logging_element, 'Delete').text = str(logging.delete) ETree.SubElement(logging_element, 'Read').text = str(logging.read) ETree.SubElement(logging_element, 'Write').text = str(logging.write) retention_element = ETree.SubElement(logging_element, 'RetentionPolicy') _convert_retention_policy_to_xml(logging.retention_policy, retention_element) # HourMetrics if hour_metrics: hour_metrics_element = ETree.SubElement(service_properties_element, 'HourMetrics') _convert_metrics_to_xml(hour_metrics, hour_metrics_element) # MinuteMetrics if minute_metrics: minute_metrics_element = ETree.SubElement(service_properties_element, 'MinuteMetrics') _convert_metrics_to_xml(minute_metrics, minute_metrics_element) # CORS # Make sure to still serialize empty list if cors is not None: cors_element = ETree.SubElement(service_properties_element, 'Cors') for rule in cors: cors_rule = ETree.SubElement(cors_element, 'CorsRule') ETree.SubElement(cors_rule, 'AllowedOrigins').text = ",".join(rule.allowed_origins) ETree.SubElement(cors_rule, 'AllowedMethods').text = ",".join(rule.allowed_methods) ETree.SubElement(cors_rule, 'MaxAgeInSeconds').text = str(rule.max_age_in_seconds) ETree.SubElement(cors_rule, 'ExposedHeaders').text = ",".join(rule.exposed_headers) ETree.SubElement(cors_rule, 'AllowedHeaders').text = ",".join(rule.allowed_headers) # Target version if target_version: ETree.SubElement(service_properties_element, 'DefaultServiceVersion').text = target_version # DeleteRetentionPolicy if delete_retention_policy: policy_element = ETree.SubElement(service_properties_element, 'DeleteRetentionPolicy') ETree.SubElement(policy_element, 'Enabled').text = str(delete_retention_policy.enabled) if delete_retention_policy.enabled: ETree.SubElement(policy_element, 'Days').text = str(delete_retention_policy.days) # StaticWebsite if static_website: static_website_element = ETree.SubElement(service_properties_element, 'StaticWebsite') ETree.SubElement(static_website_element, 'Enabled').text = str(static_website.enabled) if static_website.enabled: if static_website.index_document is not None: ETree.SubElement(static_website_element, 'IndexDocument').text = str(static_website.index_document) if static_website.error_document_404_path is not None: ETree.SubElement(static_website_element, 'ErrorDocument404Path').text = \ str(static_website.error_document_404_path) # Add xml declaration and serialize try: stream = BytesIO() ETree.ElementTree(service_properties_element).write(stream, xml_declaration=True, encoding='utf-8', method='xml') except: raise finally: output = stream.getvalue() stream.close() return output
<?xml version="1.0" encoding="utf-8"?> <StorageServiceProperties> <Logging> <Version>version-number</Version> <Delete>true|false</Delete> <Read>true|false</Read> <Write>true|false</Write> <RetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </RetentionPolicy> </Logging> <HourMetrics> <Version>version-number</Version> <Enabled>true|false</Enabled> <IncludeAPIs>true|false</IncludeAPIs> <RetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </RetentionPolicy> </HourMetrics> <MinuteMetrics> <Version>version-number</Version> <Enabled>true|false</Enabled> <IncludeAPIs>true|false</IncludeAPIs> <RetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </RetentionPolicy> </MinuteMetrics> <Cors> <CorsRule> <AllowedOrigins>comma-separated-list-of-allowed-origins</AllowedOrigins> <AllowedMethods>comma-separated-list-of-HTTP-verb</AllowedMethods> <MaxAgeInSeconds>max-caching-age-in-seconds</MaxAgeInSeconds> <ExposedHeaders>comma-seperated-list-of-response-headers</ExposedHeaders> <AllowedHeaders>comma-seperated-list-of-request-headers</AllowedHeaders> </CorsRule> </Cors> <DeleteRetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </DeleteRetentionPolicy> <StaticWebsite> <Enabled>true|false</Enabled> <IndexDocument></IndexDocument> <ErrorDocument404Path></ErrorDocument404Path> </StaticWebsite> </StorageServiceProperties>
Below is the the instruction that describes the task: ### Input: <?xml version="1.0" encoding="utf-8"?> <StorageServiceProperties> <Logging> <Version>version-number</Version> <Delete>true|false</Delete> <Read>true|false</Read> <Write>true|false</Write> <RetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </RetentionPolicy> </Logging> <HourMetrics> <Version>version-number</Version> <Enabled>true|false</Enabled> <IncludeAPIs>true|false</IncludeAPIs> <RetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </RetentionPolicy> </HourMetrics> <MinuteMetrics> <Version>version-number</Version> <Enabled>true|false</Enabled> <IncludeAPIs>true|false</IncludeAPIs> <RetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </RetentionPolicy> </MinuteMetrics> <Cors> <CorsRule> <AllowedOrigins>comma-separated-list-of-allowed-origins</AllowedOrigins> <AllowedMethods>comma-separated-list-of-HTTP-verb</AllowedMethods> <MaxAgeInSeconds>max-caching-age-in-seconds</MaxAgeInSeconds> <ExposedHeaders>comma-seperated-list-of-response-headers</ExposedHeaders> <AllowedHeaders>comma-seperated-list-of-request-headers</AllowedHeaders> </CorsRule> </Cors> <DeleteRetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </DeleteRetentionPolicy> <StaticWebsite> <Enabled>true|false</Enabled> <IndexDocument></IndexDocument> <ErrorDocument404Path></ErrorDocument404Path> </StaticWebsite> </StorageServiceProperties> ### Response: def _convert_service_properties_to_xml(logging, hour_metrics, minute_metrics, cors, target_version=None, delete_retention_policy=None, static_website=None): ''' <?xml version="1.0" encoding="utf-8"?> <StorageServiceProperties> <Logging> <Version>version-number</Version> <Delete>true|false</Delete> <Read>true|false</Read> <Write>true|false</Write> <RetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </RetentionPolicy> </Logging> <HourMetrics> <Version>version-number</Version> <Enabled>true|false</Enabled> <IncludeAPIs>true|false</IncludeAPIs> <RetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </RetentionPolicy> </HourMetrics> <MinuteMetrics> <Version>version-number</Version> <Enabled>true|false</Enabled> <IncludeAPIs>true|false</IncludeAPIs> <RetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </RetentionPolicy> </MinuteMetrics> <Cors> <CorsRule> <AllowedOrigins>comma-separated-list-of-allowed-origins</AllowedOrigins> <AllowedMethods>comma-separated-list-of-HTTP-verb</AllowedMethods> <MaxAgeInSeconds>max-caching-age-in-seconds</MaxAgeInSeconds> <ExposedHeaders>comma-seperated-list-of-response-headers</ExposedHeaders> <AllowedHeaders>comma-seperated-list-of-request-headers</AllowedHeaders> </CorsRule> </Cors> <DeleteRetentionPolicy> <Enabled>true|false</Enabled> <Days>number-of-days</Days> </DeleteRetentionPolicy> <StaticWebsite> <Enabled>true|false</Enabled> <IndexDocument></IndexDocument> <ErrorDocument404Path></ErrorDocument404Path> </StaticWebsite> </StorageServiceProperties> ''' service_properties_element = ETree.Element('StorageServiceProperties') # Logging if logging: logging_element = ETree.SubElement(service_properties_element, 'Logging') ETree.SubElement(logging_element, 'Version').text = logging.version ETree.SubElement(logging_element, 'Delete').text = str(logging.delete) ETree.SubElement(logging_element, 'Read').text = str(logging.read) ETree.SubElement(logging_element, 'Write').text = str(logging.write) retention_element = ETree.SubElement(logging_element, 'RetentionPolicy') _convert_retention_policy_to_xml(logging.retention_policy, retention_element) # HourMetrics if hour_metrics: hour_metrics_element = ETree.SubElement(service_properties_element, 'HourMetrics') _convert_metrics_to_xml(hour_metrics, hour_metrics_element) # MinuteMetrics if minute_metrics: minute_metrics_element = ETree.SubElement(service_properties_element, 'MinuteMetrics') _convert_metrics_to_xml(minute_metrics, minute_metrics_element) # CORS # Make sure to still serialize empty list if cors is not None: cors_element = ETree.SubElement(service_properties_element, 'Cors') for rule in cors: cors_rule = ETree.SubElement(cors_element, 'CorsRule') ETree.SubElement(cors_rule, 'AllowedOrigins').text = ",".join(rule.allowed_origins) ETree.SubElement(cors_rule, 'AllowedMethods').text = ",".join(rule.allowed_methods) ETree.SubElement(cors_rule, 'MaxAgeInSeconds').text = str(rule.max_age_in_seconds) ETree.SubElement(cors_rule, 'ExposedHeaders').text = ",".join(rule.exposed_headers) ETree.SubElement(cors_rule, 'AllowedHeaders').text = ",".join(rule.allowed_headers) # Target version if target_version: ETree.SubElement(service_properties_element, 'DefaultServiceVersion').text = target_version # DeleteRetentionPolicy if delete_retention_policy: policy_element = ETree.SubElement(service_properties_element, 'DeleteRetentionPolicy') ETree.SubElement(policy_element, 'Enabled').text = str(delete_retention_policy.enabled) if delete_retention_policy.enabled: ETree.SubElement(policy_element, 'Days').text = str(delete_retention_policy.days) # StaticWebsite if static_website: static_website_element = ETree.SubElement(service_properties_element, 'StaticWebsite') ETree.SubElement(static_website_element, 'Enabled').text = str(static_website.enabled) if static_website.enabled: if static_website.index_document is not None: ETree.SubElement(static_website_element, 'IndexDocument').text = str(static_website.index_document) if static_website.error_document_404_path is not None: ETree.SubElement(static_website_element, 'ErrorDocument404Path').text = \ str(static_website.error_document_404_path) # Add xml declaration and serialize try: stream = BytesIO() ETree.ElementTree(service_properties_element).write(stream, xml_declaration=True, encoding='utf-8', method='xml') except: raise finally: output = stream.getvalue() stream.close() return output
def query(method='servers', server_id=None, command=None, args=None, http_method='GET', root='api_root'): ''' Make a call to the Scaleway API. ''' if root == 'api_root': default_url = 'https://cp-par1.scaleway.com' else: default_url = 'https://api-marketplace.scaleway.com' base_path = six.text_type(config.get_cloud_config_value( root, get_configured_provider(), __opts__, search_global=False, default=default_url )) path = '{0}/{1}/'.format(base_path, method) if server_id: path += '{0}/'.format(server_id) if command: path += command if not isinstance(args, dict): args = {} token = config.get_cloud_config_value( 'token', get_configured_provider(), __opts__, search_global=False ) data = salt.utils.json.dumps(args) request = __utils__["http.query"](path, method=http_method, data=data, status=True, decode=True, decode_type='json', data_render=True, data_renderer='json', headers=True, header_dict={'X-Auth-Token': token, 'User-Agent': "salt-cloud", 'Content-Type': 'application/json'}) if request['status'] > 299: raise SaltCloudSystemExit( 'An error occurred while querying Scaleway. HTTP Code: {0} ' 'Error: \'{1}\''.format( request['status'], request['error'] ) ) # success without data if request['status'] == 204: return True return salt.utils.json.loads(request['body'])
Make a call to the Scaleway API.
Below is the the instruction that describes the task: ### Input: Make a call to the Scaleway API. ### Response: def query(method='servers', server_id=None, command=None, args=None, http_method='GET', root='api_root'): ''' Make a call to the Scaleway API. ''' if root == 'api_root': default_url = 'https://cp-par1.scaleway.com' else: default_url = 'https://api-marketplace.scaleway.com' base_path = six.text_type(config.get_cloud_config_value( root, get_configured_provider(), __opts__, search_global=False, default=default_url )) path = '{0}/{1}/'.format(base_path, method) if server_id: path += '{0}/'.format(server_id) if command: path += command if not isinstance(args, dict): args = {} token = config.get_cloud_config_value( 'token', get_configured_provider(), __opts__, search_global=False ) data = salt.utils.json.dumps(args) request = __utils__["http.query"](path, method=http_method, data=data, status=True, decode=True, decode_type='json', data_render=True, data_renderer='json', headers=True, header_dict={'X-Auth-Token': token, 'User-Agent': "salt-cloud", 'Content-Type': 'application/json'}) if request['status'] > 299: raise SaltCloudSystemExit( 'An error occurred while querying Scaleway. HTTP Code: {0} ' 'Error: \'{1}\''.format( request['status'], request['error'] ) ) # success without data if request['status'] == 204: return True return salt.utils.json.loads(request['body'])
def _t_update_b(self): r""" A method to update 'b' array at each time step according to 't_scheme' and the source term value """ network = self.project.network phase = self.project.phases()[self.settings['phase']] Vi = network['pore.volume'] dt = self.settings['t_step'] s = self.settings['t_scheme'] if (s == 'implicit'): f1, f2, f3 = 1, 1, 0 elif (s == 'cranknicolson'): f1, f2, f3 = 0.5, 1, 0 elif (s == 'steady'): f1, f2, f3 = 1, 0, 1 x_old = self[self.settings['quantity']] b = (f2*(1-f1)*(-self._A_steady)*x_old + f2*(Vi/dt)*x_old + f3*np.zeros(shape=(self.Np, ), dtype=float)) self._update_physics() for item in self.settings['sources']: Ps = self.pores(item) # Update b b[Ps] = b[Ps] - f2*(1-f1)*(phase[item+'.'+'rate'][Ps]) self._b = b return b
r""" A method to update 'b' array at each time step according to 't_scheme' and the source term value
Below is the the instruction that describes the task: ### Input: r""" A method to update 'b' array at each time step according to 't_scheme' and the source term value ### Response: def _t_update_b(self): r""" A method to update 'b' array at each time step according to 't_scheme' and the source term value """ network = self.project.network phase = self.project.phases()[self.settings['phase']] Vi = network['pore.volume'] dt = self.settings['t_step'] s = self.settings['t_scheme'] if (s == 'implicit'): f1, f2, f3 = 1, 1, 0 elif (s == 'cranknicolson'): f1, f2, f3 = 0.5, 1, 0 elif (s == 'steady'): f1, f2, f3 = 1, 0, 1 x_old = self[self.settings['quantity']] b = (f2*(1-f1)*(-self._A_steady)*x_old + f2*(Vi/dt)*x_old + f3*np.zeros(shape=(self.Np, ), dtype=float)) self._update_physics() for item in self.settings['sources']: Ps = self.pores(item) # Update b b[Ps] = b[Ps] - f2*(1-f1)*(phase[item+'.'+'rate'][Ps]) self._b = b return b
def installFuncVersionedLib(target, source, env): """Install a versioned library into a target using the function specified as the INSTALLVERSIONEDLIB construction variable.""" try: install = env['INSTALLVERSIONEDLIB'] except KeyError: raise SCons.Errors.UserError('Missing INSTALLVERSIONEDLIB construction variable.') assert len(target)==len(source), \ "Installing source %s into target %s: target and source lists must have same length."%(list(map(str, source)), list(map(str, target))) for t,s in zip(target,source): if hasattr(t.attributes, 'shlibname'): tpath = os.path.join(t.get_dir(), t.attributes.shlibname) else: tpath = t.get_path() if install(tpath,s.get_path(),env): return 1 return 0
Install a versioned library into a target using the function specified as the INSTALLVERSIONEDLIB construction variable.
Below is the the instruction that describes the task: ### Input: Install a versioned library into a target using the function specified as the INSTALLVERSIONEDLIB construction variable. ### Response: def installFuncVersionedLib(target, source, env): """Install a versioned library into a target using the function specified as the INSTALLVERSIONEDLIB construction variable.""" try: install = env['INSTALLVERSIONEDLIB'] except KeyError: raise SCons.Errors.UserError('Missing INSTALLVERSIONEDLIB construction variable.') assert len(target)==len(source), \ "Installing source %s into target %s: target and source lists must have same length."%(list(map(str, source)), list(map(str, target))) for t,s in zip(target,source): if hasattr(t.attributes, 'shlibname'): tpath = os.path.join(t.get_dir(), t.attributes.shlibname) else: tpath = t.get_path() if install(tpath,s.get_path(),env): return 1 return 0
def _get_related_indicators_page_generator(self, indicators=None, enclave_ids=None, start_page=0, page_size=None): """ Creates a generator from the |get_related_indicators_page| method that returns each successive page. :param indicators: list of indicator values to search for :param enclave_ids: list of IDs of enclaves to search in :param start_page: The page to start on. :param page_size: The size of each page. :return: The generator. """ get_page = functools.partial(self.get_related_indicators_page, indicators, enclave_ids) return Page.get_page_generator(get_page, start_page, page_size)
Creates a generator from the |get_related_indicators_page| method that returns each successive page. :param indicators: list of indicator values to search for :param enclave_ids: list of IDs of enclaves to search in :param start_page: The page to start on. :param page_size: The size of each page. :return: The generator.
Below is the the instruction that describes the task: ### Input: Creates a generator from the |get_related_indicators_page| method that returns each successive page. :param indicators: list of indicator values to search for :param enclave_ids: list of IDs of enclaves to search in :param start_page: The page to start on. :param page_size: The size of each page. :return: The generator. ### Response: def _get_related_indicators_page_generator(self, indicators=None, enclave_ids=None, start_page=0, page_size=None): """ Creates a generator from the |get_related_indicators_page| method that returns each successive page. :param indicators: list of indicator values to search for :param enclave_ids: list of IDs of enclaves to search in :param start_page: The page to start on. :param page_size: The size of each page. :return: The generator. """ get_page = functools.partial(self.get_related_indicators_page, indicators, enclave_ids) return Page.get_page_generator(get_page, start_page, page_size)
def process_formdata(self, valuelist): """Join time string.""" if valuelist: time_str = u' '.join(valuelist) try: timetuple = time.strptime(time_str, self.format) self.data = datetime.time(*timetuple[3:6]) except ValueError: self.data = None raise
Join time string.
Below is the the instruction that describes the task: ### Input: Join time string. ### Response: def process_formdata(self, valuelist): """Join time string.""" if valuelist: time_str = u' '.join(valuelist) try: timetuple = time.strptime(time_str, self.format) self.data = datetime.time(*timetuple[3:6]) except ValueError: self.data = None raise
def write(self, oprot): ''' Write this object to the given output protocol and return self. :type oprot: thryft.protocol._output_protocol._OutputProtocol :rtype: pastpy.gen.database.impl.dummy.dummy_database_configuration.DummyDatabaseConfiguration ''' oprot.write_struct_begin('DummyDatabaseConfiguration') oprot.write_field_begin(name='images_per_object', type=8, id=None) oprot.write_i32(self.images_per_object) oprot.write_field_end() oprot.write_field_begin(name='objects', type=8, id=None) oprot.write_i32(self.objects) oprot.write_field_end() oprot.write_field_stop() oprot.write_struct_end() return self
Write this object to the given output protocol and return self. :type oprot: thryft.protocol._output_protocol._OutputProtocol :rtype: pastpy.gen.database.impl.dummy.dummy_database_configuration.DummyDatabaseConfiguration
Below is the the instruction that describes the task: ### Input: Write this object to the given output protocol and return self. :type oprot: thryft.protocol._output_protocol._OutputProtocol :rtype: pastpy.gen.database.impl.dummy.dummy_database_configuration.DummyDatabaseConfiguration ### Response: def write(self, oprot): ''' Write this object to the given output protocol and return self. :type oprot: thryft.protocol._output_protocol._OutputProtocol :rtype: pastpy.gen.database.impl.dummy.dummy_database_configuration.DummyDatabaseConfiguration ''' oprot.write_struct_begin('DummyDatabaseConfiguration') oprot.write_field_begin(name='images_per_object', type=8, id=None) oprot.write_i32(self.images_per_object) oprot.write_field_end() oprot.write_field_begin(name='objects', type=8, id=None) oprot.write_i32(self.objects) oprot.write_field_end() oprot.write_field_stop() oprot.write_struct_end() return self
def enroll(self, uuid, organization, from_date=MIN_PERIOD_DATE, to_date=MAX_PERIOD_DATE, merge=False): """Enroll a unique identity in an organization. This method adds a new relationship between the unique identity, identified by <uuid>, and <organization>. Both entities must exist on the registry before creating the new enrollment. The period of the enrollment can be given with the parameters <from_date> and <to_date>, where "from_date <= to_date". Default values for these dates are '1900-01-01' and '2100-01-01'. When "merge" parameter is set to True, those overlapped enrollments related to <uuid> and <organization> found on the registry will be merged. The given enrollment will be also merged. :param uuid: unique identifier :param organization: name of the organization :param from_date: date when the enrollment starts :param to_date: date when the enrollment ends :param merge: merge overlapped enrollments; by default, it is set to False """ # Empty or None values for uuid and organizations are not allowed if not uuid or not organization: return CMD_SUCCESS try: api.add_enrollment(self.db, uuid, organization, from_date, to_date) code = CMD_SUCCESS except (NotFoundError, InvalidValueError) as e: self.error(str(e)) code = e.code except AlreadyExistsError as e: if not merge: msg_data = { 'uuid': uuid, 'org': organization, 'from_dt': str(from_date), 'to_dt': str(to_date) } msg = "enrollment for '%(uuid)s' at '%(org)s' (from: %(from_dt)s, to: %(to_dt)s) already exists in the registry" msg = msg % msg_data self.error(msg) code = e.code if not merge: return code try: api.merge_enrollments(self.db, uuid, organization) except (NotFoundError, InvalidValueError) as e: # These exceptions were checked above. If any of these raises # is due to something really wrong has happened raise RuntimeError(str(e)) return CMD_SUCCESS
Enroll a unique identity in an organization. This method adds a new relationship between the unique identity, identified by <uuid>, and <organization>. Both entities must exist on the registry before creating the new enrollment. The period of the enrollment can be given with the parameters <from_date> and <to_date>, where "from_date <= to_date". Default values for these dates are '1900-01-01' and '2100-01-01'. When "merge" parameter is set to True, those overlapped enrollments related to <uuid> and <organization> found on the registry will be merged. The given enrollment will be also merged. :param uuid: unique identifier :param organization: name of the organization :param from_date: date when the enrollment starts :param to_date: date when the enrollment ends :param merge: merge overlapped enrollments; by default, it is set to False
Below is the the instruction that describes the task: ### Input: Enroll a unique identity in an organization. This method adds a new relationship between the unique identity, identified by <uuid>, and <organization>. Both entities must exist on the registry before creating the new enrollment. The period of the enrollment can be given with the parameters <from_date> and <to_date>, where "from_date <= to_date". Default values for these dates are '1900-01-01' and '2100-01-01'. When "merge" parameter is set to True, those overlapped enrollments related to <uuid> and <organization> found on the registry will be merged. The given enrollment will be also merged. :param uuid: unique identifier :param organization: name of the organization :param from_date: date when the enrollment starts :param to_date: date when the enrollment ends :param merge: merge overlapped enrollments; by default, it is set to False ### Response: def enroll(self, uuid, organization, from_date=MIN_PERIOD_DATE, to_date=MAX_PERIOD_DATE, merge=False): """Enroll a unique identity in an organization. This method adds a new relationship between the unique identity, identified by <uuid>, and <organization>. Both entities must exist on the registry before creating the new enrollment. The period of the enrollment can be given with the parameters <from_date> and <to_date>, where "from_date <= to_date". Default values for these dates are '1900-01-01' and '2100-01-01'. When "merge" parameter is set to True, those overlapped enrollments related to <uuid> and <organization> found on the registry will be merged. The given enrollment will be also merged. :param uuid: unique identifier :param organization: name of the organization :param from_date: date when the enrollment starts :param to_date: date when the enrollment ends :param merge: merge overlapped enrollments; by default, it is set to False """ # Empty or None values for uuid and organizations are not allowed if not uuid or not organization: return CMD_SUCCESS try: api.add_enrollment(self.db, uuid, organization, from_date, to_date) code = CMD_SUCCESS except (NotFoundError, InvalidValueError) as e: self.error(str(e)) code = e.code except AlreadyExistsError as e: if not merge: msg_data = { 'uuid': uuid, 'org': organization, 'from_dt': str(from_date), 'to_dt': str(to_date) } msg = "enrollment for '%(uuid)s' at '%(org)s' (from: %(from_dt)s, to: %(to_dt)s) already exists in the registry" msg = msg % msg_data self.error(msg) code = e.code if not merge: return code try: api.merge_enrollments(self.db, uuid, organization) except (NotFoundError, InvalidValueError) as e: # These exceptions were checked above. If any of these raises # is due to something really wrong has happened raise RuntimeError(str(e)) return CMD_SUCCESS
def array2ntpl(arr): """ Convert a :class:`numpy.ndarray` object constructed by :func:`ntpl2array` back to the original :func:`collections.namedtuple` representation. Parameters ---------- arr : ndarray Array representation of named tuple constructed by :func:`ntpl2array` Returns ------- ntpl : collections.namedtuple object Named tuple object with the same name and fields as the original named typle object provided to :func:`ntpl2array` """ cls = collections.namedtuple(arr[2], arr[1]) return cls(*tuple(arr[0]))
Convert a :class:`numpy.ndarray` object constructed by :func:`ntpl2array` back to the original :func:`collections.namedtuple` representation. Parameters ---------- arr : ndarray Array representation of named tuple constructed by :func:`ntpl2array` Returns ------- ntpl : collections.namedtuple object Named tuple object with the same name and fields as the original named typle object provided to :func:`ntpl2array`
Below is the the instruction that describes the task: ### Input: Convert a :class:`numpy.ndarray` object constructed by :func:`ntpl2array` back to the original :func:`collections.namedtuple` representation. Parameters ---------- arr : ndarray Array representation of named tuple constructed by :func:`ntpl2array` Returns ------- ntpl : collections.namedtuple object Named tuple object with the same name and fields as the original named typle object provided to :func:`ntpl2array` ### Response: def array2ntpl(arr): """ Convert a :class:`numpy.ndarray` object constructed by :func:`ntpl2array` back to the original :func:`collections.namedtuple` representation. Parameters ---------- arr : ndarray Array representation of named tuple constructed by :func:`ntpl2array` Returns ------- ntpl : collections.namedtuple object Named tuple object with the same name and fields as the original named typle object provided to :func:`ntpl2array` """ cls = collections.namedtuple(arr[2], arr[1]) return cls(*tuple(arr[0]))
def serialize(self): ''' Return a JSON string of the serialized topology ''' return json.dumps(json_graph.node_link_data(self.__nxgraph), cls=Encoder)
Return a JSON string of the serialized topology
Below is the the instruction that describes the task: ### Input: Return a JSON string of the serialized topology ### Response: def serialize(self): ''' Return a JSON string of the serialized topology ''' return json.dumps(json_graph.node_link_data(self.__nxgraph), cls=Encoder)
def produce_upgrade_operations( ctx=None, metadata=None, include_symbol=None, include_object=None, **kwargs): """Produce a list of upgrade statements.""" if metadata is None: # Note, all SQLAlchemy models must have been loaded to produce # accurate results. metadata = db.metadata if ctx is None: ctx = create_migration_ctx(target_metadata=metadata, **kwargs) template_args = {} imports = set() _produce_migration_diffs( ctx, template_args, imports, include_object=include_object, include_symbol=include_symbol, **kwargs ) return template_args
Produce a list of upgrade statements.
Below is the the instruction that describes the task: ### Input: Produce a list of upgrade statements. ### Response: def produce_upgrade_operations( ctx=None, metadata=None, include_symbol=None, include_object=None, **kwargs): """Produce a list of upgrade statements.""" if metadata is None: # Note, all SQLAlchemy models must have been loaded to produce # accurate results. metadata = db.metadata if ctx is None: ctx = create_migration_ctx(target_metadata=metadata, **kwargs) template_args = {} imports = set() _produce_migration_diffs( ctx, template_args, imports, include_object=include_object, include_symbol=include_symbol, **kwargs ) return template_args
def joinCommissioned(self, strPSKd='threadjpaketest', waitTime=20): """start joiner Args: strPSKd: Joiner's PSKd Returns: True: successful to start joiner False: fail to start joiner """ print '%s call joinCommissioned' % self.port self.__sendCommand('ifconfig up') cmd = 'joiner start %s %s' %(strPSKd, self.provisioningUrl) print cmd if self.__sendCommand(cmd)[0] == "Done": maxDuration = 150 # seconds self.joinCommissionedStatus = self.joinStatus['ongoing'] if self.logThreadStatus == self.logStatus['stop']: self.logThread = ThreadRunner.run(target=self.__readCommissioningLogs, args=(maxDuration,)) t_end = time.time() + maxDuration while time.time() < t_end: if self.joinCommissionedStatus == self.joinStatus['succeed']: break elif self.joinCommissionedStatus == self.joinStatus['failed']: return False time.sleep(1) self.__sendCommand('thread start') time.sleep(30) return True else: return False
start joiner Args: strPSKd: Joiner's PSKd Returns: True: successful to start joiner False: fail to start joiner
Below is the the instruction that describes the task: ### Input: start joiner Args: strPSKd: Joiner's PSKd Returns: True: successful to start joiner False: fail to start joiner ### Response: def joinCommissioned(self, strPSKd='threadjpaketest', waitTime=20): """start joiner Args: strPSKd: Joiner's PSKd Returns: True: successful to start joiner False: fail to start joiner """ print '%s call joinCommissioned' % self.port self.__sendCommand('ifconfig up') cmd = 'joiner start %s %s' %(strPSKd, self.provisioningUrl) print cmd if self.__sendCommand(cmd)[0] == "Done": maxDuration = 150 # seconds self.joinCommissionedStatus = self.joinStatus['ongoing'] if self.logThreadStatus == self.logStatus['stop']: self.logThread = ThreadRunner.run(target=self.__readCommissioningLogs, args=(maxDuration,)) t_end = time.time() + maxDuration while time.time() < t_end: if self.joinCommissionedStatus == self.joinStatus['succeed']: break elif self.joinCommissionedStatus == self.joinStatus['failed']: return False time.sleep(1) self.__sendCommand('thread start') time.sleep(30) return True else: return False
def _load(self, exit_on_failure): """One you have added all your configuration data (Section, Element, ...) you need to load data from the config file.""" # pylint: disable-msg=W0621 log = logging.getLogger('argtoolbox') discoveredFileList = [] if self.config_file: if isinstance(self.config_file, types.UnicodeType): discoveredFileList = self.file_parser.read(self.config_file) else: discoveredFileList = self.file_parser.readfp( self.config_file, "file descriptor") else: defaultFileList = [] defaultFileList.append(self.prog_name + ".cfg") defaultFileList.append( os.path.expanduser('~/.' + self.prog_name + '.cfg')) defaultFileList.append('/etc/' + self.prog_name + '.cfg') log.debug("defaultFileList: " + str(defaultFileList)) discoveredFileList = self.file_parser.read(defaultFileList) log.debug("discoveredFileList: " + str(discoveredFileList)) if self.mandatory and len(discoveredFileList) < 1: msg = "The required config file was missing." msg += " Default config files : " + str(defaultFileList) log.error(msg) raise EnvironmentError(msg) log.debug("loading configuration ...") if exit_on_failure: for s in self.sections.values(): log.debug("loading section : " + s.get_section_name()) try: s.load(self.file_parser) except ValueError: sys.exit(1) else: for s in self.sections.values(): log.debug("loading section : " + s.get_section_name()) s.load(self.file_parser) log.debug("configuration loaded.")
One you have added all your configuration data (Section, Element, ...) you need to load data from the config file.
Below is the the instruction that describes the task: ### Input: One you have added all your configuration data (Section, Element, ...) you need to load data from the config file. ### Response: def _load(self, exit_on_failure): """One you have added all your configuration data (Section, Element, ...) you need to load data from the config file.""" # pylint: disable-msg=W0621 log = logging.getLogger('argtoolbox') discoveredFileList = [] if self.config_file: if isinstance(self.config_file, types.UnicodeType): discoveredFileList = self.file_parser.read(self.config_file) else: discoveredFileList = self.file_parser.readfp( self.config_file, "file descriptor") else: defaultFileList = [] defaultFileList.append(self.prog_name + ".cfg") defaultFileList.append( os.path.expanduser('~/.' + self.prog_name + '.cfg')) defaultFileList.append('/etc/' + self.prog_name + '.cfg') log.debug("defaultFileList: " + str(defaultFileList)) discoveredFileList = self.file_parser.read(defaultFileList) log.debug("discoveredFileList: " + str(discoveredFileList)) if self.mandatory and len(discoveredFileList) < 1: msg = "The required config file was missing." msg += " Default config files : " + str(defaultFileList) log.error(msg) raise EnvironmentError(msg) log.debug("loading configuration ...") if exit_on_failure: for s in self.sections.values(): log.debug("loading section : " + s.get_section_name()) try: s.load(self.file_parser) except ValueError: sys.exit(1) else: for s in self.sections.values(): log.debug("loading section : " + s.get_section_name()) s.load(self.file_parser) log.debug("configuration loaded.")
def shadow_reference(self, dispatcher, node): """ Only simply make a reference to the value in the current scope, specifically for the FuncBase type. """ # as opposed to the previous one, only add the value of the # identifier itself to the scope so that it becomes reserved. self.current_scope.reference(node.identifier.value)
Only simply make a reference to the value in the current scope, specifically for the FuncBase type.
Below is the the instruction that describes the task: ### Input: Only simply make a reference to the value in the current scope, specifically for the FuncBase type. ### Response: def shadow_reference(self, dispatcher, node): """ Only simply make a reference to the value in the current scope, specifically for the FuncBase type. """ # as opposed to the previous one, only add the value of the # identifier itself to the scope so that it becomes reserved. self.current_scope.reference(node.identifier.value)
def cpp_app_builder(build_context, target): """Pack a C++ binary as a Docker image with its runtime dependencies. TODO(itamar): Dynamically analyze the binary and copy shared objects from its buildenv image to the runtime image, unless they're installed. """ yprint(build_context.conf, 'Build CppApp', target) if target.props.executable and target.props.main: raise KeyError( '`main` and `executable` arguments are mutually exclusive') if target.props.executable: if target.props.executable not in target.artifacts.get(AT.app): target.artifacts.add(AT.app, target.props.executable) entrypoint = [target.props.executable] elif target.props.main: prog = build_context.targets[target.props.main] binary = list(prog.artifacts.get(AT.binary).keys())[0] entrypoint = ['/usr/src/bin/' + binary] else: raise KeyError('Must specify either `main` or `executable` argument') build_app_docker_and_bin( build_context, target, entrypoint=entrypoint)
Pack a C++ binary as a Docker image with its runtime dependencies. TODO(itamar): Dynamically analyze the binary and copy shared objects from its buildenv image to the runtime image, unless they're installed.
Below is the the instruction that describes the task: ### Input: Pack a C++ binary as a Docker image with its runtime dependencies. TODO(itamar): Dynamically analyze the binary and copy shared objects from its buildenv image to the runtime image, unless they're installed. ### Response: def cpp_app_builder(build_context, target): """Pack a C++ binary as a Docker image with its runtime dependencies. TODO(itamar): Dynamically analyze the binary and copy shared objects from its buildenv image to the runtime image, unless they're installed. """ yprint(build_context.conf, 'Build CppApp', target) if target.props.executable and target.props.main: raise KeyError( '`main` and `executable` arguments are mutually exclusive') if target.props.executable: if target.props.executable not in target.artifacts.get(AT.app): target.artifacts.add(AT.app, target.props.executable) entrypoint = [target.props.executable] elif target.props.main: prog = build_context.targets[target.props.main] binary = list(prog.artifacts.get(AT.binary).keys())[0] entrypoint = ['/usr/src/bin/' + binary] else: raise KeyError('Must specify either `main` or `executable` argument') build_app_docker_and_bin( build_context, target, entrypoint=entrypoint)
def _element_get_id(self, element): """Get id of reaction or species element. In old levels the name is used as the id. This method returns the correct attribute depending on the level. """ if self._reader._level > 1: entry_id = element.get('id') else: entry_id = element.get('name') return entry_id
Get id of reaction or species element. In old levels the name is used as the id. This method returns the correct attribute depending on the level.
Below is the the instruction that describes the task: ### Input: Get id of reaction or species element. In old levels the name is used as the id. This method returns the correct attribute depending on the level. ### Response: def _element_get_id(self, element): """Get id of reaction or species element. In old levels the name is used as the id. This method returns the correct attribute depending on the level. """ if self._reader._level > 1: entry_id = element.get('id') else: entry_id = element.get('name') return entry_id
def _hash_url(self, url): """ Hash the URL to an md5sum. """ if isinstance(url, six.text_type): url = url.encode('utf-8') return hashlib.md5(url).hexdigest()
Hash the URL to an md5sum.
Below is the the instruction that describes the task: ### Input: Hash the URL to an md5sum. ### Response: def _hash_url(self, url): """ Hash the URL to an md5sum. """ if isinstance(url, six.text_type): url = url.encode('utf-8') return hashlib.md5(url).hexdigest()
def getinputfile(self, outputfile, loadmetadata=True, client=None,requiremetadata=False): """Grabs one input file for the specified output filename (raises a KeyError exception if there is no such output, StopIteration if there are no input files for it). Shortcut for getinputfiles()""" if isinstance(outputfile, CLAMOutputFile): outputfilename = str(outputfile).replace(os.path.join(self.projectpath,'output/'),'') else: outputfilename = outputfile if outputfilename not in self: raise KeyError("No such outputfile " + outputfilename) try: return next(self.getinputfiles(outputfile,loadmetadata,client,requiremetadata)) except StopIteration: raise StopIteration("No input files for outputfile " + outputfilename)
Grabs one input file for the specified output filename (raises a KeyError exception if there is no such output, StopIteration if there are no input files for it). Shortcut for getinputfiles()
Below is the the instruction that describes the task: ### Input: Grabs one input file for the specified output filename (raises a KeyError exception if there is no such output, StopIteration if there are no input files for it). Shortcut for getinputfiles() ### Response: def getinputfile(self, outputfile, loadmetadata=True, client=None,requiremetadata=False): """Grabs one input file for the specified output filename (raises a KeyError exception if there is no such output, StopIteration if there are no input files for it). Shortcut for getinputfiles()""" if isinstance(outputfile, CLAMOutputFile): outputfilename = str(outputfile).replace(os.path.join(self.projectpath,'output/'),'') else: outputfilename = outputfile if outputfilename not in self: raise KeyError("No such outputfile " + outputfilename) try: return next(self.getinputfiles(outputfile,loadmetadata,client,requiremetadata)) except StopIteration: raise StopIteration("No input files for outputfile " + outputfilename)
def get_query(self, q, request): """ return a query set searching for the query string q either implement this method yourself or set the search_field in the LookupChannel class definition """ return Group.objects.filter( Q(name__icontains=q) | Q(description__icontains=q) )
return a query set searching for the query string q either implement this method yourself or set the search_field in the LookupChannel class definition
Below is the the instruction that describes the task: ### Input: return a query set searching for the query string q either implement this method yourself or set the search_field in the LookupChannel class definition ### Response: def get_query(self, q, request): """ return a query set searching for the query string q either implement this method yourself or set the search_field in the LookupChannel class definition """ return Group.objects.filter( Q(name__icontains=q) | Q(description__icontains=q) )
def check_archs(copied_libs, require_archs=(), stop_fast=False): """ Check compatibility of archs in `copied_libs` dict Parameters ---------- copied_libs : dict dict containing the (key, value) pairs of (``copied_lib_path``, ``dependings_dict``), where ``copied_lib_path`` is a library real path that has been copied during delocation, and ``dependings_dict`` is a dictionary with key, value pairs where the key is a path in the target being delocated (a wheel or path) depending on ``copied_lib_path``, and the value is the ``install_name`` of ``copied_lib_path`` in the depending library. require_archs : str or sequence, optional Architectures we require to be present in all library files in wheel. If an empty sequence, just check that depended libraries do have the architectures of the depending libraries, with no constraints on what these architectures are. If a sequence, then a set of required architectures e.g. ``['i386', 'x86_64']`` to specify dual Intel architectures. If a string, then a standard architecture name as returned by ``lipo -info`` or the string "intel", corresponding to the sequence ``['i386', 'x86_64']`` stop_fast : bool, optional Whether to give up collecting errors after the first Returns ------- bads : set set of length 2 or 3 tuples. A length 2 tuple is of form ``(depending_lib, missing_archs)`` meaning that an arch in `require_archs` was missing from ``depending_lib``. A length 3 tuple is of form ``(depended_lib, depending_lib, missing_archs)`` where ``depended_lib`` is the filename of the library depended on, ``depending_lib`` is the library depending on ``depending_lib`` and ``missing_archs`` is a set of missing architecture strings giving architectures present in ``depending_lib`` and missing in ``depended_lib``. An empty set means all architectures were present as required. """ if isinstance(require_archs, string_types): require_archs = (['i386', 'x86_64'] if require_archs == 'intel' else [require_archs]) require_archs = frozenset(require_archs) bads = [] for depended_lib, dep_dict in copied_libs.items(): depended_archs = get_archs(depended_lib) for depending_lib, install_name in dep_dict.items(): depending_archs = get_archs(depending_lib) all_required = depending_archs | require_archs all_missing = all_required.difference(depended_archs) if len(all_missing) == 0: continue required_missing = require_archs.difference(depended_archs) if len(required_missing): bads.append((depending_lib, required_missing)) else: bads.append((depended_lib, depending_lib, all_missing)) if stop_fast: return set(bads) return set(bads)
Check compatibility of archs in `copied_libs` dict Parameters ---------- copied_libs : dict dict containing the (key, value) pairs of (``copied_lib_path``, ``dependings_dict``), where ``copied_lib_path`` is a library real path that has been copied during delocation, and ``dependings_dict`` is a dictionary with key, value pairs where the key is a path in the target being delocated (a wheel or path) depending on ``copied_lib_path``, and the value is the ``install_name`` of ``copied_lib_path`` in the depending library. require_archs : str or sequence, optional Architectures we require to be present in all library files in wheel. If an empty sequence, just check that depended libraries do have the architectures of the depending libraries, with no constraints on what these architectures are. If a sequence, then a set of required architectures e.g. ``['i386', 'x86_64']`` to specify dual Intel architectures. If a string, then a standard architecture name as returned by ``lipo -info`` or the string "intel", corresponding to the sequence ``['i386', 'x86_64']`` stop_fast : bool, optional Whether to give up collecting errors after the first Returns ------- bads : set set of length 2 or 3 tuples. A length 2 tuple is of form ``(depending_lib, missing_archs)`` meaning that an arch in `require_archs` was missing from ``depending_lib``. A length 3 tuple is of form ``(depended_lib, depending_lib, missing_archs)`` where ``depended_lib`` is the filename of the library depended on, ``depending_lib`` is the library depending on ``depending_lib`` and ``missing_archs`` is a set of missing architecture strings giving architectures present in ``depending_lib`` and missing in ``depended_lib``. An empty set means all architectures were present as required.
Below is the the instruction that describes the task: ### Input: Check compatibility of archs in `copied_libs` dict Parameters ---------- copied_libs : dict dict containing the (key, value) pairs of (``copied_lib_path``, ``dependings_dict``), where ``copied_lib_path`` is a library real path that has been copied during delocation, and ``dependings_dict`` is a dictionary with key, value pairs where the key is a path in the target being delocated (a wheel or path) depending on ``copied_lib_path``, and the value is the ``install_name`` of ``copied_lib_path`` in the depending library. require_archs : str or sequence, optional Architectures we require to be present in all library files in wheel. If an empty sequence, just check that depended libraries do have the architectures of the depending libraries, with no constraints on what these architectures are. If a sequence, then a set of required architectures e.g. ``['i386', 'x86_64']`` to specify dual Intel architectures. If a string, then a standard architecture name as returned by ``lipo -info`` or the string "intel", corresponding to the sequence ``['i386', 'x86_64']`` stop_fast : bool, optional Whether to give up collecting errors after the first Returns ------- bads : set set of length 2 or 3 tuples. A length 2 tuple is of form ``(depending_lib, missing_archs)`` meaning that an arch in `require_archs` was missing from ``depending_lib``. A length 3 tuple is of form ``(depended_lib, depending_lib, missing_archs)`` where ``depended_lib`` is the filename of the library depended on, ``depending_lib`` is the library depending on ``depending_lib`` and ``missing_archs`` is a set of missing architecture strings giving architectures present in ``depending_lib`` and missing in ``depended_lib``. An empty set means all architectures were present as required. ### Response: def check_archs(copied_libs, require_archs=(), stop_fast=False): """ Check compatibility of archs in `copied_libs` dict Parameters ---------- copied_libs : dict dict containing the (key, value) pairs of (``copied_lib_path``, ``dependings_dict``), where ``copied_lib_path`` is a library real path that has been copied during delocation, and ``dependings_dict`` is a dictionary with key, value pairs where the key is a path in the target being delocated (a wheel or path) depending on ``copied_lib_path``, and the value is the ``install_name`` of ``copied_lib_path`` in the depending library. require_archs : str or sequence, optional Architectures we require to be present in all library files in wheel. If an empty sequence, just check that depended libraries do have the architectures of the depending libraries, with no constraints on what these architectures are. If a sequence, then a set of required architectures e.g. ``['i386', 'x86_64']`` to specify dual Intel architectures. If a string, then a standard architecture name as returned by ``lipo -info`` or the string "intel", corresponding to the sequence ``['i386', 'x86_64']`` stop_fast : bool, optional Whether to give up collecting errors after the first Returns ------- bads : set set of length 2 or 3 tuples. A length 2 tuple is of form ``(depending_lib, missing_archs)`` meaning that an arch in `require_archs` was missing from ``depending_lib``. A length 3 tuple is of form ``(depended_lib, depending_lib, missing_archs)`` where ``depended_lib`` is the filename of the library depended on, ``depending_lib`` is the library depending on ``depending_lib`` and ``missing_archs`` is a set of missing architecture strings giving architectures present in ``depending_lib`` and missing in ``depended_lib``. An empty set means all architectures were present as required. """ if isinstance(require_archs, string_types): require_archs = (['i386', 'x86_64'] if require_archs == 'intel' else [require_archs]) require_archs = frozenset(require_archs) bads = [] for depended_lib, dep_dict in copied_libs.items(): depended_archs = get_archs(depended_lib) for depending_lib, install_name in dep_dict.items(): depending_archs = get_archs(depending_lib) all_required = depending_archs | require_archs all_missing = all_required.difference(depended_archs) if len(all_missing) == 0: continue required_missing = require_archs.difference(depended_archs) if len(required_missing): bads.append((depending_lib, required_missing)) else: bads.append((depended_lib, depending_lib, all_missing)) if stop_fast: return set(bads) return set(bads)
def concrete_descendents(parentclass): """ Return a dictionary containing all subclasses of the specified parentclass, including the parentclass. Only classes that are defined in scripts that have been run or modules that have been imported are included, so the caller will usually first do ``from package import *``. Only non-abstract classes will be included. """ return dict((c.__name__,c) for c in descendents(parentclass) if not _is_abstract(c))
Return a dictionary containing all subclasses of the specified parentclass, including the parentclass. Only classes that are defined in scripts that have been run or modules that have been imported are included, so the caller will usually first do ``from package import *``. Only non-abstract classes will be included.
Below is the the instruction that describes the task: ### Input: Return a dictionary containing all subclasses of the specified parentclass, including the parentclass. Only classes that are defined in scripts that have been run or modules that have been imported are included, so the caller will usually first do ``from package import *``. Only non-abstract classes will be included. ### Response: def concrete_descendents(parentclass): """ Return a dictionary containing all subclasses of the specified parentclass, including the parentclass. Only classes that are defined in scripts that have been run or modules that have been imported are included, so the caller will usually first do ``from package import *``. Only non-abstract classes will be included. """ return dict((c.__name__,c) for c in descendents(parentclass) if not _is_abstract(c))
def tags(self): """Returns a dictionary that lists all available tags that can be used for further filtering """ ret = {} for typ in _meta_fields_twig: if typ in ['uniqueid', 'plugin', 'feedback', 'fitting', 'history', 'twig', 'uniquetwig']: continue k = '{}s'.format(typ) ret[k] = getattr(self, k) return ret
Returns a dictionary that lists all available tags that can be used for further filtering
Below is the the instruction that describes the task: ### Input: Returns a dictionary that lists all available tags that can be used for further filtering ### Response: def tags(self): """Returns a dictionary that lists all available tags that can be used for further filtering """ ret = {} for typ in _meta_fields_twig: if typ in ['uniqueid', 'plugin', 'feedback', 'fitting', 'history', 'twig', 'uniquetwig']: continue k = '{}s'.format(typ) ret[k] = getattr(self, k) return ret
def set_connection_ip_list(addresses=None, grant_by_default=False, server=_DEFAULT_SERVER): ''' Set the IPGrant list for the SMTP virtual server. :param str addresses: A dictionary of IP + subnet pairs. :param bool grant_by_default: Whether the addresses should be a blacklist or whitelist. :param str server: The SMTP server name. :return: A boolean representing whether the change succeeded. :rtype: bool CLI Example: .. code-block:: bash salt '*' win_smtp_server.set_connection_ip_list addresses="{'127.0.0.1': '255.255.255.255'}" ''' setting = 'IPGrant' formatted_addresses = list() # It's okay to accept an empty list for set_connection_ip_list, # since an empty list may be desirable. if not addresses: addresses = dict() _LOG.debug('Empty %s specified.', setting) # Convert addresses to the 'ip_address, subnet' format used by # IIsIPSecuritySetting. for address in addresses: formatted_addresses.append('{0}, {1}'.format(address.strip(), addresses[address].strip())) current_addresses = get_connection_ip_list(as_wmi_format=True, server=server) # Order is not important, so compare to the current addresses as unordered sets. if set(formatted_addresses) == set(current_addresses): _LOG.debug('%s already contains the provided addresses.', setting) return True # First we should check GrantByDefault, and change it if necessary. current_grant_by_default = _get_wmi_setting('IIsIPSecuritySetting', 'GrantByDefault', server) if grant_by_default != current_grant_by_default: _LOG.debug('Setting GrantByDefault to: %s', grant_by_default) _set_wmi_setting('IIsIPSecuritySetting', 'GrantByDefault', grant_by_default, server) _set_wmi_setting('IIsIPSecuritySetting', setting, formatted_addresses, server) new_addresses = get_connection_ip_list(as_wmi_format=True, server=server) ret = set(formatted_addresses) == set(new_addresses) if ret: _LOG.debug('%s configured successfully: %s', setting, formatted_addresses) return ret _LOG.error('Unable to configure %s with value: %s', setting, formatted_addresses) return ret
Set the IPGrant list for the SMTP virtual server. :param str addresses: A dictionary of IP + subnet pairs. :param bool grant_by_default: Whether the addresses should be a blacklist or whitelist. :param str server: The SMTP server name. :return: A boolean representing whether the change succeeded. :rtype: bool CLI Example: .. code-block:: bash salt '*' win_smtp_server.set_connection_ip_list addresses="{'127.0.0.1': '255.255.255.255'}"
Below is the the instruction that describes the task: ### Input: Set the IPGrant list for the SMTP virtual server. :param str addresses: A dictionary of IP + subnet pairs. :param bool grant_by_default: Whether the addresses should be a blacklist or whitelist. :param str server: The SMTP server name. :return: A boolean representing whether the change succeeded. :rtype: bool CLI Example: .. code-block:: bash salt '*' win_smtp_server.set_connection_ip_list addresses="{'127.0.0.1': '255.255.255.255'}" ### Response: def set_connection_ip_list(addresses=None, grant_by_default=False, server=_DEFAULT_SERVER): ''' Set the IPGrant list for the SMTP virtual server. :param str addresses: A dictionary of IP + subnet pairs. :param bool grant_by_default: Whether the addresses should be a blacklist or whitelist. :param str server: The SMTP server name. :return: A boolean representing whether the change succeeded. :rtype: bool CLI Example: .. code-block:: bash salt '*' win_smtp_server.set_connection_ip_list addresses="{'127.0.0.1': '255.255.255.255'}" ''' setting = 'IPGrant' formatted_addresses = list() # It's okay to accept an empty list for set_connection_ip_list, # since an empty list may be desirable. if not addresses: addresses = dict() _LOG.debug('Empty %s specified.', setting) # Convert addresses to the 'ip_address, subnet' format used by # IIsIPSecuritySetting. for address in addresses: formatted_addresses.append('{0}, {1}'.format(address.strip(), addresses[address].strip())) current_addresses = get_connection_ip_list(as_wmi_format=True, server=server) # Order is not important, so compare to the current addresses as unordered sets. if set(formatted_addresses) == set(current_addresses): _LOG.debug('%s already contains the provided addresses.', setting) return True # First we should check GrantByDefault, and change it if necessary. current_grant_by_default = _get_wmi_setting('IIsIPSecuritySetting', 'GrantByDefault', server) if grant_by_default != current_grant_by_default: _LOG.debug('Setting GrantByDefault to: %s', grant_by_default) _set_wmi_setting('IIsIPSecuritySetting', 'GrantByDefault', grant_by_default, server) _set_wmi_setting('IIsIPSecuritySetting', setting, formatted_addresses, server) new_addresses = get_connection_ip_list(as_wmi_format=True, server=server) ret = set(formatted_addresses) == set(new_addresses) if ret: _LOG.debug('%s configured successfully: %s', setting, formatted_addresses) return ret _LOG.error('Unable to configure %s with value: %s', setting, formatted_addresses) return ret
def manipulate(self, stored_instance, component_instance): """ Stores the given StoredInstance bean. :param stored_instance: The iPOPO component StoredInstance :param component_instance: The component instance """ # Store the stored instance... self._ipopo_instance = stored_instance # ... and the bundle context self._context = stored_instance.bundle_context # Set the default value for the field: an empty dictionary setattr(component_instance, self._field, {})
Stores the given StoredInstance bean. :param stored_instance: The iPOPO component StoredInstance :param component_instance: The component instance
Below is the the instruction that describes the task: ### Input: Stores the given StoredInstance bean. :param stored_instance: The iPOPO component StoredInstance :param component_instance: The component instance ### Response: def manipulate(self, stored_instance, component_instance): """ Stores the given StoredInstance bean. :param stored_instance: The iPOPO component StoredInstance :param component_instance: The component instance """ # Store the stored instance... self._ipopo_instance = stored_instance # ... and the bundle context self._context = stored_instance.bundle_context # Set the default value for the field: an empty dictionary setattr(component_instance, self._field, {})
def decodeString(encoded): ''' Decodes an UTF-8 string from an encoded MQTT bytearray. Returns the decoded string and renaining bytearray to be parsed ''' length = encoded[0]*256 + encoded[1] return (encoded[2:2+length].decode('utf-8'), encoded[2+length:])
Decodes an UTF-8 string from an encoded MQTT bytearray. Returns the decoded string and renaining bytearray to be parsed
Below is the the instruction that describes the task: ### Input: Decodes an UTF-8 string from an encoded MQTT bytearray. Returns the decoded string and renaining bytearray to be parsed ### Response: def decodeString(encoded): ''' Decodes an UTF-8 string from an encoded MQTT bytearray. Returns the decoded string and renaining bytearray to be parsed ''' length = encoded[0]*256 + encoded[1] return (encoded[2:2+length].decode('utf-8'), encoded[2+length:])
def write(self, text, color): """ Write the given text to the stream in the given color. """ color = self._colors[color] self.stream.write('\x1b[{}m{}\x1b[0m'.format(color, text))
Write the given text to the stream in the given color.
Below is the the instruction that describes the task: ### Input: Write the given text to the stream in the given color. ### Response: def write(self, text, color): """ Write the given text to the stream in the given color. """ color = self._colors[color] self.stream.write('\x1b[{}m{}\x1b[0m'.format(color, text))
def operations_map(self): # type: () -> Dict[Union[str, None], str] """ returns a Mapping of operation names and it's associated types. E.g. {'myQuery': 'query', 'myMutation': 'mutation'} """ document_ast = self.document_ast operations = {} # type: Dict[Union[str, None], str] for definition in document_ast.definitions: if isinstance(definition, ast.OperationDefinition): if definition.name: operations[definition.name.value] = definition.operation else: operations[None] = definition.operation return operations
returns a Mapping of operation names and it's associated types. E.g. {'myQuery': 'query', 'myMutation': 'mutation'}
Below is the the instruction that describes the task: ### Input: returns a Mapping of operation names and it's associated types. E.g. {'myQuery': 'query', 'myMutation': 'mutation'} ### Response: def operations_map(self): # type: () -> Dict[Union[str, None], str] """ returns a Mapping of operation names and it's associated types. E.g. {'myQuery': 'query', 'myMutation': 'mutation'} """ document_ast = self.document_ast operations = {} # type: Dict[Union[str, None], str] for definition in document_ast.definitions: if isinstance(definition, ast.OperationDefinition): if definition.name: operations[definition.name.value] = definition.operation else: operations[None] = definition.operation return operations
def authorize(self, ctx, identity, ops): '''Implements Authorizer.authorize by calling f with the given identity for each operation. ''' allowed = [] caveats = [] for op in ops: ok, fcaveats = self._f(ctx, identity, op) allowed.append(ok) if fcaveats is not None: caveats.extend(fcaveats) return allowed, caveats
Implements Authorizer.authorize by calling f with the given identity for each operation.
Below is the the instruction that describes the task: ### Input: Implements Authorizer.authorize by calling f with the given identity for each operation. ### Response: def authorize(self, ctx, identity, ops): '''Implements Authorizer.authorize by calling f with the given identity for each operation. ''' allowed = [] caveats = [] for op in ops: ok, fcaveats = self._f(ctx, identity, op) allowed.append(ok) if fcaveats is not None: caveats.extend(fcaveats) return allowed, caveats
def scientificformat(value, fmt='%13.9E', sep=' ', sep2=':'): """ :param value: the value to convert into a string :param fmt: the formatting string to use for float values :param sep: separator to use for vector-like values :param sep2: second separator to use for matrix-like values Convert a float or an array into a string by using the scientific notation and a fixed precision (by default 10 decimal digits). For instance: >>> scientificformat(-0E0) '0.000000000E+00' >>> scientificformat(-0.004) '-4.000000000E-03' >>> scientificformat([0.004]) '4.000000000E-03' >>> scientificformat([0.01, 0.02], '%10.6E') '1.000000E-02 2.000000E-02' >>> scientificformat([[0.1, 0.2], [0.3, 0.4]], '%4.1E') '1.0E-01:2.0E-01 3.0E-01:4.0E-01' """ if isinstance(value, numpy.bool_): return '1' if value else '0' elif isinstance(value, bytes): return value.decode('utf8') elif isinstance(value, str): return value elif hasattr(value, '__len__'): return sep.join((scientificformat(f, fmt, sep2) for f in value)) elif isinstance(value, (float, numpy.float64, numpy.float32)): fmt_value = fmt % value if set(fmt_value) <= zeroset: # '-0.0000000E+00' is converted into '0.0000000E+00 fmt_value = fmt_value.replace('-', '') return fmt_value return str(value)
:param value: the value to convert into a string :param fmt: the formatting string to use for float values :param sep: separator to use for vector-like values :param sep2: second separator to use for matrix-like values Convert a float or an array into a string by using the scientific notation and a fixed precision (by default 10 decimal digits). For instance: >>> scientificformat(-0E0) '0.000000000E+00' >>> scientificformat(-0.004) '-4.000000000E-03' >>> scientificformat([0.004]) '4.000000000E-03' >>> scientificformat([0.01, 0.02], '%10.6E') '1.000000E-02 2.000000E-02' >>> scientificformat([[0.1, 0.2], [0.3, 0.4]], '%4.1E') '1.0E-01:2.0E-01 3.0E-01:4.0E-01'
Below is the the instruction that describes the task: ### Input: :param value: the value to convert into a string :param fmt: the formatting string to use for float values :param sep: separator to use for vector-like values :param sep2: second separator to use for matrix-like values Convert a float or an array into a string by using the scientific notation and a fixed precision (by default 10 decimal digits). For instance: >>> scientificformat(-0E0) '0.000000000E+00' >>> scientificformat(-0.004) '-4.000000000E-03' >>> scientificformat([0.004]) '4.000000000E-03' >>> scientificformat([0.01, 0.02], '%10.6E') '1.000000E-02 2.000000E-02' >>> scientificformat([[0.1, 0.2], [0.3, 0.4]], '%4.1E') '1.0E-01:2.0E-01 3.0E-01:4.0E-01' ### Response: def scientificformat(value, fmt='%13.9E', sep=' ', sep2=':'): """ :param value: the value to convert into a string :param fmt: the formatting string to use for float values :param sep: separator to use for vector-like values :param sep2: second separator to use for matrix-like values Convert a float or an array into a string by using the scientific notation and a fixed precision (by default 10 decimal digits). For instance: >>> scientificformat(-0E0) '0.000000000E+00' >>> scientificformat(-0.004) '-4.000000000E-03' >>> scientificformat([0.004]) '4.000000000E-03' >>> scientificformat([0.01, 0.02], '%10.6E') '1.000000E-02 2.000000E-02' >>> scientificformat([[0.1, 0.2], [0.3, 0.4]], '%4.1E') '1.0E-01:2.0E-01 3.0E-01:4.0E-01' """ if isinstance(value, numpy.bool_): return '1' if value else '0' elif isinstance(value, bytes): return value.decode('utf8') elif isinstance(value, str): return value elif hasattr(value, '__len__'): return sep.join((scientificformat(f, fmt, sep2) for f in value)) elif isinstance(value, (float, numpy.float64, numpy.float32)): fmt_value = fmt % value if set(fmt_value) <= zeroset: # '-0.0000000E+00' is converted into '0.0000000E+00 fmt_value = fmt_value.replace('-', '') return fmt_value return str(value)
def SwitchToAlert(): ''' <input value="Test" type="button" onClick="alert('OK')" > ''' try: alert = WebDriverWait(Web.driver, 10).until(lambda driver: driver.switch_to_alert()) return alert except: print("Waring: Timeout at %d seconds.Alert was not found.") return False
<input value="Test" type="button" onClick="alert('OK')" >
Below is the the instruction that describes the task: ### Input: <input value="Test" type="button" onClick="alert('OK')" > ### Response: def SwitchToAlert(): ''' <input value="Test" type="button" onClick="alert('OK')" > ''' try: alert = WebDriverWait(Web.driver, 10).until(lambda driver: driver.switch_to_alert()) return alert except: print("Waring: Timeout at %d seconds.Alert was not found.") return False
def get_fields_in_model(instance): """ Returns the list of fields in the given model instance. Checks whether to use the official _meta API or use the raw data. This method excludes many to many fields. :param instance: The model instance to get the fields for :type instance: Model :return: The list of fields for the given model (instance) :rtype: list """ assert isinstance(instance, Model) # Check if the Django 1.8 _meta API is available use_api = hasattr(instance._meta, 'get_fields') and callable(instance._meta.get_fields) if use_api: return [f for f in instance._meta.get_fields() if track_field(f)] return instance._meta.fields
Returns the list of fields in the given model instance. Checks whether to use the official _meta API or use the raw data. This method excludes many to many fields. :param instance: The model instance to get the fields for :type instance: Model :return: The list of fields for the given model (instance) :rtype: list
Below is the the instruction that describes the task: ### Input: Returns the list of fields in the given model instance. Checks whether to use the official _meta API or use the raw data. This method excludes many to many fields. :param instance: The model instance to get the fields for :type instance: Model :return: The list of fields for the given model (instance) :rtype: list ### Response: def get_fields_in_model(instance): """ Returns the list of fields in the given model instance. Checks whether to use the official _meta API or use the raw data. This method excludes many to many fields. :param instance: The model instance to get the fields for :type instance: Model :return: The list of fields for the given model (instance) :rtype: list """ assert isinstance(instance, Model) # Check if the Django 1.8 _meta API is available use_api = hasattr(instance._meta, 'get_fields') and callable(instance._meta.get_fields) if use_api: return [f for f in instance._meta.get_fields() if track_field(f)] return instance._meta.fields
def delete_value(self, label=None): """Delete the labelled value (or all values) on this Point Raises [IOTException](./Exceptions.m.html#IoticAgent.IOT.Exceptions.IOTException) containing the error if the infrastructure detects a problem Raises [LinkException](../Core/AmqpLink.m.html#IoticAgent.Core.AmqpLink.LinkException) if there is a communications problem between you and the infrastructure `label` (optional) (string) the label for the value you want to delete. If not specified, all values for this point will be removed. """ evt = self._client._request_point_value_delete(self.__lid, self.__pid, self._type, label=label) self._client._wait_and_except_if_failed(evt)
Delete the labelled value (or all values) on this Point Raises [IOTException](./Exceptions.m.html#IoticAgent.IOT.Exceptions.IOTException) containing the error if the infrastructure detects a problem Raises [LinkException](../Core/AmqpLink.m.html#IoticAgent.Core.AmqpLink.LinkException) if there is a communications problem between you and the infrastructure `label` (optional) (string) the label for the value you want to delete. If not specified, all values for this point will be removed.
Below is the the instruction that describes the task: ### Input: Delete the labelled value (or all values) on this Point Raises [IOTException](./Exceptions.m.html#IoticAgent.IOT.Exceptions.IOTException) containing the error if the infrastructure detects a problem Raises [LinkException](../Core/AmqpLink.m.html#IoticAgent.Core.AmqpLink.LinkException) if there is a communications problem between you and the infrastructure `label` (optional) (string) the label for the value you want to delete. If not specified, all values for this point will be removed. ### Response: def delete_value(self, label=None): """Delete the labelled value (or all values) on this Point Raises [IOTException](./Exceptions.m.html#IoticAgent.IOT.Exceptions.IOTException) containing the error if the infrastructure detects a problem Raises [LinkException](../Core/AmqpLink.m.html#IoticAgent.Core.AmqpLink.LinkException) if there is a communications problem between you and the infrastructure `label` (optional) (string) the label for the value you want to delete. If not specified, all values for this point will be removed. """ evt = self._client._request_point_value_delete(self.__lid, self.__pid, self._type, label=label) self._client._wait_and_except_if_failed(evt)
def add_product_error(self, product, error): ''' Adds an error to the given product's field ''' ''' if product in field_names: field = field_names[product] elif isinstance(product, inventory.Product): return else: field = None ''' self.add_error(self.field_name(product), error)
Adds an error to the given product's field
Below is the the instruction that describes the task: ### Input: Adds an error to the given product's field ### Response: def add_product_error(self, product, error): ''' Adds an error to the given product's field ''' ''' if product in field_names: field = field_names[product] elif isinstance(product, inventory.Product): return else: field = None ''' self.add_error(self.field_name(product), error)
def loadBWT(bwtDir, logger=None): ''' Generic load function, this is recommended for anyone wishing to use this code as it will automatically detect compression and assign the appropriate class preferring the decompressed version if both exist. @return - a MultiStringBWT, CompressedBWT, or none if neither can be instantiated ''' if os.path.exists(bwtDir+'/msbwt.npy'): msbwt = MultiStringBWT() msbwt.loadMsbwt(bwtDir, logger) return msbwt elif os.path.exists(bwtDir+'/comp_msbwt.npy'): msbwt = CompressedMSBWT() msbwt.loadMsbwt(bwtDir, logger) return msbwt else: logger.error('Invalid BWT directory.') return None
Generic load function, this is recommended for anyone wishing to use this code as it will automatically detect compression and assign the appropriate class preferring the decompressed version if both exist. @return - a MultiStringBWT, CompressedBWT, or none if neither can be instantiated
Below is the the instruction that describes the task: ### Input: Generic load function, this is recommended for anyone wishing to use this code as it will automatically detect compression and assign the appropriate class preferring the decompressed version if both exist. @return - a MultiStringBWT, CompressedBWT, or none if neither can be instantiated ### Response: def loadBWT(bwtDir, logger=None): ''' Generic load function, this is recommended for anyone wishing to use this code as it will automatically detect compression and assign the appropriate class preferring the decompressed version if both exist. @return - a MultiStringBWT, CompressedBWT, or none if neither can be instantiated ''' if os.path.exists(bwtDir+'/msbwt.npy'): msbwt = MultiStringBWT() msbwt.loadMsbwt(bwtDir, logger) return msbwt elif os.path.exists(bwtDir+'/comp_msbwt.npy'): msbwt = CompressedMSBWT() msbwt.loadMsbwt(bwtDir, logger) return msbwt else: logger.error('Invalid BWT directory.') return None
def ion_balance_proportional(anion_charges, cation_charges, zs, n_anions, n_cations, balance_error, method): '''Helper method for balance_ions for the proportional family of methods. See balance_ions for a description of the methods; parameters are fairly obvious. ''' anion_zs = zs[0:n_anions] cation_zs = zs[n_anions:n_cations+n_anions] anion_balance_error = sum([zi*ci for zi, ci in zip(anion_zs, anion_charges)]) cation_balance_error = sum([zi*ci for zi, ci in zip(cation_zs, cation_charges)]) if method == 'proportional insufficient ions increase': if balance_error < 0: multiplier = -anion_balance_error/cation_balance_error cation_zs = [i*multiplier for i in cation_zs] else: multiplier = -cation_balance_error/anion_balance_error anion_zs = [i*multiplier for i in anion_zs] elif method == 'proportional excess ions decrease': if balance_error < 0: multiplier = -cation_balance_error/anion_balance_error anion_zs = [i*multiplier for i in anion_zs] else: multiplier = -anion_balance_error/cation_balance_error cation_zs = [i*multiplier for i in cation_zs] elif method == 'proportional cation adjustment': multiplier = -anion_balance_error/cation_balance_error cation_zs = [i*multiplier for i in cation_zs] elif method == 'proportional anion adjustment': multiplier = -cation_balance_error/anion_balance_error anion_zs = [i*multiplier for i in anion_zs] else: raise Exception('Allowable methods are %s' %charge_balance_methods) z_water = 1. - sum(anion_zs) - sum(cation_zs) return anion_zs, cation_zs, z_water
Helper method for balance_ions for the proportional family of methods. See balance_ions for a description of the methods; parameters are fairly obvious.
Below is the the instruction that describes the task: ### Input: Helper method for balance_ions for the proportional family of methods. See balance_ions for a description of the methods; parameters are fairly obvious. ### Response: def ion_balance_proportional(anion_charges, cation_charges, zs, n_anions, n_cations, balance_error, method): '''Helper method for balance_ions for the proportional family of methods. See balance_ions for a description of the methods; parameters are fairly obvious. ''' anion_zs = zs[0:n_anions] cation_zs = zs[n_anions:n_cations+n_anions] anion_balance_error = sum([zi*ci for zi, ci in zip(anion_zs, anion_charges)]) cation_balance_error = sum([zi*ci for zi, ci in zip(cation_zs, cation_charges)]) if method == 'proportional insufficient ions increase': if balance_error < 0: multiplier = -anion_balance_error/cation_balance_error cation_zs = [i*multiplier for i in cation_zs] else: multiplier = -cation_balance_error/anion_balance_error anion_zs = [i*multiplier for i in anion_zs] elif method == 'proportional excess ions decrease': if balance_error < 0: multiplier = -cation_balance_error/anion_balance_error anion_zs = [i*multiplier for i in anion_zs] else: multiplier = -anion_balance_error/cation_balance_error cation_zs = [i*multiplier for i in cation_zs] elif method == 'proportional cation adjustment': multiplier = -anion_balance_error/cation_balance_error cation_zs = [i*multiplier for i in cation_zs] elif method == 'proportional anion adjustment': multiplier = -cation_balance_error/anion_balance_error anion_zs = [i*multiplier for i in anion_zs] else: raise Exception('Allowable methods are %s' %charge_balance_methods) z_water = 1. - sum(anion_zs) - sum(cation_zs) return anion_zs, cation_zs, z_water
def serialize(self, obj, level=0, objname=None, topLevelKeysToIgnore=None, toBytes=True): """ Create a string representation of the given object. Examples: :: >>> serialize("str") 'str' >>> serialize([1,2,3,4,5]) '1,2,3,4,5' >>> signing.serlize({1:'a', 2:'b'}) '1:a|2:b' >>> signing.serlize({1:'a', 2:'b', 3:[1,{2:'k'}]}) '1:a|2:b|3:1,2:k' :param obj: the object to serlize :param level: a parameter used internally for recursion to serialize nested data structures :param topLevelKeysToIgnore: the list of top level keys to ignore for serialization :return: a string representation of `obj` """ res = None if not isinstance(obj, acceptableTypes): error("invalid type found {}: {}".format(objname, obj)) elif isinstance(obj, str): res = obj elif isinstance(obj, dict): if level > 0: keys = list(obj.keys()) else: topLevelKeysToIgnore = topLevelKeysToIgnore or [] keys = [k for k in obj.keys() if k not in topLevelKeysToIgnore] keys.sort() strs = [] for k in keys: onm = ".".join([str(objname), str(k)]) if objname else k strs.append( str(k) + ":" + self.serialize(obj[k], level + 1, onm, toBytes=False)) res = "|".join(strs) elif isinstance(obj, Iterable): strs = [] for o in obj: strs.append(self.serialize( o, level + 1, objname, toBytes=False)) res = ",".join(strs) elif obj is None: res = "" else: res = str(obj) # logger.trace("serialized msg {} into {}".format(obj, res)) if not toBytes: return res return res.encode('utf-8')
Create a string representation of the given object. Examples: :: >>> serialize("str") 'str' >>> serialize([1,2,3,4,5]) '1,2,3,4,5' >>> signing.serlize({1:'a', 2:'b'}) '1:a|2:b' >>> signing.serlize({1:'a', 2:'b', 3:[1,{2:'k'}]}) '1:a|2:b|3:1,2:k' :param obj: the object to serlize :param level: a parameter used internally for recursion to serialize nested data structures :param topLevelKeysToIgnore: the list of top level keys to ignore for serialization :return: a string representation of `obj`
Below is the the instruction that describes the task: ### Input: Create a string representation of the given object. Examples: :: >>> serialize("str") 'str' >>> serialize([1,2,3,4,5]) '1,2,3,4,5' >>> signing.serlize({1:'a', 2:'b'}) '1:a|2:b' >>> signing.serlize({1:'a', 2:'b', 3:[1,{2:'k'}]}) '1:a|2:b|3:1,2:k' :param obj: the object to serlize :param level: a parameter used internally for recursion to serialize nested data structures :param topLevelKeysToIgnore: the list of top level keys to ignore for serialization :return: a string representation of `obj` ### Response: def serialize(self, obj, level=0, objname=None, topLevelKeysToIgnore=None, toBytes=True): """ Create a string representation of the given object. Examples: :: >>> serialize("str") 'str' >>> serialize([1,2,3,4,5]) '1,2,3,4,5' >>> signing.serlize({1:'a', 2:'b'}) '1:a|2:b' >>> signing.serlize({1:'a', 2:'b', 3:[1,{2:'k'}]}) '1:a|2:b|3:1,2:k' :param obj: the object to serlize :param level: a parameter used internally for recursion to serialize nested data structures :param topLevelKeysToIgnore: the list of top level keys to ignore for serialization :return: a string representation of `obj` """ res = None if not isinstance(obj, acceptableTypes): error("invalid type found {}: {}".format(objname, obj)) elif isinstance(obj, str): res = obj elif isinstance(obj, dict): if level > 0: keys = list(obj.keys()) else: topLevelKeysToIgnore = topLevelKeysToIgnore or [] keys = [k for k in obj.keys() if k not in topLevelKeysToIgnore] keys.sort() strs = [] for k in keys: onm = ".".join([str(objname), str(k)]) if objname else k strs.append( str(k) + ":" + self.serialize(obj[k], level + 1, onm, toBytes=False)) res = "|".join(strs) elif isinstance(obj, Iterable): strs = [] for o in obj: strs.append(self.serialize( o, level + 1, objname, toBytes=False)) res = ",".join(strs) elif obj is None: res = "" else: res = str(obj) # logger.trace("serialized msg {} into {}".format(obj, res)) if not toBytes: return res return res.encode('utf-8')
def new_mapper(agent): """Creates a mapper object on witch add_mapping() and remove_mapping() can be called. It uses fire-and-forget notifications so it has a very low overhead and latency but a little less guarantees.""" recp = recipient.Broadcast(MappingUpdatesPoster.protocol_id, 'lobby') return agent.initiate_protocol(MappingUpdatesPoster, recp)
Creates a mapper object on witch add_mapping() and remove_mapping() can be called. It uses fire-and-forget notifications so it has a very low overhead and latency but a little less guarantees.
Below is the the instruction that describes the task: ### Input: Creates a mapper object on witch add_mapping() and remove_mapping() can be called. It uses fire-and-forget notifications so it has a very low overhead and latency but a little less guarantees. ### Response: def new_mapper(agent): """Creates a mapper object on witch add_mapping() and remove_mapping() can be called. It uses fire-and-forget notifications so it has a very low overhead and latency but a little less guarantees.""" recp = recipient.Broadcast(MappingUpdatesPoster.protocol_id, 'lobby') return agent.initiate_protocol(MappingUpdatesPoster, recp)
def parse(self, parser): """Main method to render data into the template.""" lineno = next(parser.stream).lineno if parser.stream.skip_if('name:short'): parser.stream.skip(1) short = parser.parse_expression() else: short = nodes.Const(False) result = self.call_method('_commit_hash', [short], [], lineno=lineno) return nodes.Output([result], lineno=lineno)
Main method to render data into the template.
Below is the the instruction that describes the task: ### Input: Main method to render data into the template. ### Response: def parse(self, parser): """Main method to render data into the template.""" lineno = next(parser.stream).lineno if parser.stream.skip_if('name:short'): parser.stream.skip(1) short = parser.parse_expression() else: short = nodes.Const(False) result = self.call_method('_commit_hash', [short], [], lineno=lineno) return nodes.Output([result], lineno=lineno)
def _to_dict(self): ''' Returns a dictionary representation of this object ''' return dict(area= self.area._to_dict(), earthquakes = [q._to_dict() for q in self.earthquakes], title = self.title)
Returns a dictionary representation of this object
Below is the the instruction that describes the task: ### Input: Returns a dictionary representation of this object ### Response: def _to_dict(self): ''' Returns a dictionary representation of this object ''' return dict(area= self.area._to_dict(), earthquakes = [q._to_dict() for q in self.earthquakes], title = self.title)
def install_dap_from_path(path, update=False, update_allpaths=False, first=True, force=False, nodeps=False, reinstall=False, __ui__=''): '''Installs a dap from a given path''' will_uninstall = False dap_obj = dapi.Dap(path) name = dap_obj.meta['package_name'] if name in get_installed_daps(): if not update and not reinstall: raise DapiLocalError( 'DAP {name} is already installed. ' 'Run `da pkg list` to see it\'s location, or use --reinstall to ignore this check.' .format(name=name)) elif not update_allpaths and name in get_installed_daps(_install_path()): will_uninstall = True elif update_allpaths and name in get_installed_daps(): will_uninstall = True if update and update_allpaths: install_locations = [] for pair in get_installed_daps_detailed()[name]: install_locations.append(pair['location']) else: install_locations = [_install_path()] # This should not happen unless someone did it on purpose for location in install_locations: if os.path.isfile(location): raise DapiLocalError( '{i} is a file, not a directory.'.format(i=_install_path())) _dir = tempfile.mkdtemp() old_level = logger.getEffectiveLevel() logger.setLevel(logging.ERROR) ok = dapi.DapChecker.check(dap_obj) logger.setLevel(old_level) if not ok: raise DapiLocalError('The DAP you want to install has errors, not installing.') installed = [] if first: if not force and not _is_supported_here(dap_obj.meta): raise DapiLocalError( '{0} is not supported on this platform (use --force to suppress this check)'. format(name)) deps = set() if 'dependencies' in dap_obj.meta and not nodeps: for dep in dap_obj.meta['dependencies']: dep = _strip_version_from_dependency(dep) if dep not in get_installed_daps(): deps |= _get_all_dependencies_of(dep, force=force) for dep in deps: if dep not in get_installed_daps(): installed += install_dap(dep, first=False, __ui__=__ui__) dap_obj.extract(_dir) if will_uninstall: uninstall_dap(name, allpaths=update_allpaths, __ui__=__ui__) _dapdir = os.path.join(_dir, name + '-' + dap_obj.meta['version']) if not os.path.isdir(_install_path()): os.makedirs(_install_path()) os.mkdir(os.path.join(_dapdir, 'meta')) os.rename(os.path.join(_dapdir, 'meta.yaml'), os.path.join(_dapdir, 'meta', name + '.yaml')) for location in install_locations: for f in glob.glob(_dapdir + '/*'): dst = os.path.join(location, os.path.basename(f)) if os.path.isdir(f): if not os.path.exists(dst): os.mkdir(dst) for src_dir, dirs, files in os.walk(f): dst_dir = src_dir.replace(f, dst) if not os.path.exists(dst_dir): os.mkdir(dst_dir) for file_ in files: src_file = os.path.join(src_dir, file_) dst_file = os.path.join(dst_dir, file_) shutil.copyfile(src_file, dst_file) else: shutil.copyfile(f, dst) try: shutil.rmtree(_dir) except: pass return [name] + installed
Installs a dap from a given path
Below is the the instruction that describes the task: ### Input: Installs a dap from a given path ### Response: def install_dap_from_path(path, update=False, update_allpaths=False, first=True, force=False, nodeps=False, reinstall=False, __ui__=''): '''Installs a dap from a given path''' will_uninstall = False dap_obj = dapi.Dap(path) name = dap_obj.meta['package_name'] if name in get_installed_daps(): if not update and not reinstall: raise DapiLocalError( 'DAP {name} is already installed. ' 'Run `da pkg list` to see it\'s location, or use --reinstall to ignore this check.' .format(name=name)) elif not update_allpaths and name in get_installed_daps(_install_path()): will_uninstall = True elif update_allpaths and name in get_installed_daps(): will_uninstall = True if update and update_allpaths: install_locations = [] for pair in get_installed_daps_detailed()[name]: install_locations.append(pair['location']) else: install_locations = [_install_path()] # This should not happen unless someone did it on purpose for location in install_locations: if os.path.isfile(location): raise DapiLocalError( '{i} is a file, not a directory.'.format(i=_install_path())) _dir = tempfile.mkdtemp() old_level = logger.getEffectiveLevel() logger.setLevel(logging.ERROR) ok = dapi.DapChecker.check(dap_obj) logger.setLevel(old_level) if not ok: raise DapiLocalError('The DAP you want to install has errors, not installing.') installed = [] if first: if not force and not _is_supported_here(dap_obj.meta): raise DapiLocalError( '{0} is not supported on this platform (use --force to suppress this check)'. format(name)) deps = set() if 'dependencies' in dap_obj.meta and not nodeps: for dep in dap_obj.meta['dependencies']: dep = _strip_version_from_dependency(dep) if dep not in get_installed_daps(): deps |= _get_all_dependencies_of(dep, force=force) for dep in deps: if dep not in get_installed_daps(): installed += install_dap(dep, first=False, __ui__=__ui__) dap_obj.extract(_dir) if will_uninstall: uninstall_dap(name, allpaths=update_allpaths, __ui__=__ui__) _dapdir = os.path.join(_dir, name + '-' + dap_obj.meta['version']) if not os.path.isdir(_install_path()): os.makedirs(_install_path()) os.mkdir(os.path.join(_dapdir, 'meta')) os.rename(os.path.join(_dapdir, 'meta.yaml'), os.path.join(_dapdir, 'meta', name + '.yaml')) for location in install_locations: for f in glob.glob(_dapdir + '/*'): dst = os.path.join(location, os.path.basename(f)) if os.path.isdir(f): if not os.path.exists(dst): os.mkdir(dst) for src_dir, dirs, files in os.walk(f): dst_dir = src_dir.replace(f, dst) if not os.path.exists(dst_dir): os.mkdir(dst_dir) for file_ in files: src_file = os.path.join(src_dir, file_) dst_file = os.path.join(dst_dir, file_) shutil.copyfile(src_file, dst_file) else: shutil.copyfile(f, dst) try: shutil.rmtree(_dir) except: pass return [name] + installed
def convert(pinyin, style, strict, default=None, **kwargs): """根据拼音风格把原始拼音转换为不同的格式 :param pinyin: 原始有声调的单个拼音 :type pinyin: unicode :param style: 拼音风格 :param strict: 是否严格遵照《汉语拼音方案》来处理声母和韵母,详见 :ref:`strict` :type strict: bool :param default: 拼音风格对应的实现不存在时返回的默认值 :return: 按照拼音风格进行处理过后的拼音字符串 :rtype: unicode """ if style in _registry: return _registry[style](pinyin, strict=strict, **kwargs) return default
根据拼音风格把原始拼音转换为不同的格式 :param pinyin: 原始有声调的单个拼音 :type pinyin: unicode :param style: 拼音风格 :param strict: 是否严格遵照《汉语拼音方案》来处理声母和韵母,详见 :ref:`strict` :type strict: bool :param default: 拼音风格对应的实现不存在时返回的默认值 :return: 按照拼音风格进行处理过后的拼音字符串 :rtype: unicode
Below is the the instruction that describes the task: ### Input: 根据拼音风格把原始拼音转换为不同的格式 :param pinyin: 原始有声调的单个拼音 :type pinyin: unicode :param style: 拼音风格 :param strict: 是否严格遵照《汉语拼音方案》来处理声母和韵母,详见 :ref:`strict` :type strict: bool :param default: 拼音风格对应的实现不存在时返回的默认值 :return: 按照拼音风格进行处理过后的拼音字符串 :rtype: unicode ### Response: def convert(pinyin, style, strict, default=None, **kwargs): """根据拼音风格把原始拼音转换为不同的格式 :param pinyin: 原始有声调的单个拼音 :type pinyin: unicode :param style: 拼音风格 :param strict: 是否严格遵照《汉语拼音方案》来处理声母和韵母,详见 :ref:`strict` :type strict: bool :param default: 拼音风格对应的实现不存在时返回的默认值 :return: 按照拼音风格进行处理过后的拼音字符串 :rtype: unicode """ if style in _registry: return _registry[style](pinyin, strict=strict, **kwargs) return default
def btc_tx_serialize(_txobj): """ Given a transaction dict returned by btc_tx_deserialize, convert it back into a hex-encoded byte string. Derived from code written by Vitalik Buterin in pybitcointools (https://github.com/vbuterin/pybitcointools) """ # output buffer o = [] txobj = None if encoding.json_is_base(_txobj, 16): # txobj is built from hex strings already. deserialize them txobj = encoding.json_changebase(_txobj, lambda x: binascii.unhexlify(x)) else: txobj = copy.deepcopy(_txobj) # version o.append(encoding.encode(txobj["version"], 256, 4)[::-1]) # do we have any witness scripts? have_witness = False for inp in txobj['ins']: if inp.has_key('witness_script') and len(inp['witness_script']) > 0: have_witness = True break if have_witness: # add segwit marker o.append('\x00\x01') # number of inputs o.append(encoding.num_to_var_int(len(txobj["ins"]))) # all inputs for inp in txobj["ins"]: # input tx hash o.append(inp["outpoint"]["hash"][::-1]) # input tx outpoint o.append(encoding.encode(inp["outpoint"]["index"], 256, 4)[::-1]) # input scriptsig script = inp.get('script') if not script: script = bytes() scriptsig = encoding.num_to_var_int(len(script)) + script o.append(scriptsig) # sequence o.append(encoding.encode(inp.get("sequence", UINT_MAX - 1), 256, 4)[::-1]) # number of outputs o.append(encoding.num_to_var_int(len(txobj["outs"]))) # all outputs for out in txobj["outs"]: # value o.append(encoding.encode(out["value"], 256, 8)[::-1]) # scriptPubKey scriptpubkey = encoding.num_to_var_int(len(out['script'])) + out['script'] o.append(scriptpubkey) # add witnesses if have_witness: for inp in txobj['ins']: witness_script = inp.get('witness_script') if not witness_script: witness_script = '\x00' o.append(witness_script) # locktime o.append(encoding.encode(txobj["locktime"], 256, 4)[::-1]) # full string ret = ''.join( encoding.json_changebase(o, lambda x: encoding.safe_hexlify(x)) ) return ret
Given a transaction dict returned by btc_tx_deserialize, convert it back into a hex-encoded byte string. Derived from code written by Vitalik Buterin in pybitcointools (https://github.com/vbuterin/pybitcointools)
Below is the the instruction that describes the task: ### Input: Given a transaction dict returned by btc_tx_deserialize, convert it back into a hex-encoded byte string. Derived from code written by Vitalik Buterin in pybitcointools (https://github.com/vbuterin/pybitcointools) ### Response: def btc_tx_serialize(_txobj): """ Given a transaction dict returned by btc_tx_deserialize, convert it back into a hex-encoded byte string. Derived from code written by Vitalik Buterin in pybitcointools (https://github.com/vbuterin/pybitcointools) """ # output buffer o = [] txobj = None if encoding.json_is_base(_txobj, 16): # txobj is built from hex strings already. deserialize them txobj = encoding.json_changebase(_txobj, lambda x: binascii.unhexlify(x)) else: txobj = copy.deepcopy(_txobj) # version o.append(encoding.encode(txobj["version"], 256, 4)[::-1]) # do we have any witness scripts? have_witness = False for inp in txobj['ins']: if inp.has_key('witness_script') and len(inp['witness_script']) > 0: have_witness = True break if have_witness: # add segwit marker o.append('\x00\x01') # number of inputs o.append(encoding.num_to_var_int(len(txobj["ins"]))) # all inputs for inp in txobj["ins"]: # input tx hash o.append(inp["outpoint"]["hash"][::-1]) # input tx outpoint o.append(encoding.encode(inp["outpoint"]["index"], 256, 4)[::-1]) # input scriptsig script = inp.get('script') if not script: script = bytes() scriptsig = encoding.num_to_var_int(len(script)) + script o.append(scriptsig) # sequence o.append(encoding.encode(inp.get("sequence", UINT_MAX - 1), 256, 4)[::-1]) # number of outputs o.append(encoding.num_to_var_int(len(txobj["outs"]))) # all outputs for out in txobj["outs"]: # value o.append(encoding.encode(out["value"], 256, 8)[::-1]) # scriptPubKey scriptpubkey = encoding.num_to_var_int(len(out['script'])) + out['script'] o.append(scriptpubkey) # add witnesses if have_witness: for inp in txobj['ins']: witness_script = inp.get('witness_script') if not witness_script: witness_script = '\x00' o.append(witness_script) # locktime o.append(encoding.encode(txobj["locktime"], 256, 4)[::-1]) # full string ret = ''.join( encoding.json_changebase(o, lambda x: encoding.safe_hexlify(x)) ) return ret
def _connect(self): """Connect to Squid Proxy Manager interface.""" if sys.version_info[:2] < (2,6): self._conn = httplib.HTTPConnection(self._host, self._port) else: self._conn = httplib.HTTPConnection(self._host, self._port, False, defaultTimeout)
Connect to Squid Proxy Manager interface.
Below is the the instruction that describes the task: ### Input: Connect to Squid Proxy Manager interface. ### Response: def _connect(self): """Connect to Squid Proxy Manager interface.""" if sys.version_info[:2] < (2,6): self._conn = httplib.HTTPConnection(self._host, self._port) else: self._conn = httplib.HTTPConnection(self._host, self._port, False, defaultTimeout)
def find_invalid_chars(self, text, context_size=20): """Find invalid characters in text and store information about the findings. Parameters ---------- context_size: int How many characters to return as the context. """ result = defaultdict(list) for idx, char in enumerate(text): if char not in self.alphabet: start = max(0, idx-context_size) end = min(len(text), idx+context_size) result[char].append(text[start:end]) return result
Find invalid characters in text and store information about the findings. Parameters ---------- context_size: int How many characters to return as the context.
Below is the the instruction that describes the task: ### Input: Find invalid characters in text and store information about the findings. Parameters ---------- context_size: int How many characters to return as the context. ### Response: def find_invalid_chars(self, text, context_size=20): """Find invalid characters in text and store information about the findings. Parameters ---------- context_size: int How many characters to return as the context. """ result = defaultdict(list) for idx, char in enumerate(text): if char not in self.alphabet: start = max(0, idx-context_size) end = min(len(text), idx+context_size) result[char].append(text[start:end]) return result
def function(self, x, y, amp, R_sersic, Re, n_sersic, gamma, e1, e2, center_x=0, center_y=0, alpha=3.): """ returns Core-Sersic function """ phi_G, q = param_util.ellipticity2phi_q(e1, e2) Rb = R_sersic x_shift = x - center_x y_shift = y - center_y cos_phi = np.cos(phi_G) sin_phi = np.sin(phi_G) xt1 = cos_phi*x_shift+sin_phi*y_shift xt2 = -sin_phi*x_shift+cos_phi*y_shift xt2difq2 = xt2/(q*q) R_ = np.sqrt(xt1*xt1+xt2*xt2difq2) #R_ = R_.astype(np.float32) if isinstance(R_, int) or isinstance(R_, float): R_ = max(self._smoothing, R_) else: R_[R_ < self._smoothing] = self._smoothing if isinstance(R_, int) or isinstance(R_, float): R = max(self._smoothing, R_) else: R=np.empty_like(R_) _R = R_[R_ > self._smoothing] #in the SIS regime R[R_ <= self._smoothing] = self._smoothing R[R_ > self._smoothing] = _R k, bn = self.k_bn(n_sersic, Re) result = amp * (1 + (Rb / R) ** alpha) ** (gamma / alpha) * np.exp(-bn * (((R ** alpha + Rb ** alpha) / Re ** alpha) ** (1. / (alpha * n_sersic)) - 1.)) return np.nan_to_num(result)
returns Core-Sersic function
Below is the the instruction that describes the task: ### Input: returns Core-Sersic function ### Response: def function(self, x, y, amp, R_sersic, Re, n_sersic, gamma, e1, e2, center_x=0, center_y=0, alpha=3.): """ returns Core-Sersic function """ phi_G, q = param_util.ellipticity2phi_q(e1, e2) Rb = R_sersic x_shift = x - center_x y_shift = y - center_y cos_phi = np.cos(phi_G) sin_phi = np.sin(phi_G) xt1 = cos_phi*x_shift+sin_phi*y_shift xt2 = -sin_phi*x_shift+cos_phi*y_shift xt2difq2 = xt2/(q*q) R_ = np.sqrt(xt1*xt1+xt2*xt2difq2) #R_ = R_.astype(np.float32) if isinstance(R_, int) or isinstance(R_, float): R_ = max(self._smoothing, R_) else: R_[R_ < self._smoothing] = self._smoothing if isinstance(R_, int) or isinstance(R_, float): R = max(self._smoothing, R_) else: R=np.empty_like(R_) _R = R_[R_ > self._smoothing] #in the SIS regime R[R_ <= self._smoothing] = self._smoothing R[R_ > self._smoothing] = _R k, bn = self.k_bn(n_sersic, Re) result = amp * (1 + (Rb / R) ** alpha) ** (gamma / alpha) * np.exp(-bn * (((R ** alpha + Rb ** alpha) / Re ** alpha) ** (1. / (alpha * n_sersic)) - 1.)) return np.nan_to_num(result)
def _wait_for_file(cls, filename, timeout=FAIL_WAIT_SEC, want_content=True): """Wait up to timeout seconds for filename to appear with a non-zero size or raise Timeout().""" def file_waiter(): return os.path.exists(filename) and (not want_content or os.path.getsize(filename)) action_msg = 'file {} to appear'.format(filename) return cls._deadline_until(file_waiter, action_msg, timeout=timeout)
Wait up to timeout seconds for filename to appear with a non-zero size or raise Timeout().
Below is the the instruction that describes the task: ### Input: Wait up to timeout seconds for filename to appear with a non-zero size or raise Timeout(). ### Response: def _wait_for_file(cls, filename, timeout=FAIL_WAIT_SEC, want_content=True): """Wait up to timeout seconds for filename to appear with a non-zero size or raise Timeout().""" def file_waiter(): return os.path.exists(filename) and (not want_content or os.path.getsize(filename)) action_msg = 'file {} to appear'.format(filename) return cls._deadline_until(file_waiter, action_msg, timeout=timeout)
def resetn(self): """ reset a core. After a call to this function, the core is running """ #Regular reset will kick NRF out of DBG mode logging.debug("target_nrf51.reset: enable reset pin") self.write_memory(RESET, RESET_ENABLE) #reset logging.debug("target_nrf51.reset: trigger nRST pin") self.reset()
reset a core. After a call to this function, the core is running
Below is the the instruction that describes the task: ### Input: reset a core. After a call to this function, the core is running ### Response: def resetn(self): """ reset a core. After a call to this function, the core is running """ #Regular reset will kick NRF out of DBG mode logging.debug("target_nrf51.reset: enable reset pin") self.write_memory(RESET, RESET_ENABLE) #reset logging.debug("target_nrf51.reset: trigger nRST pin") self.reset()
def det4D(m): ''' det4D(array) yields the determinate of the given matrix array, which may have more than 2 dimensions, in which case the later dimensions are multiplied and added point-wise. ''' # I just solved this in Mathematica, copy-pasted, and replaced the string '] m' with ']*m': # Mathematica code: Det@Table[m[i][j], {i, 0, 3}, {j, 0, 3}] return (m[0][3]*m[1][2]*m[2][1]*m[3][0] - m[0][2]*m[1][3]*m[2][1]*m[3][0] - m[0][3]*m[1][1]*m[2][2]*m[3][0] + m[0][1]*m[1][3]*m[2][2]*m[3][0] + m[0][2]*m[1][1]*m[2][3]*m[3][0] - m[0][1]*m[1][2]*m[2][3]*m[3][0] - m[0][3]*m[1][2]*m[2][0]*m[3][1] + m[0][2]*m[1][3]*m[2][0]*m[3][1] + m[0][3]*m[1][0]*m[2][2]*m[3][1] - m[0][0]*m[1][3]*m[2][2]*m[3][1] - m[0][2]*m[1][0]*m[2][3]*m[3][1] + m[0][0]*m[1][2]*m[2][3]*m[3][1] + m[0][3]*m[1][1]*m[2][0]*m[3][2] - m[0][1]*m[1][3]*m[2][0]*m[3][2] - m[0][3]*m[1][0]*m[2][1]*m[3][2] + m[0][0]*m[1][3]*m[2][1]*m[3][2] + m[0][1]*m[1][0]*m[2][3]*m[3][2] - m[0][0]*m[1][1]*m[2][3]*m[3][2] - m[0][2]*m[1][1]*m[2][0]*m[3][3] + m[0][1]*m[1][2]*m[2][0]*m[3][3] + m[0][2]*m[1][0]*m[2][1]*m[3][3] - m[0][0]*m[1][2]*m[2][1]*m[3][3] - m[0][1]*m[1][0]*m[2][2]*m[3][3] + m[0][0]*m[1][1]*m[2][2]*m[3][3])
det4D(array) yields the determinate of the given matrix array, which may have more than 2 dimensions, in which case the later dimensions are multiplied and added point-wise.
Below is the the instruction that describes the task: ### Input: det4D(array) yields the determinate of the given matrix array, which may have more than 2 dimensions, in which case the later dimensions are multiplied and added point-wise. ### Response: def det4D(m): ''' det4D(array) yields the determinate of the given matrix array, which may have more than 2 dimensions, in which case the later dimensions are multiplied and added point-wise. ''' # I just solved this in Mathematica, copy-pasted, and replaced the string '] m' with ']*m': # Mathematica code: Det@Table[m[i][j], {i, 0, 3}, {j, 0, 3}] return (m[0][3]*m[1][2]*m[2][1]*m[3][0] - m[0][2]*m[1][3]*m[2][1]*m[3][0] - m[0][3]*m[1][1]*m[2][2]*m[3][0] + m[0][1]*m[1][3]*m[2][2]*m[3][0] + m[0][2]*m[1][1]*m[2][3]*m[3][0] - m[0][1]*m[1][2]*m[2][3]*m[3][0] - m[0][3]*m[1][2]*m[2][0]*m[3][1] + m[0][2]*m[1][3]*m[2][0]*m[3][1] + m[0][3]*m[1][0]*m[2][2]*m[3][1] - m[0][0]*m[1][3]*m[2][2]*m[3][1] - m[0][2]*m[1][0]*m[2][3]*m[3][1] + m[0][0]*m[1][2]*m[2][3]*m[3][1] + m[0][3]*m[1][1]*m[2][0]*m[3][2] - m[0][1]*m[1][3]*m[2][0]*m[3][2] - m[0][3]*m[1][0]*m[2][1]*m[3][2] + m[0][0]*m[1][3]*m[2][1]*m[3][2] + m[0][1]*m[1][0]*m[2][3]*m[3][2] - m[0][0]*m[1][1]*m[2][3]*m[3][2] - m[0][2]*m[1][1]*m[2][0]*m[3][3] + m[0][1]*m[1][2]*m[2][0]*m[3][3] + m[0][2]*m[1][0]*m[2][1]*m[3][3] - m[0][0]*m[1][2]*m[2][1]*m[3][3] - m[0][1]*m[1][0]*m[2][2]*m[3][3] + m[0][0]*m[1][1]*m[2][2]*m[3][3])
def start_service(self, stack, service): """启动服务 启动指定名称服务的所有容器。 Args: - stack: 服务所属的服务组名称 - service: 服务名 Returns: 返回一个tuple对象,其格式为(<result>, <ResponseInfo>) - result 成功返回空dict{},失败返回{"error": "<errMsg string>"} - ResponseInfo 请求的Response信息 """ url = '{0}/v3/stacks/{1}/services/{2}/start'.format(self.host, stack, service) return self.__post(url)
启动服务 启动指定名称服务的所有容器。 Args: - stack: 服务所属的服务组名称 - service: 服务名 Returns: 返回一个tuple对象,其格式为(<result>, <ResponseInfo>) - result 成功返回空dict{},失败返回{"error": "<errMsg string>"} - ResponseInfo 请求的Response信息
Below is the the instruction that describes the task: ### Input: 启动服务 启动指定名称服务的所有容器。 Args: - stack: 服务所属的服务组名称 - service: 服务名 Returns: 返回一个tuple对象,其格式为(<result>, <ResponseInfo>) - result 成功返回空dict{},失败返回{"error": "<errMsg string>"} - ResponseInfo 请求的Response信息 ### Response: def start_service(self, stack, service): """启动服务 启动指定名称服务的所有容器。 Args: - stack: 服务所属的服务组名称 - service: 服务名 Returns: 返回一个tuple对象,其格式为(<result>, <ResponseInfo>) - result 成功返回空dict{},失败返回{"error": "<errMsg string>"} - ResponseInfo 请求的Response信息 """ url = '{0}/v3/stacks/{1}/services/{2}/start'.format(self.host, stack, service) return self.__post(url)
def _rgb_triangle(ax, r_label, g_label, b_label, loc): """ Draw an RGB triangle legend on the desired axis """ if not loc in range(1, 11): loc = 2 from mpl_toolkits.axes_grid1.inset_locator import inset_axes inset_ax = inset_axes(ax, width=1, height=1, loc=loc) mesh = 35 x = [] y = [] color = [] for r in range(0, mesh): for g in range(0, mesh): for b in range(0, mesh): if not (r == 0 and b == 0 and g == 0): r1 = r / (r + g + b) g1 = g / (r + g + b) b1 = b / (r + g + b) x.append(0.33 * (2. * g1 + r1) / (r1 + b1 + g1)) y.append(0.33 * np.sqrt(3) * r1 / (r1 + b1 + g1)) rc = math.sqrt(r ** 2 / (r ** 2 + g ** 2 + b ** 2)) gc = math.sqrt(g ** 2 / (r ** 2 + g ** 2 + b ** 2)) bc = math.sqrt(b ** 2 / (r ** 2 + g ** 2 + b ** 2)) color.append([rc, gc, bc]) # x = [n + 0.25 for n in x] # nudge x coordinates # y = [n + (max_y - 1) for n in y] # shift y coordinates to top # plot the triangle inset_ax.scatter(x, y, s=7, marker='.', edgecolor=color) inset_ax.set_xlim([-0.35, 1.00]) inset_ax.set_ylim([-0.35, 1.00]) # add the labels inset_ax.text(0.70, -0.2, g_label, fontsize=13, family='Times New Roman', color=(0, 0, 0), horizontalalignment='left') inset_ax.text(0.325, 0.70, r_label, fontsize=13, family='Times New Roman', color=(0, 0, 0), horizontalalignment='center') inset_ax.text(-0.05, -0.2, b_label, fontsize=13, family='Times New Roman', color=(0, 0, 0), horizontalalignment='right') inset_ax.get_xaxis().set_visible(False) inset_ax.get_yaxis().set_visible(False)
Draw an RGB triangle legend on the desired axis
Below is the the instruction that describes the task: ### Input: Draw an RGB triangle legend on the desired axis ### Response: def _rgb_triangle(ax, r_label, g_label, b_label, loc): """ Draw an RGB triangle legend on the desired axis """ if not loc in range(1, 11): loc = 2 from mpl_toolkits.axes_grid1.inset_locator import inset_axes inset_ax = inset_axes(ax, width=1, height=1, loc=loc) mesh = 35 x = [] y = [] color = [] for r in range(0, mesh): for g in range(0, mesh): for b in range(0, mesh): if not (r == 0 and b == 0 and g == 0): r1 = r / (r + g + b) g1 = g / (r + g + b) b1 = b / (r + g + b) x.append(0.33 * (2. * g1 + r1) / (r1 + b1 + g1)) y.append(0.33 * np.sqrt(3) * r1 / (r1 + b1 + g1)) rc = math.sqrt(r ** 2 / (r ** 2 + g ** 2 + b ** 2)) gc = math.sqrt(g ** 2 / (r ** 2 + g ** 2 + b ** 2)) bc = math.sqrt(b ** 2 / (r ** 2 + g ** 2 + b ** 2)) color.append([rc, gc, bc]) # x = [n + 0.25 for n in x] # nudge x coordinates # y = [n + (max_y - 1) for n in y] # shift y coordinates to top # plot the triangle inset_ax.scatter(x, y, s=7, marker='.', edgecolor=color) inset_ax.set_xlim([-0.35, 1.00]) inset_ax.set_ylim([-0.35, 1.00]) # add the labels inset_ax.text(0.70, -0.2, g_label, fontsize=13, family='Times New Roman', color=(0, 0, 0), horizontalalignment='left') inset_ax.text(0.325, 0.70, r_label, fontsize=13, family='Times New Roman', color=(0, 0, 0), horizontalalignment='center') inset_ax.text(-0.05, -0.2, b_label, fontsize=13, family='Times New Roman', color=(0, 0, 0), horizontalalignment='right') inset_ax.get_xaxis().set_visible(False) inset_ax.get_yaxis().set_visible(False)
def _tryMatch(self, textToMatchObject): """Try to find themselves in the text. Returns (count, matchedRule) or (None, None) if doesn't match """ # andreikop: This check is not described in kate docs, and I haven't found it in the code if not textToMatchObject.isWordStart: return None index = self._tryMatchText(textToMatchObject.text) if index is None: return None if textToMatchObject.currentColumnIndex + index < len(textToMatchObject.wholeLineText): newTextToMatchObject = TextToMatchObject(textToMatchObject.currentColumnIndex + index, textToMatchObject.wholeLineText, self.parentContext.parser.deliminatorSet, textToMatchObject.contextData) for rule in self.childRules: ruleTryMatchResult = rule.tryMatch(newTextToMatchObject) if ruleTryMatchResult is not None: index += ruleTryMatchResult.length break # child rule context and attribute ignored return RuleTryMatchResult(self, index)
Try to find themselves in the text. Returns (count, matchedRule) or (None, None) if doesn't match
Below is the the instruction that describes the task: ### Input: Try to find themselves in the text. Returns (count, matchedRule) or (None, None) if doesn't match ### Response: def _tryMatch(self, textToMatchObject): """Try to find themselves in the text. Returns (count, matchedRule) or (None, None) if doesn't match """ # andreikop: This check is not described in kate docs, and I haven't found it in the code if not textToMatchObject.isWordStart: return None index = self._tryMatchText(textToMatchObject.text) if index is None: return None if textToMatchObject.currentColumnIndex + index < len(textToMatchObject.wholeLineText): newTextToMatchObject = TextToMatchObject(textToMatchObject.currentColumnIndex + index, textToMatchObject.wholeLineText, self.parentContext.parser.deliminatorSet, textToMatchObject.contextData) for rule in self.childRules: ruleTryMatchResult = rule.tryMatch(newTextToMatchObject) if ruleTryMatchResult is not None: index += ruleTryMatchResult.length break # child rule context and attribute ignored return RuleTryMatchResult(self, index)
def enter_command_mode(self): """ Go into command mode. """ self.application.layout.focus(self.command_buffer) self.application.vi_state.input_mode = InputMode.INSERT self.previewer.save()
Go into command mode.
Below is the the instruction that describes the task: ### Input: Go into command mode. ### Response: def enter_command_mode(self): """ Go into command mode. """ self.application.layout.focus(self.command_buffer) self.application.vi_state.input_mode = InputMode.INSERT self.previewer.save()
def new(cls, ns_path, script, campaign_dir, runner_type='Auto', overwrite=False, optimized=True, check_repo=True): """ Create a new campaign from an ns-3 installation and a campaign directory. This method will create a DatabaseManager, which will install a database in the specified campaign_dir. If a database is already available at the ns_path described in the specified campaign_dir and its configuration matches config, this instance is used instead. If the overwrite argument is set to True instead, the specified directory is wiped and a new campaign is created in its place. Furthermore, this method will initialize a SimulationRunner, of type specified by the runner_type parameter, which will be locked on the ns-3 installation at ns_path and set up to run the desired script. Finally, note that creation of a campaign requires a git repository to be initialized at the specified ns_path. This will allow SEM to save the commit at which the simulations are run, enforce reproducibility and avoid mixing results coming from different versions of ns-3 and its libraries. Args: ns_path (str): path to the ns-3 installation to employ in this campaign. script (str): ns-3 script that will be executed to run simulations. campaign_dir (str): path to the directory in which to save the simulation campaign database. runner_type (str): implementation of the SimulationRunner to use. Value can be: SimulationRunner (for running sequential simulations locally), ParallelRunner (for running parallel simulations locally), GridRunner (for running simulations using a DRMAA-compatible parallel task scheduler). Use Auto to automatically pick the best runner. overwrite (bool): whether to overwrite already existing campaign_dir folders. This deletes the directory if and only if it only contains files that were detected to be created by sem. optimized (bool): whether to configure the runner to employ an optimized ns-3 build. """ # Convert paths to be absolute ns_path = os.path.abspath(ns_path) campaign_dir = os.path.abspath(campaign_dir) # Verify if the specified campaign is already available if Path(campaign_dir).exists() and not overwrite: # Try loading manager = CampaignManager.load(campaign_dir, ns_path, runner_type=runner_type, optimized=optimized, check_repo=check_repo) if manager.db.get_script() == script: return manager else: del manager # Initialize runner runner = CampaignManager.create_runner(ns_path, script, runner_type=runner_type, optimized=optimized) # Get list of parameters to save in the DB params = runner.get_available_parameters() # Get current commit commit = "" if check_repo: from git import Repo, exc commit = Repo(ns_path).head.commit.hexsha # Create a database manager from the configuration db = DatabaseManager.new(script=script, params=params, commit=commit, campaign_dir=campaign_dir, overwrite=overwrite) return cls(db, runner, check_repo)
Create a new campaign from an ns-3 installation and a campaign directory. This method will create a DatabaseManager, which will install a database in the specified campaign_dir. If a database is already available at the ns_path described in the specified campaign_dir and its configuration matches config, this instance is used instead. If the overwrite argument is set to True instead, the specified directory is wiped and a new campaign is created in its place. Furthermore, this method will initialize a SimulationRunner, of type specified by the runner_type parameter, which will be locked on the ns-3 installation at ns_path and set up to run the desired script. Finally, note that creation of a campaign requires a git repository to be initialized at the specified ns_path. This will allow SEM to save the commit at which the simulations are run, enforce reproducibility and avoid mixing results coming from different versions of ns-3 and its libraries. Args: ns_path (str): path to the ns-3 installation to employ in this campaign. script (str): ns-3 script that will be executed to run simulations. campaign_dir (str): path to the directory in which to save the simulation campaign database. runner_type (str): implementation of the SimulationRunner to use. Value can be: SimulationRunner (for running sequential simulations locally), ParallelRunner (for running parallel simulations locally), GridRunner (for running simulations using a DRMAA-compatible parallel task scheduler). Use Auto to automatically pick the best runner. overwrite (bool): whether to overwrite already existing campaign_dir folders. This deletes the directory if and only if it only contains files that were detected to be created by sem. optimized (bool): whether to configure the runner to employ an optimized ns-3 build.
Below is the the instruction that describes the task: ### Input: Create a new campaign from an ns-3 installation and a campaign directory. This method will create a DatabaseManager, which will install a database in the specified campaign_dir. If a database is already available at the ns_path described in the specified campaign_dir and its configuration matches config, this instance is used instead. If the overwrite argument is set to True instead, the specified directory is wiped and a new campaign is created in its place. Furthermore, this method will initialize a SimulationRunner, of type specified by the runner_type parameter, which will be locked on the ns-3 installation at ns_path and set up to run the desired script. Finally, note that creation of a campaign requires a git repository to be initialized at the specified ns_path. This will allow SEM to save the commit at which the simulations are run, enforce reproducibility and avoid mixing results coming from different versions of ns-3 and its libraries. Args: ns_path (str): path to the ns-3 installation to employ in this campaign. script (str): ns-3 script that will be executed to run simulations. campaign_dir (str): path to the directory in which to save the simulation campaign database. runner_type (str): implementation of the SimulationRunner to use. Value can be: SimulationRunner (for running sequential simulations locally), ParallelRunner (for running parallel simulations locally), GridRunner (for running simulations using a DRMAA-compatible parallel task scheduler). Use Auto to automatically pick the best runner. overwrite (bool): whether to overwrite already existing campaign_dir folders. This deletes the directory if and only if it only contains files that were detected to be created by sem. optimized (bool): whether to configure the runner to employ an optimized ns-3 build. ### Response: def new(cls, ns_path, script, campaign_dir, runner_type='Auto', overwrite=False, optimized=True, check_repo=True): """ Create a new campaign from an ns-3 installation and a campaign directory. This method will create a DatabaseManager, which will install a database in the specified campaign_dir. If a database is already available at the ns_path described in the specified campaign_dir and its configuration matches config, this instance is used instead. If the overwrite argument is set to True instead, the specified directory is wiped and a new campaign is created in its place. Furthermore, this method will initialize a SimulationRunner, of type specified by the runner_type parameter, which will be locked on the ns-3 installation at ns_path and set up to run the desired script. Finally, note that creation of a campaign requires a git repository to be initialized at the specified ns_path. This will allow SEM to save the commit at which the simulations are run, enforce reproducibility and avoid mixing results coming from different versions of ns-3 and its libraries. Args: ns_path (str): path to the ns-3 installation to employ in this campaign. script (str): ns-3 script that will be executed to run simulations. campaign_dir (str): path to the directory in which to save the simulation campaign database. runner_type (str): implementation of the SimulationRunner to use. Value can be: SimulationRunner (for running sequential simulations locally), ParallelRunner (for running parallel simulations locally), GridRunner (for running simulations using a DRMAA-compatible parallel task scheduler). Use Auto to automatically pick the best runner. overwrite (bool): whether to overwrite already existing campaign_dir folders. This deletes the directory if and only if it only contains files that were detected to be created by sem. optimized (bool): whether to configure the runner to employ an optimized ns-3 build. """ # Convert paths to be absolute ns_path = os.path.abspath(ns_path) campaign_dir = os.path.abspath(campaign_dir) # Verify if the specified campaign is already available if Path(campaign_dir).exists() and not overwrite: # Try loading manager = CampaignManager.load(campaign_dir, ns_path, runner_type=runner_type, optimized=optimized, check_repo=check_repo) if manager.db.get_script() == script: return manager else: del manager # Initialize runner runner = CampaignManager.create_runner(ns_path, script, runner_type=runner_type, optimized=optimized) # Get list of parameters to save in the DB params = runner.get_available_parameters() # Get current commit commit = "" if check_repo: from git import Repo, exc commit = Repo(ns_path).head.commit.hexsha # Create a database manager from the configuration db = DatabaseManager.new(script=script, params=params, commit=commit, campaign_dir=campaign_dir, overwrite=overwrite) return cls(db, runner, check_repo)
def teardown_app_request(self, func: Callable) -> Callable: """Add a teardown request function to the app. This is designed to be used as a decorator, and has the same arguments as :meth:`~quart.Quart.teardown_request`. It applies to all requests to the app this blueprint is registered on. An example usage, .. code-block:: python blueprint = Blueprint(__name__) @blueprint.teardown_app_request def teardown(): ... """ self.record_once(lambda state: state.app.teardown_request(func)) return func
Add a teardown request function to the app. This is designed to be used as a decorator, and has the same arguments as :meth:`~quart.Quart.teardown_request`. It applies to all requests to the app this blueprint is registered on. An example usage, .. code-block:: python blueprint = Blueprint(__name__) @blueprint.teardown_app_request def teardown(): ...
Below is the the instruction that describes the task: ### Input: Add a teardown request function to the app. This is designed to be used as a decorator, and has the same arguments as :meth:`~quart.Quart.teardown_request`. It applies to all requests to the app this blueprint is registered on. An example usage, .. code-block:: python blueprint = Blueprint(__name__) @blueprint.teardown_app_request def teardown(): ... ### Response: def teardown_app_request(self, func: Callable) -> Callable: """Add a teardown request function to the app. This is designed to be used as a decorator, and has the same arguments as :meth:`~quart.Quart.teardown_request`. It applies to all requests to the app this blueprint is registered on. An example usage, .. code-block:: python blueprint = Blueprint(__name__) @blueprint.teardown_app_request def teardown(): ... """ self.record_once(lambda state: state.app.teardown_request(func)) return func
def to_dict(x, depth, exclude_keys=set(), depth_threshold=8): """Transform a nested object/dict/list into a regular dict json.dump(s) and pickle don't like to un/serialize regular Python objects so this function should handle arbitrarily nested objects to be serialized to regular string, float, int, bool, None values. This is a recursive function so by default it will exit at a certain depth (depth_threshold=8). Args: x (object): Some object to dict-ify unless x is a scalar/literal then return x as is depth (int): Starting depth must be 0 (cannot supply default value due to weird Pythonisms) exclude_keys (set): Keys to avoid adding to the output dict depth_threshold (int): object/dict nesting depth to stop at Returns: dict: dict with only scalar/literal leaf values """ if x is None or isinstance(x, (str, int, float, bool)): return x if isinstance(x, np.int_): return int(x) if isinstance(x, np.int64): return int(x) if isinstance(x, np.float_): return float(x) if isinstance(x, np.float64): return float(x) if isinstance(x, np.bool_): return bool(x) if depth + 1 > depth_threshold: return {} if isinstance(x, list): out = [] for v in x: tmp = to_dict(v, depth + 1, exclude_keys, depth_threshold) if tmp == {}: continue out.append(tmp) return out out = {} if isinstance(x, dict): for k, v in x.items(): if k in exclude_keys: continue if not isinstance(k, (str,)): k = str(k) tmp = to_dict(v, depth + 1, exclude_keys, depth_threshold) if tmp == {}: continue out[k] = tmp return out for attr in listattrs(x): if attr in exclude_keys: continue v = getattr(x, attr) tmp = to_dict(v, depth + 1, exclude_keys, depth_threshold) if tmp == {}: continue out[attr] = tmp return out
Transform a nested object/dict/list into a regular dict json.dump(s) and pickle don't like to un/serialize regular Python objects so this function should handle arbitrarily nested objects to be serialized to regular string, float, int, bool, None values. This is a recursive function so by default it will exit at a certain depth (depth_threshold=8). Args: x (object): Some object to dict-ify unless x is a scalar/literal then return x as is depth (int): Starting depth must be 0 (cannot supply default value due to weird Pythonisms) exclude_keys (set): Keys to avoid adding to the output dict depth_threshold (int): object/dict nesting depth to stop at Returns: dict: dict with only scalar/literal leaf values
Below is the the instruction that describes the task: ### Input: Transform a nested object/dict/list into a regular dict json.dump(s) and pickle don't like to un/serialize regular Python objects so this function should handle arbitrarily nested objects to be serialized to regular string, float, int, bool, None values. This is a recursive function so by default it will exit at a certain depth (depth_threshold=8). Args: x (object): Some object to dict-ify unless x is a scalar/literal then return x as is depth (int): Starting depth must be 0 (cannot supply default value due to weird Pythonisms) exclude_keys (set): Keys to avoid adding to the output dict depth_threshold (int): object/dict nesting depth to stop at Returns: dict: dict with only scalar/literal leaf values ### Response: def to_dict(x, depth, exclude_keys=set(), depth_threshold=8): """Transform a nested object/dict/list into a regular dict json.dump(s) and pickle don't like to un/serialize regular Python objects so this function should handle arbitrarily nested objects to be serialized to regular string, float, int, bool, None values. This is a recursive function so by default it will exit at a certain depth (depth_threshold=8). Args: x (object): Some object to dict-ify unless x is a scalar/literal then return x as is depth (int): Starting depth must be 0 (cannot supply default value due to weird Pythonisms) exclude_keys (set): Keys to avoid adding to the output dict depth_threshold (int): object/dict nesting depth to stop at Returns: dict: dict with only scalar/literal leaf values """ if x is None or isinstance(x, (str, int, float, bool)): return x if isinstance(x, np.int_): return int(x) if isinstance(x, np.int64): return int(x) if isinstance(x, np.float_): return float(x) if isinstance(x, np.float64): return float(x) if isinstance(x, np.bool_): return bool(x) if depth + 1 > depth_threshold: return {} if isinstance(x, list): out = [] for v in x: tmp = to_dict(v, depth + 1, exclude_keys, depth_threshold) if tmp == {}: continue out.append(tmp) return out out = {} if isinstance(x, dict): for k, v in x.items(): if k in exclude_keys: continue if not isinstance(k, (str,)): k = str(k) tmp = to_dict(v, depth + 1, exclude_keys, depth_threshold) if tmp == {}: continue out[k] = tmp return out for attr in listattrs(x): if attr in exclude_keys: continue v = getattr(x, attr) tmp = to_dict(v, depth + 1, exclude_keys, depth_threshold) if tmp == {}: continue out[attr] = tmp return out
def _float_or_str(value): """Internal method to attempt `float(value)` handling a `ValueError` """ # remove any surrounding quotes value = QUOTE_REGEX.sub('', value) try: # attempt `float()` conversion return float(value) except ValueError: # just return the input return value
Internal method to attempt `float(value)` handling a `ValueError`
Below is the the instruction that describes the task: ### Input: Internal method to attempt `float(value)` handling a `ValueError` ### Response: def _float_or_str(value): """Internal method to attempt `float(value)` handling a `ValueError` """ # remove any surrounding quotes value = QUOTE_REGEX.sub('', value) try: # attempt `float()` conversion return float(value) except ValueError: # just return the input return value
def unquote(value): """Remove wrapping quotes from a string. :param value: A string that might be wrapped in double quotes, such as a HTTP cookie value. :returns: Beginning and ending quotes removed and escaped quotes (``\"``) unescaped """ if len(value) > 1 and value[0] == '"' and value[-1] == '"': value = value[1:-1].replace(r'\"', '"') return value
Remove wrapping quotes from a string. :param value: A string that might be wrapped in double quotes, such as a HTTP cookie value. :returns: Beginning and ending quotes removed and escaped quotes (``\"``) unescaped
Below is the the instruction that describes the task: ### Input: Remove wrapping quotes from a string. :param value: A string that might be wrapped in double quotes, such as a HTTP cookie value. :returns: Beginning and ending quotes removed and escaped quotes (``\"``) unescaped ### Response: def unquote(value): """Remove wrapping quotes from a string. :param value: A string that might be wrapped in double quotes, such as a HTTP cookie value. :returns: Beginning and ending quotes removed and escaped quotes (``\"``) unescaped """ if len(value) > 1 and value[0] == '"' and value[-1] == '"': value = value[1:-1].replace(r'\"', '"') return value
def parse_list_objects(data, bucket_name): """ Parser for list objects response. :param data: Response data for list objects. :param bucket_name: Response for the bucket. :return: Replies back three distinctive components. - List of :class:`Object <Object>` - True if list is truncated, False otherwise. - Object name marker for the next request. """ root = S3Element.fromstring('ListObjectResult', data) is_truncated = root.get_child_text('IsTruncated').lower() == 'true' # NextMarker element need not be present. marker = root.get_urldecoded_elem_text('NextMarker', strict=False) objects, object_dirs = _parse_objects_from_xml_elts( bucket_name, root.findall('Contents'), root.findall('CommonPrefixes') ) if is_truncated and marker is None: marker = objects[-1].object_name return objects + object_dirs, is_truncated, marker
Parser for list objects response. :param data: Response data for list objects. :param bucket_name: Response for the bucket. :return: Replies back three distinctive components. - List of :class:`Object <Object>` - True if list is truncated, False otherwise. - Object name marker for the next request.
Below is the the instruction that describes the task: ### Input: Parser for list objects response. :param data: Response data for list objects. :param bucket_name: Response for the bucket. :return: Replies back three distinctive components. - List of :class:`Object <Object>` - True if list is truncated, False otherwise. - Object name marker for the next request. ### Response: def parse_list_objects(data, bucket_name): """ Parser for list objects response. :param data: Response data for list objects. :param bucket_name: Response for the bucket. :return: Replies back three distinctive components. - List of :class:`Object <Object>` - True if list is truncated, False otherwise. - Object name marker for the next request. """ root = S3Element.fromstring('ListObjectResult', data) is_truncated = root.get_child_text('IsTruncated').lower() == 'true' # NextMarker element need not be present. marker = root.get_urldecoded_elem_text('NextMarker', strict=False) objects, object_dirs = _parse_objects_from_xml_elts( bucket_name, root.findall('Contents'), root.findall('CommonPrefixes') ) if is_truncated and marker is None: marker = objects[-1].object_name return objects + object_dirs, is_truncated, marker
def change_password(self, body, username=None, params=None): """ `<https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-change-password.html>`_ :arg body: the new password for the user :arg username: The username of the user to change the password for :arg refresh: If `true` (the default) then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` then do nothing with refreshes., valid choices are: 'true', 'false', 'wait_for' """ if body in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'body'.") return self.transport.perform_request( "PUT", _make_path("_security", "user", username, "_password"), params=params, body=body, )
`<https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-change-password.html>`_ :arg body: the new password for the user :arg username: The username of the user to change the password for :arg refresh: If `true` (the default) then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` then do nothing with refreshes., valid choices are: 'true', 'false', 'wait_for'
Below is the the instruction that describes the task: ### Input: `<https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-change-password.html>`_ :arg body: the new password for the user :arg username: The username of the user to change the password for :arg refresh: If `true` (the default) then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` then do nothing with refreshes., valid choices are: 'true', 'false', 'wait_for' ### Response: def change_password(self, body, username=None, params=None): """ `<https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-change-password.html>`_ :arg body: the new password for the user :arg username: The username of the user to change the password for :arg refresh: If `true` (the default) then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` then do nothing with refreshes., valid choices are: 'true', 'false', 'wait_for' """ if body in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'body'.") return self.transport.perform_request( "PUT", _make_path("_security", "user", username, "_password"), params=params, body=body, )
def sext(self, num): """Sign-extend this farray by *num* bits. Returns a new farray. """ sign = self._items[-1] return self.__class__(self._items + [sign] * num, ftype=self.ftype)
Sign-extend this farray by *num* bits. Returns a new farray.
Below is the the instruction that describes the task: ### Input: Sign-extend this farray by *num* bits. Returns a new farray. ### Response: def sext(self, num): """Sign-extend this farray by *num* bits. Returns a new farray. """ sign = self._items[-1] return self.__class__(self._items + [sign] * num, ftype=self.ftype)
def copy_data(self): """ Copy the data from the it's point of origin, serializing it, storing it serialized as well as in it's raw form and calculate a running hash of the serialized representation """ HASH_FUNCTION = hashlib.sha256() try: raw_iterator = self.get_binary_iterator() except AttributeError: raw_iterator = self.get_non_binary_iterator() self.copy_file = tempfile.NamedTemporaryFile(mode='w+') for part in raw_iterator: encoded_part = dbsafe_encode(part) self.copy_file.write(encoded_part) self.copy_file.write('\n') HASH_FUNCTION.update(encoded_part) self.copy_file.seek(0) self.data_iterator = (dbsafe_decode(line) for line in self.copy_file) else: self.copy_file = tempfile.NamedTemporaryFile(mode='w+b') for part in raw_iterator: self.copy_file.write(part) HASH_FUNCTION.update(part) self.copy_file.seek(0) self.data_iterator = self.copy_file self.new_hash = HASH_FUNCTION.hexdigest()
Copy the data from the it's point of origin, serializing it, storing it serialized as well as in it's raw form and calculate a running hash of the serialized representation
Below is the the instruction that describes the task: ### Input: Copy the data from the it's point of origin, serializing it, storing it serialized as well as in it's raw form and calculate a running hash of the serialized representation ### Response: def copy_data(self): """ Copy the data from the it's point of origin, serializing it, storing it serialized as well as in it's raw form and calculate a running hash of the serialized representation """ HASH_FUNCTION = hashlib.sha256() try: raw_iterator = self.get_binary_iterator() except AttributeError: raw_iterator = self.get_non_binary_iterator() self.copy_file = tempfile.NamedTemporaryFile(mode='w+') for part in raw_iterator: encoded_part = dbsafe_encode(part) self.copy_file.write(encoded_part) self.copy_file.write('\n') HASH_FUNCTION.update(encoded_part) self.copy_file.seek(0) self.data_iterator = (dbsafe_decode(line) for line in self.copy_file) else: self.copy_file = tempfile.NamedTemporaryFile(mode='w+b') for part in raw_iterator: self.copy_file.write(part) HASH_FUNCTION.update(part) self.copy_file.seek(0) self.data_iterator = self.copy_file self.new_hash = HASH_FUNCTION.hexdigest()
def get_server_certificate(server_certificate, flags=FLAGS.BASE, **conn): """ Orchestrates all the calls required to fully build out an IAM User in the following format: { "Arn": ..., "ServerCertificateName": ..., "Path": ..., "ServerCertificateId": ..., "UploadDate": ..., # str "Expiration": ..., # str "CertificateBody": ..., "CertificateChain": ..., "_version": 1 } :param flags: By default, Users is disabled. This is somewhat expensive as it has to call the `get_server_certificate` call multiple times. :param server_certificate: dict MUST contain the ServerCertificateName and also a combination of either the ARN or the account_number. :param output: Determines whether keys should be returned camelized or underscored. :param conn: dict containing enough information to make a connection to the desired account. Must at least have 'assume_role' key. :return: dict containing fully built out Server Certificate. """ if not server_certificate.get('ServerCertificateName'): raise MissingFieldException('Must include ServerCertificateName.') server_certificate = modify(server_certificate, output='camelized') _conn_from_args(server_certificate, conn) return registry.build_out(flags, start_with=server_certificate, pass_datastructure=True, **conn)
Orchestrates all the calls required to fully build out an IAM User in the following format: { "Arn": ..., "ServerCertificateName": ..., "Path": ..., "ServerCertificateId": ..., "UploadDate": ..., # str "Expiration": ..., # str "CertificateBody": ..., "CertificateChain": ..., "_version": 1 } :param flags: By default, Users is disabled. This is somewhat expensive as it has to call the `get_server_certificate` call multiple times. :param server_certificate: dict MUST contain the ServerCertificateName and also a combination of either the ARN or the account_number. :param output: Determines whether keys should be returned camelized or underscored. :param conn: dict containing enough information to make a connection to the desired account. Must at least have 'assume_role' key. :return: dict containing fully built out Server Certificate.
Below is the the instruction that describes the task: ### Input: Orchestrates all the calls required to fully build out an IAM User in the following format: { "Arn": ..., "ServerCertificateName": ..., "Path": ..., "ServerCertificateId": ..., "UploadDate": ..., # str "Expiration": ..., # str "CertificateBody": ..., "CertificateChain": ..., "_version": 1 } :param flags: By default, Users is disabled. This is somewhat expensive as it has to call the `get_server_certificate` call multiple times. :param server_certificate: dict MUST contain the ServerCertificateName and also a combination of either the ARN or the account_number. :param output: Determines whether keys should be returned camelized or underscored. :param conn: dict containing enough information to make a connection to the desired account. Must at least have 'assume_role' key. :return: dict containing fully built out Server Certificate. ### Response: def get_server_certificate(server_certificate, flags=FLAGS.BASE, **conn): """ Orchestrates all the calls required to fully build out an IAM User in the following format: { "Arn": ..., "ServerCertificateName": ..., "Path": ..., "ServerCertificateId": ..., "UploadDate": ..., # str "Expiration": ..., # str "CertificateBody": ..., "CertificateChain": ..., "_version": 1 } :param flags: By default, Users is disabled. This is somewhat expensive as it has to call the `get_server_certificate` call multiple times. :param server_certificate: dict MUST contain the ServerCertificateName and also a combination of either the ARN or the account_number. :param output: Determines whether keys should be returned camelized or underscored. :param conn: dict containing enough information to make a connection to the desired account. Must at least have 'assume_role' key. :return: dict containing fully built out Server Certificate. """ if not server_certificate.get('ServerCertificateName'): raise MissingFieldException('Must include ServerCertificateName.') server_certificate = modify(server_certificate, output='camelized') _conn_from_args(server_certificate, conn) return registry.build_out(flags, start_with=server_certificate, pass_datastructure=True, **conn)
def _add_annots(self, layout, annots): """Adds annotations to the layout object """ if annots: for annot in resolve1(annots): annot = resolve1(annot) if annot.get('Rect') is not None: annot['bbox'] = annot.pop('Rect') # Rename key annot = self._set_hwxy_attrs(annot) try: annot['URI'] = resolve1(annot['A'])['URI'] except KeyError: pass for k, v in six.iteritems(annot): if not isinstance(v, six.string_types): annot[k] = obj_to_string(v) elem = parser.makeelement('Annot', annot) layout.add(elem) return layout
Adds annotations to the layout object
Below is the the instruction that describes the task: ### Input: Adds annotations to the layout object ### Response: def _add_annots(self, layout, annots): """Adds annotations to the layout object """ if annots: for annot in resolve1(annots): annot = resolve1(annot) if annot.get('Rect') is not None: annot['bbox'] = annot.pop('Rect') # Rename key annot = self._set_hwxy_attrs(annot) try: annot['URI'] = resolve1(annot['A'])['URI'] except KeyError: pass for k, v in six.iteritems(annot): if not isinstance(v, six.string_types): annot[k] = obj_to_string(v) elem = parser.makeelement('Annot', annot) layout.add(elem) return layout
def build_component(res, parent=None): "Create a gui2py control based on the python resource" # control specs (parameters) kwargs = dict(res.items()) comtype = kwargs.pop('type') if 'components' in res: components = kwargs.pop('components') elif comtype == 'Menu' and 'items' in res: components = kwargs.pop('items') else: components = [] from gui import registry if comtype in registry.CONTROLS: comclass = registry.CONTROLS[comtype] elif comtype in registry.MENU: comclass = registry.MENU[comtype] elif comtype in registry.MISC: comclass = registry.MISC[comtype] else: raise RuntimeError("%s not in registry" % comtype) # Instantiate the GUI object com = comclass(parent=parent, **kwargs) for comp in components: build_component(comp, parent=com) return com
Create a gui2py control based on the python resource
Below is the the instruction that describes the task: ### Input: Create a gui2py control based on the python resource ### Response: def build_component(res, parent=None): "Create a gui2py control based on the python resource" # control specs (parameters) kwargs = dict(res.items()) comtype = kwargs.pop('type') if 'components' in res: components = kwargs.pop('components') elif comtype == 'Menu' and 'items' in res: components = kwargs.pop('items') else: components = [] from gui import registry if comtype in registry.CONTROLS: comclass = registry.CONTROLS[comtype] elif comtype in registry.MENU: comclass = registry.MENU[comtype] elif comtype in registry.MISC: comclass = registry.MISC[comtype] else: raise RuntimeError("%s not in registry" % comtype) # Instantiate the GUI object com = comclass(parent=parent, **kwargs) for comp in components: build_component(comp, parent=com) return com
def page_length(self, length): '''Specifies page length. This command is only valid with continuous length labels. Args: length: The length of the page, in dots. Can't exceed 12000. Returns: None Raises: RuntimeError: Length must be less than 12000. ''' mH = length/256 mL = length%256 if length < 12000: self.send(chr(27)+'('+'C'+chr(2)+chr(0)+chr(mL)+chr(mH)) else: raise RuntimeError('Length must be less than 12000.')
Specifies page length. This command is only valid with continuous length labels. Args: length: The length of the page, in dots. Can't exceed 12000. Returns: None Raises: RuntimeError: Length must be less than 12000.
Below is the the instruction that describes the task: ### Input: Specifies page length. This command is only valid with continuous length labels. Args: length: The length of the page, in dots. Can't exceed 12000. Returns: None Raises: RuntimeError: Length must be less than 12000. ### Response: def page_length(self, length): '''Specifies page length. This command is only valid with continuous length labels. Args: length: The length of the page, in dots. Can't exceed 12000. Returns: None Raises: RuntimeError: Length must be less than 12000. ''' mH = length/256 mL = length%256 if length < 12000: self.send(chr(27)+'('+'C'+chr(2)+chr(0)+chr(mL)+chr(mH)) else: raise RuntimeError('Length must be less than 12000.')
def get_dot(stop=True): """Returns a string containing a DOT file. Setting stop to True will cause the trace to stop. """ defaults = [] nodes = [] edges = [] # define default attributes for comp, comp_attr in graph_attributes.items(): attr = ', '.join( '%s = "%s"' % (attr, val) for attr, val in comp_attr.items() ) defaults.append( '\t%(comp)s [ %(attr)s ];\n' % locals() ) # define nodes for func, hits in func_count.items(): calls_frac, total_time_frac, total_time = _frac_calculation(func, hits) col = settings['node_colour'](calls_frac, total_time_frac) attribs = ['%s="%s"' % a for a in settings['node_attributes'].items()] node_str = '"%s" [%s];' % (func, ', '.join(attribs)) nodes.append( node_str % locals() ) # define edges for fr_key, fr_val in call_dict.items(): if not fr_key: continue for to_key, to_val in fr_val.items(): calls_frac, total_time_frac, totla_time = \ _frac_calculation(to_key, to_val) col = settings['edge_colour'](calls_frac, total_time_frac) edge = '[ color = "%s", label="%s" ]' % (col, to_val) edges.append('"%s"->"%s" %s;' % (fr_key, to_key, edge)) defaults = '\n\t'.join( defaults ) nodes = '\n\t'.join( nodes ) edges = '\n\t'.join( edges ) dot_fmt = ("digraph G {\n" " %(defaults)s\n\n" " %(nodes)s\n\n" " %(edges)s\n}\n" ) return dot_fmt % locals()
Returns a string containing a DOT file. Setting stop to True will cause the trace to stop.
Below is the the instruction that describes the task: ### Input: Returns a string containing a DOT file. Setting stop to True will cause the trace to stop. ### Response: def get_dot(stop=True): """Returns a string containing a DOT file. Setting stop to True will cause the trace to stop. """ defaults = [] nodes = [] edges = [] # define default attributes for comp, comp_attr in graph_attributes.items(): attr = ', '.join( '%s = "%s"' % (attr, val) for attr, val in comp_attr.items() ) defaults.append( '\t%(comp)s [ %(attr)s ];\n' % locals() ) # define nodes for func, hits in func_count.items(): calls_frac, total_time_frac, total_time = _frac_calculation(func, hits) col = settings['node_colour'](calls_frac, total_time_frac) attribs = ['%s="%s"' % a for a in settings['node_attributes'].items()] node_str = '"%s" [%s];' % (func, ', '.join(attribs)) nodes.append( node_str % locals() ) # define edges for fr_key, fr_val in call_dict.items(): if not fr_key: continue for to_key, to_val in fr_val.items(): calls_frac, total_time_frac, totla_time = \ _frac_calculation(to_key, to_val) col = settings['edge_colour'](calls_frac, total_time_frac) edge = '[ color = "%s", label="%s" ]' % (col, to_val) edges.append('"%s"->"%s" %s;' % (fr_key, to_key, edge)) defaults = '\n\t'.join( defaults ) nodes = '\n\t'.join( nodes ) edges = '\n\t'.join( edges ) dot_fmt = ("digraph G {\n" " %(defaults)s\n\n" " %(nodes)s\n\n" " %(edges)s\n}\n" ) return dot_fmt % locals()
def _cache(self): """ Populates the list with a number of gradient colors. The list has Gradient.steps colors that interpolate between the fixed base Gradient.colors. The spread parameter controls the midpoint of the gradient, you can shift it right and left. A separate gradient is calculated for each half and then glued together. """ n = self.steps # Only one color in base list. if len(self._colors) == 1: ColorList.__init__(self, [self._colors[0] for i in _range(n)]) return # Expand the base list so we can chop more accurately. colors = self._interpolate(self._colors, 40) # Chop into left half and right half. # Make sure their ending and beginning match colors. left = colors[:len(colors) / 2] right = colors[len(colors) / 2:] left.append(right[0]) right.insert(0, left[-1]) # Calculate left and right gradient proportionally to spread. gradient = self._interpolate(left, int(n * self.spread))[:-1] gradient.extend( self._interpolate(right, n - int(n * self.spread))[1:] ) if self.spread > 1: gradient = gradient[:n] if self.spread < 0: gradient = gradient[-n:] ColorList.__init__(self, gradient)
Populates the list with a number of gradient colors. The list has Gradient.steps colors that interpolate between the fixed base Gradient.colors. The spread parameter controls the midpoint of the gradient, you can shift it right and left. A separate gradient is calculated for each half and then glued together.
Below is the the instruction that describes the task: ### Input: Populates the list with a number of gradient colors. The list has Gradient.steps colors that interpolate between the fixed base Gradient.colors. The spread parameter controls the midpoint of the gradient, you can shift it right and left. A separate gradient is calculated for each half and then glued together. ### Response: def _cache(self): """ Populates the list with a number of gradient colors. The list has Gradient.steps colors that interpolate between the fixed base Gradient.colors. The spread parameter controls the midpoint of the gradient, you can shift it right and left. A separate gradient is calculated for each half and then glued together. """ n = self.steps # Only one color in base list. if len(self._colors) == 1: ColorList.__init__(self, [self._colors[0] for i in _range(n)]) return # Expand the base list so we can chop more accurately. colors = self._interpolate(self._colors, 40) # Chop into left half and right half. # Make sure their ending and beginning match colors. left = colors[:len(colors) / 2] right = colors[len(colors) / 2:] left.append(right[0]) right.insert(0, left[-1]) # Calculate left and right gradient proportionally to spread. gradient = self._interpolate(left, int(n * self.spread))[:-1] gradient.extend( self._interpolate(right, n - int(n * self.spread))[1:] ) if self.spread > 1: gradient = gradient[:n] if self.spread < 0: gradient = gradient[-n:] ColorList.__init__(self, gradient)
def locate_fixed_differences(ac1, ac2): """Locate variants with no shared alleles between two populations. Parameters ---------- ac1 : array_like, int, shape (n_variants, n_alleles) Allele counts array from the first population. ac2 : array_like, int, shape (n_variants, n_alleles) Allele counts array from the second population. Returns ------- loc : ndarray, bool, shape (n_variants,) See Also -------- allel.stats.diversity.windowed_df Examples -------- >>> import allel >>> g = allel.GenotypeArray([[[0, 0], [0, 0], [1, 1], [1, 1]], ... [[0, 1], [0, 1], [0, 1], [0, 1]], ... [[0, 1], [0, 1], [1, 1], [1, 1]], ... [[0, 0], [0, 0], [1, 1], [2, 2]], ... [[0, 0], [-1, -1], [1, 1], [-1, -1]]]) >>> ac1 = g.count_alleles(subpop=[0, 1]) >>> ac2 = g.count_alleles(subpop=[2, 3]) >>> loc_df = allel.locate_fixed_differences(ac1, ac2) >>> loc_df array([ True, False, False, True, True]) """ # check inputs ac1 = asarray_ndim(ac1, 2) ac2 = asarray_ndim(ac2, 2) check_dim0_aligned(ac1, ac2) ac1, ac2 = ensure_dim1_aligned(ac1, ac2) # stack allele counts for convenience pac = np.dstack([ac1, ac2]) # count numbers of alleles called in each population pan = np.sum(pac, axis=1) # count the numbers of populations with each allele npa = np.sum(pac > 0, axis=2) # locate variants with allele calls in both populations non_missing = np.all(pan > 0, axis=1) # locate variants where all alleles are only found in a single population no_shared_alleles = np.all(npa <= 1, axis=1) return non_missing & no_shared_alleles
Locate variants with no shared alleles between two populations. Parameters ---------- ac1 : array_like, int, shape (n_variants, n_alleles) Allele counts array from the first population. ac2 : array_like, int, shape (n_variants, n_alleles) Allele counts array from the second population. Returns ------- loc : ndarray, bool, shape (n_variants,) See Also -------- allel.stats.diversity.windowed_df Examples -------- >>> import allel >>> g = allel.GenotypeArray([[[0, 0], [0, 0], [1, 1], [1, 1]], ... [[0, 1], [0, 1], [0, 1], [0, 1]], ... [[0, 1], [0, 1], [1, 1], [1, 1]], ... [[0, 0], [0, 0], [1, 1], [2, 2]], ... [[0, 0], [-1, -1], [1, 1], [-1, -1]]]) >>> ac1 = g.count_alleles(subpop=[0, 1]) >>> ac2 = g.count_alleles(subpop=[2, 3]) >>> loc_df = allel.locate_fixed_differences(ac1, ac2) >>> loc_df array([ True, False, False, True, True])
Below is the the instruction that describes the task: ### Input: Locate variants with no shared alleles between two populations. Parameters ---------- ac1 : array_like, int, shape (n_variants, n_alleles) Allele counts array from the first population. ac2 : array_like, int, shape (n_variants, n_alleles) Allele counts array from the second population. Returns ------- loc : ndarray, bool, shape (n_variants,) See Also -------- allel.stats.diversity.windowed_df Examples -------- >>> import allel >>> g = allel.GenotypeArray([[[0, 0], [0, 0], [1, 1], [1, 1]], ... [[0, 1], [0, 1], [0, 1], [0, 1]], ... [[0, 1], [0, 1], [1, 1], [1, 1]], ... [[0, 0], [0, 0], [1, 1], [2, 2]], ... [[0, 0], [-1, -1], [1, 1], [-1, -1]]]) >>> ac1 = g.count_alleles(subpop=[0, 1]) >>> ac2 = g.count_alleles(subpop=[2, 3]) >>> loc_df = allel.locate_fixed_differences(ac1, ac2) >>> loc_df array([ True, False, False, True, True]) ### Response: def locate_fixed_differences(ac1, ac2): """Locate variants with no shared alleles between two populations. Parameters ---------- ac1 : array_like, int, shape (n_variants, n_alleles) Allele counts array from the first population. ac2 : array_like, int, shape (n_variants, n_alleles) Allele counts array from the second population. Returns ------- loc : ndarray, bool, shape (n_variants,) See Also -------- allel.stats.diversity.windowed_df Examples -------- >>> import allel >>> g = allel.GenotypeArray([[[0, 0], [0, 0], [1, 1], [1, 1]], ... [[0, 1], [0, 1], [0, 1], [0, 1]], ... [[0, 1], [0, 1], [1, 1], [1, 1]], ... [[0, 0], [0, 0], [1, 1], [2, 2]], ... [[0, 0], [-1, -1], [1, 1], [-1, -1]]]) >>> ac1 = g.count_alleles(subpop=[0, 1]) >>> ac2 = g.count_alleles(subpop=[2, 3]) >>> loc_df = allel.locate_fixed_differences(ac1, ac2) >>> loc_df array([ True, False, False, True, True]) """ # check inputs ac1 = asarray_ndim(ac1, 2) ac2 = asarray_ndim(ac2, 2) check_dim0_aligned(ac1, ac2) ac1, ac2 = ensure_dim1_aligned(ac1, ac2) # stack allele counts for convenience pac = np.dstack([ac1, ac2]) # count numbers of alleles called in each population pan = np.sum(pac, axis=1) # count the numbers of populations with each allele npa = np.sum(pac > 0, axis=2) # locate variants with allele calls in both populations non_missing = np.all(pan > 0, axis=1) # locate variants where all alleles are only found in a single population no_shared_alleles = np.all(npa <= 1, axis=1) return non_missing & no_shared_alleles
def status_message(self): """Detailed message about whether the dependency is installed. :rtype: str """ if self.is_available: return "INSTALLED {0!s}" elif self.why and self.package: return "MISSING {0!s:<20}needed for {0.why}, part of the {0.package} package" elif self.why: return "MISSING {0!s:<20}needed for {0.why}" elif self.package: return "MISSING {0!s:<20}part of the {0.package} package" else: return "MISSING {0!s:<20}"
Detailed message about whether the dependency is installed. :rtype: str
Below is the the instruction that describes the task: ### Input: Detailed message about whether the dependency is installed. :rtype: str ### Response: def status_message(self): """Detailed message about whether the dependency is installed. :rtype: str """ if self.is_available: return "INSTALLED {0!s}" elif self.why and self.package: return "MISSING {0!s:<20}needed for {0.why}, part of the {0.package} package" elif self.why: return "MISSING {0!s:<20}needed for {0.why}" elif self.package: return "MISSING {0!s:<20}part of the {0.package} package" else: return "MISSING {0!s:<20}"
def set_dims(self, dims, shape=None): """Return a new variable with given set of dimensions. This method might be used to attach new dimension(s) to variable. When possible, this operation does not copy this variable's data. Parameters ---------- dims : str or sequence of str or dict Dimensions to include on the new variable. If a dict, values are used to provide the sizes of new dimensions; otherwise, new dimensions are inserted with length 1. Returns ------- Variable """ if isinstance(dims, str): dims = [dims] if shape is None and utils.is_dict_like(dims): shape = dims.values() missing_dims = set(self.dims) - set(dims) if missing_dims: raise ValueError('new dimensions %r must be a superset of ' 'existing dimensions %r' % (dims, self.dims)) self_dims = set(self.dims) expanded_dims = tuple( d for d in dims if d not in self_dims) + self.dims if self.dims == expanded_dims: # don't use broadcast_to unless necessary so the result remains # writeable if possible expanded_data = self.data elif shape is not None: dims_map = dict(zip(dims, shape)) tmp_shape = tuple(dims_map[d] for d in expanded_dims) expanded_data = duck_array_ops.broadcast_to(self.data, tmp_shape) else: expanded_data = self.data[ (None,) * (len(expanded_dims) - self.ndim)] expanded_var = Variable(expanded_dims, expanded_data, self._attrs, self._encoding, fastpath=True) return expanded_var.transpose(*dims)
Return a new variable with given set of dimensions. This method might be used to attach new dimension(s) to variable. When possible, this operation does not copy this variable's data. Parameters ---------- dims : str or sequence of str or dict Dimensions to include on the new variable. If a dict, values are used to provide the sizes of new dimensions; otherwise, new dimensions are inserted with length 1. Returns ------- Variable
Below is the the instruction that describes the task: ### Input: Return a new variable with given set of dimensions. This method might be used to attach new dimension(s) to variable. When possible, this operation does not copy this variable's data. Parameters ---------- dims : str or sequence of str or dict Dimensions to include on the new variable. If a dict, values are used to provide the sizes of new dimensions; otherwise, new dimensions are inserted with length 1. Returns ------- Variable ### Response: def set_dims(self, dims, shape=None): """Return a new variable with given set of dimensions. This method might be used to attach new dimension(s) to variable. When possible, this operation does not copy this variable's data. Parameters ---------- dims : str or sequence of str or dict Dimensions to include on the new variable. If a dict, values are used to provide the sizes of new dimensions; otherwise, new dimensions are inserted with length 1. Returns ------- Variable """ if isinstance(dims, str): dims = [dims] if shape is None and utils.is_dict_like(dims): shape = dims.values() missing_dims = set(self.dims) - set(dims) if missing_dims: raise ValueError('new dimensions %r must be a superset of ' 'existing dimensions %r' % (dims, self.dims)) self_dims = set(self.dims) expanded_dims = tuple( d for d in dims if d not in self_dims) + self.dims if self.dims == expanded_dims: # don't use broadcast_to unless necessary so the result remains # writeable if possible expanded_data = self.data elif shape is not None: dims_map = dict(zip(dims, shape)) tmp_shape = tuple(dims_map[d] for d in expanded_dims) expanded_data = duck_array_ops.broadcast_to(self.data, tmp_shape) else: expanded_data = self.data[ (None,) * (len(expanded_dims) - self.ndim)] expanded_var = Variable(expanded_dims, expanded_data, self._attrs, self._encoding, fastpath=True) return expanded_var.transpose(*dims)
def _update_conda_devel(): """Update to the latest development conda package. """ conda_bin = _get_conda_bin() channels = _get_conda_channels(conda_bin) assert conda_bin, "Could not find anaconda distribution for upgrading bcbio" subprocess.check_call([conda_bin, "install", "--quiet", "--yes"] + channels + ["bcbio-nextgen>=%s" % version.__version__.replace("a0", "a")]) return os.path.dirname(os.path.dirname(conda_bin))
Update to the latest development conda package.
Below is the the instruction that describes the task: ### Input: Update to the latest development conda package. ### Response: def _update_conda_devel(): """Update to the latest development conda package. """ conda_bin = _get_conda_bin() channels = _get_conda_channels(conda_bin) assert conda_bin, "Could not find anaconda distribution for upgrading bcbio" subprocess.check_call([conda_bin, "install", "--quiet", "--yes"] + channels + ["bcbio-nextgen>=%s" % version.__version__.replace("a0", "a")]) return os.path.dirname(os.path.dirname(conda_bin))
def form_valid(self, form): ''' Create slots and return success message. ''' startDate = form.cleaned_data['startDate'] endDate = form.cleaned_data['endDate'] startTime = form.cleaned_data['startTime'] endTime = form.cleaned_data['endTime'] instructor = form.cleaned_data['instructorId'] interval_minutes = getConstant('privateLessons__lessonLengthInterval') this_date = startDate while this_date <= endDate: this_time = startTime while this_time < endTime: InstructorAvailabilitySlot.objects.create( instructor=instructor, startTime=ensure_localtime(datetime.combine(this_date, this_time)), duration=interval_minutes, location=form.cleaned_data.get('location'), room=form.cleaned_data.get('room'), pricingTier=form.cleaned_data.get('pricingTier'), ) this_time = (ensure_localtime(datetime.combine(this_date, this_time)) + timedelta(minutes=interval_minutes)).time() this_date += timedelta(days=1) return JsonResponse({'valid': True})
Create slots and return success message.
Below is the the instruction that describes the task: ### Input: Create slots and return success message. ### Response: def form_valid(self, form): ''' Create slots and return success message. ''' startDate = form.cleaned_data['startDate'] endDate = form.cleaned_data['endDate'] startTime = form.cleaned_data['startTime'] endTime = form.cleaned_data['endTime'] instructor = form.cleaned_data['instructorId'] interval_minutes = getConstant('privateLessons__lessonLengthInterval') this_date = startDate while this_date <= endDate: this_time = startTime while this_time < endTime: InstructorAvailabilitySlot.objects.create( instructor=instructor, startTime=ensure_localtime(datetime.combine(this_date, this_time)), duration=interval_minutes, location=form.cleaned_data.get('location'), room=form.cleaned_data.get('room'), pricingTier=form.cleaned_data.get('pricingTier'), ) this_time = (ensure_localtime(datetime.combine(this_date, this_time)) + timedelta(minutes=interval_minutes)).time() this_date += timedelta(days=1) return JsonResponse({'valid': True})