code
stringlengths 4
4.48k
| docstring
stringlengths 1
6.45k
| _id
stringlengths 24
24
|
|---|---|---|
class ScaredyCat: <NEW_LINE> <INDENT> pass | An entity that runs away from the player | 62599093099cdd3c6367628f |
class Hardtanh(Module): <NEW_LINE> <INDENT> def __init__(self, min_value=-1, max_value=1, inplace=False): <NEW_LINE> <INDENT> super(Hardtanh, self).__init__() <NEW_LINE> self.min_val = min_value <NEW_LINE> self.max_val = max_value <NEW_LINE> self.inplace = inplace <NEW_LINE> assert self.max_val > self.min_val <NEW_LINE> <DEDENT> def forward(self, input): <NEW_LINE> <INDENT> return F.hardtanh(input, self.min_val, self.max_val, self.inplace) <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> inplace_str=', inplace' if self.inplace else '' <NEW_LINE> return self.__class__.__name__ + ' (' + 'min_val=' + str(self.min_val) + ', max_val=' + str(self.max_val) + inplace_str + ')' | Applies the HardTanh function element-wise
HardTanh is defined as::
f(x) = +1, if x > 1
f(x) = -1, if x < -1
f(x) = x, otherwise
The range of the linear region :math:`[-1, 1]` can be adjusted
Args:
min_value: minimum value of the linear region range
max_value: maximum value of the linear region range
inplace: can optionally do the operation in-place
Shape:
- Input: :math:`(N, *)` where `*` means, any number of additional dimensions
- Output: :math:`(N, *)`, same shape as the input
Examples::
>>> m = nn.HardTanh(-2, 2)
>>> input = autograd.Variable(torch.randn(2))
>>> print(input)
>>> print(m(input)) | 62599093283ffb24f3cf55cc |
class MarcoProcessor(DataProcessor): <NEW_LINE> <INDENT> def get_train_examples(self, data_dir): <NEW_LINE> <INDENT> logger.info("LOOKING AT {}".format(os.path.join(data_dir, "triples.small.train.tsv"))) <NEW_LINE> return self._create_examples( self._read_tsv(os.path.join(data_dir, "triples.small.train.leave5k.tsv")), "train") <NEW_LINE> <DEDENT> def get_dev_examples(self, data_dir): <NEW_LINE> <INDENT> return self._create_examples( self._read_tsv(os.path.join(data_dir, "triples.small.dev.5k.tsv")), "dev") <NEW_LINE> <DEDENT> def get_labels(self): <NEW_LINE> <INDENT> return ["0", "1"] <NEW_LINE> <DEDENT> def _create_examples(self, lines, set_type): <NEW_LINE> <INDENT> examples = [] <NEW_LINE> for (i, line) in enumerate(lines): <NEW_LINE> <INDENT> if i == 0: <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> guid = "%s-%s" % (set_type, i) <NEW_LINE> text_a = line[0] + line[1] <NEW_LINE> text_b = line[0] + line[2] <NEW_LINE> label = 0 <NEW_LINE> examples.append( InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label)) <NEW_LINE> <DEDENT> return examples | Processor for the MRPC data set (GLUE version). | 6259909360cbc95b06365bfe |
class NotAllowed(ApiRequestError): <NEW_LINE> <INDENT> pass | 12 - You're not allowed to do that | 62599093091ae35668706960 |
class RoundedRectangle(clutter.Actor): <NEW_LINE> <INDENT> __gtype_name__ = 'RoundedRectangle' <NEW_LINE> def __init__(self, width, height, arc, step, color=None, border_color=None, border_width=0): <NEW_LINE> <INDENT> super(RoundedRectangle, self).__init__() <NEW_LINE> self._width = width <NEW_LINE> self._height = height <NEW_LINE> self._arc = arc <NEW_LINE> self._step = step <NEW_LINE> if color: <NEW_LINE> <INDENT> self._color = color <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self._color = clutter.color_from_string("#000") <NEW_LINE> <DEDENT> if border_color: <NEW_LINE> <INDENT> self._border_color = border_color <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self._border_color = clutter.color_from_string("#000") <NEW_LINE> <DEDENT> self._border_width = border_width <NEW_LINE> <DEDENT> def do_paint(self): <NEW_LINE> <INDENT> cogl.path_round_rectangle(0, 0, self._width, self._height, self._arc, self._step) <NEW_LINE> cogl.path_close() <NEW_LINE> cogl.clip_push_from_path() <NEW_LINE> cogl.set_source_color(self._border_color) <NEW_LINE> cogl.path_round_rectangle(0, 0, self._width, self._height, self._arc, self._step) <NEW_LINE> cogl.path_close() <NEW_LINE> if True: <NEW_LINE> <INDENT> cogl.set_source_color(self._color) <NEW_LINE> cogl.path_round_rectangle(self._border_width, self._border_width, self._width - self._border_width, self._height - self._border_width, self._arc, self._step) <NEW_LINE> cogl.path_fill() <NEW_LINE> <DEDENT> cogl.path_close() <NEW_LINE> cogl.clip_pop() <NEW_LINE> <DEDENT> def do_pick(self, color): <NEW_LINE> <INDENT> if self.should_pick_paint() == False: <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> cogl.path_round_rectangle(0, 0, self._width, self._height, self._arc, self._step) <NEW_LINE> cogl.path_close() <NEW_LINE> cogl.clip_push_from_path() <NEW_LINE> cogl.set_source_color(color) <NEW_LINE> cogl.path_round_rectangle(0, 0, self._width, self._height, self._arc, self._step) <NEW_LINE> cogl.path_close() <NEW_LINE> cogl.path_fill() <NEW_LINE> cogl.clip_pop() <NEW_LINE> <DEDENT> def get_color(self): <NEW_LINE> <INDENT> return self._color <NEW_LINE> <DEDENT> def set_color(self, color): <NEW_LINE> <INDENT> self._color = color <NEW_LINE> self.queue_redraw() <NEW_LINE> <DEDENT> def get_border_width(self): <NEW_LINE> <INDENT> return self._border_width <NEW_LINE> <DEDENT> def set_border_width(self, width): <NEW_LINE> <INDENT> self._border_width = width <NEW_LINE> self.queue_redraw() <NEW_LINE> <DEDENT> def get_border_color(color): <NEW_LINE> <INDENT> return self._border_color <NEW_LINE> <DEDENT> def set_border_color(self, color): <NEW_LINE> <INDENT> self._border_color = color <NEW_LINE> self.queue_redraw() | Custom actor used to draw a rectangle that can have rounded corners | 6259909350812a4eaa621a5d |
class GhettoBitStream(object): <NEW_LINE> <INDENT> def __init__(self, data): <NEW_LINE> <INDENT> self.bytes = deque(bytearray(data)) <NEW_LINE> self._bit_buffer = deque() <NEW_LINE> <DEDENT> def __iter__(self): <NEW_LINE> <INDENT> return self <NEW_LINE> <DEDENT> def __next__(self): <NEW_LINE> <INDENT> if not self._bit_buffer: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> byte = self.pop_byte() <NEW_LINE> <DEDENT> except IndexError: <NEW_LINE> <INDENT> raise StopIteration <NEW_LINE> <DEDENT> bits = self._byte_to_bits(byte) <NEW_LINE> self._bit_buffer.extend(bits) <NEW_LINE> <DEDENT> return self._bit_buffer.popleft() <NEW_LINE> <DEDENT> def next(self): <NEW_LINE> <INDENT> return self.__next__() <NEW_LINE> <DEDENT> def pop_byte(self): <NEW_LINE> <INDENT> return self.bytes.popleft() <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def _byte_to_bits(cls, byte): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> return '{0:08b}'.format(byte) <NEW_LINE> <DEDENT> except AttributeError: <NEW_LINE> <INDENT> return cls._bin_backport(byte) <NEW_LINE> <DEDENT> <DEDENT> @staticmethod <NEW_LINE> def _bin_backport(x): <NEW_LINE> <INDENT> chars = [] <NEW_LINE> for n in range(7, -1, -1): <NEW_LINE> <INDENT> y = x - 2 ** n <NEW_LINE> if y >= 0: <NEW_LINE> <INDENT> chars.append('1') <NEW_LINE> x = y <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> chars.append('0') <NEW_LINE> <DEDENT> <DEDENT> return ''.join(chars) <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def combine_bytes(data): <NEW_LINE> <INDENT> copy = data[:] <NEW_LINE> copy.reverse() <NEW_LINE> return sum(x << n * 8 for n, x in enumerate(copy)) | Accepts binary data and makes it available as a stream of bits or one byte
at a time. Python does not provide a built-in way to read a stream of bits,
or a way to represent a single bit. Thus, this class uses character '0'
or '1' to represent the status of each bit.
Data is converted into the '0' and '1' characters one byte at a time, since
that operation multiplies the size of the data by a factor of 8, and it may
not be desirable to inflate all of the data at once. | 62599093be7bc26dc9252cec |
class IPv4AddressAnalyzer(RegexAnalyzer): <NEW_LINE> <INDENT> name = "IPv4AddressAnalyzer" <NEW_LINE> def __init__(self, actions): <NEW_LINE> <INDENT> regex = r"\b\d{1,3}(?:\.\d{1,3}){3}\b" <NEW_LINE> super().__init__(actions, regex) <NEW_LINE> <DEDENT> def verify(self, results): <NEW_LINE> <INDENT> verified_ips = [] <NEW_LINE> for result in results: <NEW_LINE> <INDENT> octet_max_value = 255 <NEW_LINE> for octet in result.split("."): <NEW_LINE> <INDENT> if int(octet) > octet_max_value: <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> verified_ips.append(result) <NEW_LINE> <DEDENT> <DEDENT> return verified_ips | Analyzer to match on ip addresses via regex | 625990935fdd1c0f98e5fca5 |
class EquidistantPositionParamDef(PositionParamDef): <NEW_LINE> <INDENT> def __init__(self, values): <NEW_LINE> <INDENT> positions = [] <NEW_LINE> for i, v in enumerate(values): <NEW_LINE> <INDENT> pos = float(i)/(len(values)-1) <NEW_LINE> positions.append(pos) <NEW_LINE> <DEDENT> super(EquidistantPositionParamDef, self).__init__(values, positions) | Extension of PositionParamDef, in which the position of each value is
equidistant from its neighbours and their order is determined by their
order in values. | 625990933617ad0b5ee07e83 |
@skip('Not implemented') <NEW_LINE> class TestClark1987SingleComplex(Clark1987): <NEW_LINE> <INDENT> @classmethod <NEW_LINE> def setup_class(cls): <NEW_LINE> <INDENT> super(TestClark1987SingleComplex, cls).setup_class( dtype=np.complex64, conserve_memory=0 ) <NEW_LINE> cls.results = cls.run_filter() | Basic single precision complex test for the loglikelihood and filtered
states. | 62599093adb09d7d5dc0c28c |
class AverageMeter(object): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.reset() <NEW_LINE> <DEDENT> def reset(self): <NEW_LINE> <INDENT> self.sum = 0 <NEW_LINE> self.count = 0 <NEW_LINE> <DEDENT> def update(self, val, n=1): <NEW_LINE> <INDENT> self.sum += val * n <NEW_LINE> self.count += n <NEW_LINE> <DEDENT> def get_average(): <NEW_LINE> <INDENT> return self.sum / self.count | Computes and stores the average and current value | 62599093bf627c535bcb3207 |
class ITask(object): <NEW_LINE> <INDENT> def get_storage(self): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> def create_job(self): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> def finish(self): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> def is_finished(self): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> def on_job_created(self, callback): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> def trigger_job_created(self, job): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> def on_finished(self, callback): <NEW_LINE> <INDENT> raise NotImplementedError() | Interface for Task.
| 62599093283ffb24f3cf55d3 |
class ReaderSerializer(serializers.ModelSerializer): <NEW_LINE> <INDENT> url = serializers.HyperlinkedIdentityField(view_name="account:reader-detail") <NEW_LINE> class Meta: <NEW_LINE> <INDENT> model = Reader <NEW_LINE> fields = ('id', 'email', 'password', 'first_name', 'last_name', 'img', 'liked_posts', 'subscribed_categories', 'subscribed_authors', 'is_staff', 'is_active', 'is_superuser', 'is_author', 'last_login', 'url' ) <NEW_LINE> <DEDENT> def create(self, validated_data): <NEW_LINE> <INDENT> return Reader.objects.create_reader(**validated_data) <NEW_LINE> <DEDENT> def validate_is_superuser(self, value): <NEW_LINE> <INDENT> if value is True: <NEW_LINE> <INDENT> raise serializers.ValidationError("Reader must not have is_superuser=True") <NEW_LINE> <DEDENT> return value <NEW_LINE> <DEDENT> def validate_is_staff(self, value): <NEW_LINE> <INDENT> if value is True: <NEW_LINE> <INDENT> raise serializers.ValidationError("Reader must not have is_staff=True") <NEW_LINE> <DEDENT> return value | Reader serializer to create, retrieve a reader and get list of readers | 62599093656771135c48aeca |
class WildFire(poc_grid.Grid): <NEW_LINE> <INDENT> def __init__(self, grid_height, grid_width, queue = poc_queue.Queue()): <NEW_LINE> <INDENT> poc_grid.Grid.__init__(self, grid_height, grid_width) <NEW_LINE> self._fire_boundary = queue <NEW_LINE> <DEDENT> def clear(self): <NEW_LINE> <INDENT> poc_grid.Grid.clear(self) <NEW_LINE> self._fire_boundary.clear() <NEW_LINE> <DEDENT> def enqueue_boundary(self, row, col): <NEW_LINE> <INDENT> self._fire_boundary.enqueue((row, col)) <NEW_LINE> <DEDENT> def dequeue_boundary(self): <NEW_LINE> <INDENT> return self._fire_boundary.dequeue() <NEW_LINE> <DEDENT> def boundary_size(self): <NEW_LINE> <INDENT> return len(self._fire_boundary) <NEW_LINE> <DEDENT> def fire_boundary(self): <NEW_LINE> <INDENT> for cell in self._fire_boundary: <NEW_LINE> <INDENT> yield cell <NEW_LINE> <DEDENT> <DEDENT> def update_boundary(self): <NEW_LINE> <INDENT> cell = self._fire_boundary.dequeue() <NEW_LINE> neighbors = self.four_neighbors(cell[0], cell[1]) <NEW_LINE> for neighbor in neighbors: <NEW_LINE> <INDENT> if self.is_empty(neighbor[0], neighbor[1]): <NEW_LINE> <INDENT> self.set_full(neighbor[0], neighbor[1]) <NEW_LINE> self._fire_boundary.enqueue(neighbor) | Class that models a burning wild fire using a grid and a queue
The grid stores whether a cell is burned (FULL) or unburned (EMPTY)
The queue stores the cells on the boundary of the fire | 62599093d8ef3951e32c8cf6 |
class CreditOrgAdmin(admin.ModelAdmin): <NEW_LINE> <INDENT> list_display = ('id', 'name', 'username') <NEW_LINE> readonly_fields = ('id',) <NEW_LINE> raw_id_fields = ('username',) <NEW_LINE> list_filter = ('name', 'username') <NEW_LINE> search_fields = ('id', 'name', 'username',) | Кастомизация представления в административной панели,
модели кредитных организаций. | 6259909355399d3f05628247 |
class CABWrapperOnlyDependencyOutputterConfiguration(EPMWrapperOnlyDependencyFilterConfiguration, CABDependencyOutputterConfiguration): <NEW_LINE> <INDENT> pass | >>> PhysicalModuleTypes.names(CABInterfaceOnlyDependencyOutputterConfiguration.skip_module_types_as_source)
... | 62599093be7bc26dc9252cef |
class ExecuteUpdateWorkflowLUser: <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> super().__init__() <NEW_LINE> self.log_event = models.Log.WORKFLOW_UPDATE_LUSERS <NEW_LINE> <DEDENT> def execute_operation( self, user, workflow: Optional[models.Workflow] = None, action: Optional[models.Action] = None, payload: Optional[Dict] = None, log_item: Optional[models.Log] = None, ): <NEW_LINE> <INDENT> del action <NEW_LINE> if not log_item and self.log_event: <NEW_LINE> <INDENT> log_item = workflow.log( user, operation_type=self.log_event, **payload) <NEW_LINE> <DEDENT> try: <NEW_LINE> <INDENT> emails = sql.get_rows( workflow.get_data_frame_table_name(), column_names=[workflow.luser_email_column.name]) <NEW_LINE> luser_list = [] <NEW_LINE> created = 0 <NEW_LINE> for row in emails: <NEW_LINE> <INDENT> uemail = row[workflow.luser_email_column.name] <NEW_LINE> luser = get_user_model().objects.filter(email=uemail).first() <NEW_LINE> if not luser: <NEW_LINE> <INDENT> if settings.DEBUG: <NEW_LINE> <INDENT> password = 'boguspwd' <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> password = get_random_string(length=RANDOM_PWD_LENGTH) <NEW_LINE> <DEDENT> luser = get_user_model().objects.create_user( email=uemail, password=password, ) <NEW_LINE> created += 1 <NEW_LINE> <DEDENT> luser_list.append(luser) <NEW_LINE> <DEDENT> workflow.lusers.set(luser_list) <NEW_LINE> workflow.lusers_is_outdated = False <NEW_LINE> workflow.save() <NEW_LINE> log_item.payload['total_users'] = emails.rowcount <NEW_LINE> log_item.payload['new_users'] = created <NEW_LINE> log_item.payload['status'] = ugettext( 'Learner emails successfully updated.', ) <NEW_LINE> log_item.save(update_fields=['payload']) <NEW_LINE> log_item.payload['status'] = 'Execution finished successfully' <NEW_LINE> log_item.save(update_fields=['payload']) <NEW_LINE> <DEDENT> except Exception as exc: <NEW_LINE> <INDENT> log_item.payload['status'] = ugettext('Error: {0}').format(exc) <NEW_LINE> log_item.save(update_fields=['payload']) | Update the LUSER field in a workflow. | 62599093dc8b845886d552ee |
class Cutoff: <NEW_LINE> <INDENT> def get_mask(self, grid): <NEW_LINE> <INDENT> raise NotImplementedError <NEW_LINE> <DEDENT> def get_modes_number(self, grid): <NEW_LINE> <INDENT> raise NotImplementedError | The base class for mode cutoffs. | 62599093283ffb24f3cf55d6 |
class DeleteMixin(BaseMixin): <NEW_LINE> <INDENT> def delete(self, params, meta, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError("delete method not implemented") <NEW_LINE> <DEDENT> def on_delete(self, req, resp, handler=None, **kwargs): <NEW_LINE> <INDENT> self.handle( handler or self.delete, req, resp, **kwargs ) <NEW_LINE> resp.status = falcon.HTTP_ACCEPTED | Add default "delete flow on DELETE" to any resource class. | 6259909350812a4eaa621a62 |
class SimpsonIntegrator3PtTestCases(unittest.TestCase, IntegratorCommonTestCases): <NEW_LINE> <INDENT> def __init__(self, *args, **kwargs): <NEW_LINE> <INDENT> self.num_nodes = 7 <NEW_LINE> self.integrator = 'simpson' <NEW_LINE> super(SimpsonIntegrator3PtTestCases, self).__init__(*args, **kwargs) | Only run the common test cases using second order accuracy because
it cannot differentiate the quartic accurately | 6259909460cbc95b06365c04 |
class IS_AXI: <NEW_LINE> <INDENT> s = struct.Struct('3Bx2BH31sx') <NEW_LINE> def __init__(self, ReqI=0, AXStart=0, NumCP=0, NumO=0, LName=''): <NEW_LINE> <INDENT> self.Size = 40 <NEW_LINE> self.Type = ISP_AXI <NEW_LINE> self.ReqI = ReqI <NEW_LINE> self.AXStart = AXStart <NEW_LINE> self.NumCP = NumCP <NEW_LINE> self.NumO = NumO <NEW_LINE> self.LName = LName <NEW_LINE> <DEDENT> def pack(self): <NEW_LINE> <INDENT> return self.s.pack(self.Size, self.Type, self.ReqI, self.AXStart, self.NumCP, self.NumO, str_factory.encode(self.LName)) <NEW_LINE> <DEDENT> def unpack(self, data): <NEW_LINE> <INDENT> self.Size, self.Type, self.ReqI, self.AXStart, self.NumCP, self.NumO, self.LName = self.s.unpack(data) <NEW_LINE> self.LName = str_factory.decode(self.LName) <NEW_LINE> return self | AutoX Info | 62599094dc8b845886d552f2 |
class ConnectionState(msrest.serialization.Model): <NEW_LINE> <INDENT> _attribute_map = { 'status': {'key': 'status', 'type': 'str'}, 'description': {'key': 'description', 'type': 'str'}, } <NEW_LINE> def __init__( self, **kwargs ): <NEW_LINE> <INDENT> super(ConnectionState, self).__init__(**kwargs) <NEW_LINE> self.status = kwargs.get('status', None) <NEW_LINE> self.description = kwargs.get('description', None) | ConnectionState information.
:param status: Status of the connection. Possible values include: "Pending", "Approved",
"Rejected", "Disconnected".
:type status: str or
~azure.mgmt.eventhub.v2021_06_01_preview.models.PrivateLinkConnectionStatus
:param description: Description of the connection state.
:type description: str | 62599094f9cc0f698b1c6168 |
class Upkeep(Turn): <NEW_LINE> <INDENT> @argtypes(Turn, Player) <NEW_LINE> def __init__(self, player): <NEW_LINE> <INDENT> Turn.__init__(player) <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return "Upkeep phase signal" | This class serves to signal the upkeep step of a player's turn | 62599094adb09d7d5dc0c294 |
class _UserFilterBasedTrigger(FilterBasedTrigger): <NEW_LINE> <INDENT> def __init__(self, nickname: str = None, user_id: int = None, username: str = None): <NEW_LINE> <INDENT> if nickname is not None: <NEW_LINE> <INDENT> super().__init__(Filters.user(DEFAULT_USERS_HELPER.get_user_id_by_nickname(nickname))) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> super().__init__(Filters.user(user_id, username)) | A user filter trigger. This is used to trigger a rule when an incoming message comes from a
specific user. | 62599094ad47b63b2c5a9581 |
class toneAnalyserService(object): <NEW_LINE> <INDENT> def importarSentimentos(self): <NEW_LINE> <INDENT> instaRepository = instagramRepository() <NEW_LINE> ibmTone = ibmWebService() <NEW_LINE> listaTags = instaRepository.consultarTudo() <NEW_LINE> for tagInsta in listaTags: <NEW_LINE> <INDENT> tagInsta.sentimento = ibmTone.retornarEmocaoTag(tagInsta.tag) <NEW_LINE> instaRepository.atualizarSentimento(tagInsta) | description of class | 62599094091ae3566870696e |
class Sky2Pix_ZenithalPerspective(Sky2PixProjection, Zenithal): <NEW_LINE> <INDENT> mu = Parameter(default=0.0) <NEW_LINE> gamma = Parameter(default=0.0, getter=np.rad2deg, setter=np.deg2rad) <NEW_LINE> @mu.validator <NEW_LINE> def mu(self, value): <NEW_LINE> <INDENT> if np.any(value == -1): <NEW_LINE> <INDENT> raise InputParameterError( "Zenithal perspective projection is not defined for mu = -1") <NEW_LINE> <DEDENT> <DEDENT> @property <NEW_LINE> def inverse(self): <NEW_LINE> <INDENT> return Pix2Sky_AZP(self.mu.value, self.gamma.value) <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def evaluate(cls, phi, theta, mu, gamma): <NEW_LINE> <INDENT> return _projections.azps2x( phi, theta, mu, np.rad2deg(gamma)) | Zenithal perspective projection - sky to pixel.
Corresponds to the ``AZP`` projection in FITS WCS.
.. math::
x &= R \sin \phi \\
y &= -R \sec \gamma \cos \theta
where:
.. math::
R = \frac{180^{\circ}}{\pi} \frac{(\mu + 1) \cos \theta}{(\mu + \sin \theta) + \cos \theta \cos \phi \tan \gamma}
Parameters
----------
mu : float
Distance from point of projection to center of sphere
in spherical radii, μ. Default is 0.
gamma : float
Look angle γ in degrees. Default is 0°. | 6259909450812a4eaa621a64 |
class TestCredentials(unittest.TestCase): <NEW_LINE> <INDENT> def setUp(self): <NEW_LINE> <INDENT> self.new_credential = Credentials("intagram","pass123") <NEW_LINE> <DEDENT> def test_init(self): <NEW_LINE> <INDENT> self.assertEqual(self.new_credential.account_name,"facebook") <NEW_LINE> self.assertEqual(self.new_credential.account_password,"pass123456") <NEW_LINE> <DEDENT> def test_save_account(self): <NEW_LINE> <INDENT> self.new_credential.save_account() <NEW_LINE> self.assertEqual(len(Credentials.credential_list),1) <NEW_LINE> <DEDENT> def tearDown(self): <NEW_LINE> <INDENT> Credentials.credential_list = [] <NEW_LINE> <DEDENT> def test_save_multiple_account(self): <NEW_LINE> <INDENT> self.new_credential.save_account() <NEW_LINE> test_account = Credentials("Telegram","pass12345") <NEW_LINE> test_account.save_account() <NEW_LINE> self.assertEqual(len(Credentials.credential_list),2) | test for Credential | 62599094f9cc0f698b1c6169 |
class ListOrderException(Exception): <NEW_LINE> <INDENT> def __init__(self, msg: str) -> None: <NEW_LINE> <INDENT> self.message = str(msg) <NEW_LINE> <DEDENT> def __str__(self) -> str: <NEW_LINE> <INDENT> return self.message | Should be raised, if the ordering of a list is wrong (e.g. min values in an extent list after max...)
:param msg: detailed error message | 62599094283ffb24f3cf55dc |
class UOWEventHandler(interfaces.AttributeExtension): <NEW_LINE> <INDENT> active_history = False <NEW_LINE> def __init__(self, key): <NEW_LINE> <INDENT> self.key = key <NEW_LINE> <DEDENT> def append(self, state, item, initiator): <NEW_LINE> <INDENT> sess = _state_session(state) <NEW_LINE> if sess: <NEW_LINE> <INDENT> prop = _state_mapper(state).get_property(self.key) <NEW_LINE> if prop.cascade.save_update and item not in sess: <NEW_LINE> <INDENT> sess.add(item) <NEW_LINE> <DEDENT> <DEDENT> return item <NEW_LINE> <DEDENT> def remove(self, state, item, initiator): <NEW_LINE> <INDENT> sess = _state_session(state) <NEW_LINE> if sess: <NEW_LINE> <INDENT> prop = _state_mapper(state).get_property(self.key) <NEW_LINE> if prop.cascade.delete_orphan and item in sess.new and prop.mapper._is_orphan(attributes.instance_state(item)): <NEW_LINE> <INDENT> sess.expunge(item) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def set(self, state, newvalue, oldvalue, initiator): <NEW_LINE> <INDENT> if oldvalue is newvalue: <NEW_LINE> <INDENT> return newvalue <NEW_LINE> <DEDENT> sess = _state_session(state) <NEW_LINE> if sess: <NEW_LINE> <INDENT> prop = _state_mapper(state).get_property(self.key) <NEW_LINE> if newvalue is not None and prop.cascade.save_update and newvalue not in sess: <NEW_LINE> <INDENT> sess.add(newvalue) <NEW_LINE> <DEDENT> if prop.cascade.delete_orphan and oldvalue in sess.new and prop.mapper._is_orphan(attributes.instance_state(oldvalue)): <NEW_LINE> <INDENT> sess.expunge(oldvalue) <NEW_LINE> <DEDENT> <DEDENT> return newvalue | An event handler added to all relation attributes which handles
session cascade operations. | 62599094dc8b845886d552f6 |
class PickBestHarness(RestCommand): <NEW_LINE> <INDENT> def __init__(self, files, *args, **kwargs): <NEW_LINE> <INDENT> super(PickBestHarness, self).__init__(*args, **kwargs) <NEW_LINE> self.files = files <NEW_LINE> <DEDENT> def setup(self): <NEW_LINE> <INDENT> mapping = Options() <NEW_LINE> for yaml_file in self.files: <NEW_LINE> <INDENT> mapping[yaml_file] = yaml.load(open(yaml_file).read()) <NEW_LINE> <DEDENT> rmapping = dict((b['address'], k) for k, v in mapping.items() for _, b in v['devices'].items()) <NEW_LINE> ret = self.ifc.api.f5asset.filter(v_accessaddress__in=list(rmapping.keys())) <NEW_LINE> highest_due = {} <NEW_LINE> for f5asset in ret.data.objects: <NEW_LINE> <INDENT> yaml_file = rmapping[f5asset['v_accessaddress']] <NEW_LINE> timestamp = time.mktime(time.strptime(f5asset['v_due_on'], '%Y-%m-%dT%H:%M:%S')) if f5asset['v_due_on'] else 0 <NEW_LINE> highest_due[yaml_file] = max(highest_due.get(yaml_file, 0), timestamp) <NEW_LINE> <DEDENT> LOG.debug(highest_due) <NEW_LINE> best_yaml_file = min(highest_due, key=lambda x: highest_due[x]) <NEW_LINE> return Options(mapping[best_yaml_file]) | Given a list of harness definition files, pick the one that's the most "available".
Assumes files are in YAML format.
@rtype: dict | 62599094ad47b63b2c5a9583 |
class ItemAlign(BaseAlign): <NEW_LINE> <INDENT> def align_inner(self, source, target) -> dict: <NEW_LINE> <INDENT> source = str(source) <NEW_LINE> target = str(target) <NEW_LINE> translation = {} <NEW_LINE> if Path(source).is_file() and Path(target).is_file(): <NEW_LINE> <INDENT> translation = FileAlign().align(source, target) <NEW_LINE> <DEDENT> elif Path(source).is_dir() and Path(target).is_dir(): <NEW_LINE> <INDENT> translation = DirAlign().align(source, target) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> print(f'文件目录类型不一致或不存在') <NEW_LINE> <DEDENT> return translation | 从 IterAlign 调用，检查 item 是文件或路径 | 625990943617ad0b5ee07e91 |
class TestDecorators(unittest.TestCase): <NEW_LINE> <INDENT> def test_json_decorator(self): <NEW_LINE> <INDENT> method_input = {"a": 1, "b": 2} <NEW_LINE> expected = json.dumps(method_input) <NEW_LINE> response = _my_test_func(method_input, 200) <NEW_LINE> self.assertEquals(expected, response.data) <NEW_LINE> self.assertEquals(200, response.status_code) <NEW_LINE> self.assertEquals('application/json', response.content_type) | Decorators unit tests | 62599094d8ef3951e32c8cfc |
class PreferencesDialog(gaupol.BuilderDialog): <NEW_LINE> <INDENT> _widgets = ("notebook",) <NEW_LINE> def __init__(self, parent, application): <NEW_LINE> <INDENT> gaupol.BuilderDialog.__init__(self, "preferences-dialog.ui", connect_signals=False) <NEW_LINE> self._editor_page = EditorPage(self, application) <NEW_LINE> self._extension_page = ExtensionPage(self, application) <NEW_LINE> self._file_page = FilePage(self, application) <NEW_LINE> self._preview_page = PreviewPage(self, application) <NEW_LINE> self._video_page = VideoPage(self, application) <NEW_LINE> self._builder.connect_signals(self._get_callbacks()) <NEW_LINE> self.connect("response", self._on_response) <NEW_LINE> aeidon.util.connect(self, "_notebook", "switch-page") <NEW_LINE> self.set_transient_for(parent) <NEW_LINE> self.set_default_response(Gtk.ResponseType.CLOSE) <NEW_LINE> self.set_response_sensitive(Gtk.ResponseType.HELP, False) <NEW_LINE> <DEDENT> def _get_callbacks(self): <NEW_LINE> <INDENT> callbacks = {} <NEW_LINE> for page in (self._editor_page, self._extension_page, self._file_page, self._preview_page, self._video_page): <NEW_LINE> <INDENT> for name in [x for x in dir(page) if x.startswith("_on_")]: <NEW_LINE> <INDENT> callbacks[name] = getattr(page, name) <NEW_LINE> <DEDENT> <DEDENT> return callbacks <NEW_LINE> <DEDENT> def _on_notebook_switch_page(self, notebook, page, index): <NEW_LINE> <INDENT> self.set_response_sensitive(Gtk.ResponseType.HELP, index == 3) <NEW_LINE> <DEDENT> def _on_response(self, dialog, response): <NEW_LINE> <INDENT> if response == Gtk.ResponseType.HELP: <NEW_LINE> <INDENT> gaupol.util.show_uri(gaupol.PREVIEW_HELP_URL) <NEW_LINE> self.stop_emission("response") | Dialog for editing preferences. | 625990947cff6e4e811b7782 |
class StoreLocation(glance.store.location.StoreLocation): <NEW_LINE> <INDENT> def process_specs(self): <NEW_LINE> <INDENT> self.scheme = self.specs.get('scheme', STORE_SCHEME) <NEW_LINE> self.server_host = self.specs.get('server_host') <NEW_LINE> self.path = os.path.join(DS_URL_PREFIX, self.specs.get('image_dir').strip('/'), self.specs.get('image_id')) <NEW_LINE> dc_path = self.specs.get('datacenter_path') <NEW_LINE> if dc_path is not None: <NEW_LINE> <INDENT> param_list = {'dcPath': self.specs.get('datacenter_path'), 'dsName': self.specs.get('datastore_name')} <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> param_list = {'dsName': self.specs.get('datastore_name')} <NEW_LINE> <DEDENT> self.query = urlparse.urlencode(param_list) <NEW_LINE> <DEDENT> def get_uri(self): <NEW_LINE> <INDENT> if is_valid_ipv6(self.server_host): <NEW_LINE> <INDENT> base_url = '%s://[%s]%s' % (self.scheme, self.server_host, self.path) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> base_url = '%s://%s%s' % (self.scheme, self.server_host, self.path) <NEW_LINE> <DEDENT> return '%s?%s' % (base_url, self.query) <NEW_LINE> <DEDENT> def _is_valid_path(self, path): <NEW_LINE> <INDENT> return path.startswith( os.path.join(DS_URL_PREFIX, CONF.vmware_store_image_dir.strip('/'))) <NEW_LINE> <DEDENT> def parse_uri(self, uri): <NEW_LINE> <INDENT> if not uri.startswith('%s://' % STORE_SCHEME): <NEW_LINE> <INDENT> reason = (_("URI %(uri)s must start with %(scheme)s://") % {'uri': uri, 'scheme': STORE_SCHEME}) <NEW_LINE> LOG.error(reason) <NEW_LINE> raise exception.BadStoreUri(reason) <NEW_LINE> <DEDENT> (self.scheme, self.server_host, path, params, query, fragment) = urlparse.urlparse(uri) <NEW_LINE> if not query: <NEW_LINE> <INDENT> path = path.split('?') <NEW_LINE> if self._is_valid_path(path[0]): <NEW_LINE> <INDENT> self.path = path[0] <NEW_LINE> self.query = path[1] <NEW_LINE> return <NEW_LINE> <DEDENT> <DEDENT> elif self._is_valid_path(path): <NEW_LINE> <INDENT> self.path = path <NEW_LINE> self.query = query <NEW_LINE> return <NEW_LINE> <DEDENT> reason = 'Badly formed VMware datastore URI %(uri)s.' % {'uri': uri} <NEW_LINE> LOG.debug(reason) <NEW_LINE> raise exception.BadStoreUri(reason) | Class describing an VMware URI.
An VMware URI can look like any of the following:
vsphere://server_host/folder/file_path?dcPath=dc_path&dsName=ds_name | 62599094f9cc0f698b1c616b |
@cached_class <NEW_LINE> class MaterialsProjectCompatibility(Compatibility): <NEW_LINE> <INDENT> def __init__(self, compat_type="Advanced", correct_peroxide=True, check_potcar_hash=False): <NEW_LINE> <INDENT> module_dir = os.path.dirname(os.path.abspath(__file__)) <NEW_LINE> fp = os.path.join(module_dir, "MPCompatibility.yaml") <NEW_LINE> i_s = MPVaspInputSet() <NEW_LINE> Compatibility.__init__( self, [PotcarCorrection(i_s, check_hash=check_potcar_hash), GasCorrection(fp, correct_peroxide=correct_peroxide), UCorrection(fp, i_s, compat_type)]) | This class implements the GGA/GGA+U mixing scheme, which allows mixing of
entries. Note that this should only be used for VASP calculations using the
MaterialsProject parameters (see pymatgen.io.vaspio_set.MPVaspInputSet).
Using this compatibility scheme on runs with different parameters is not
valid.
Args:
compat_type: Two options, GGA or Advanced. GGA means all GGA+U
entries are excluded. Advanced means mixing scheme is
implemented to make entries compatible with each other,
but entries which are supposed to be done in GGA+U will have the
equivalent GGA entries excluded. For example, Fe oxides should
have a U value under the Advanced scheme. A GGA Fe oxide run
will therefore be excluded under the scheme.
correct_peroxide: Specify whether peroxide/superoxide/ozonide
corrections are to be applied or not.
check_potcar_hash (bool): Use potcar hash to verify potcars are correct. | 625990943617ad0b5ee07e93 |
class Invite(SlottedModel): <NEW_LINE> <INDENT> code = Field(str) <NEW_LINE> inviter = Field(User) <NEW_LINE> guild = Field(Guild) <NEW_LINE> channel = Field(Channel) <NEW_LINE> max_age = Field(int) <NEW_LINE> max_uses = Field(int) <NEW_LINE> uses = Field(int) <NEW_LINE> temporary = Field(bool) <NEW_LINE> created_at = Field(datetime) <NEW_LINE> @classmethod <NEW_LINE> def create(cls, channel, max_age=86400, max_uses=0, temporary=False, unique=False): <NEW_LINE> <INDENT> return channel.client.api.channels_invites_create( channel.id, max_age=max_age, max_uses=max_uses, temporary=temporary, unique=unique) <NEW_LINE> <DEDENT> def delete(self): <NEW_LINE> <INDENT> self.client.api.invites_delete(self.code) | An invite object.
Attributes
----------
code : str
The invite code.
inviter : :class:`disco.types.user.User`
The user who created this invite.
guild : :class:`disco.types.guild.Guild`
The guild this invite is for.
channel : :class:`disco.types.channel.Channel`
The channel this invite is for.
max_age : int
The time after this invite's creation at which it expires.
max_uses : int
The maximum number of uses.
uses : int
The current number of times the invite was used.
temporary : bool
Whether this invite only grants temporary membership.
created_at : datetime
When this invite was created. | 62599094d8ef3951e32c8cfd |
class Product(models.Model): <NEW_LINE> <INDENT> _inherit = "product.product" <NEW_LINE> @api.multi <NEW_LINE> def write(self, vals): <NEW_LINE> <INDENT> res = super(Product, self).write(vals) <NEW_LINE> if 'default_code' not in vals or not res: <NEW_LINE> <INDENT> return res <NEW_LINE> <DEDENT> templates = [p.product_tmpl_id.id for p in self] <NEW_LINE> default_code = vals['default_code'] <NEW_LINE> siblings = self.search([ ('product_tmpl_id', 'in', templates), ('default_code', '!=', default_code), ('default_code', 'in', ['', None]), ]) <NEW_LINE> if siblings: <NEW_LINE> <INDENT> siblings.write({'default_code': default_code}) <NEW_LINE> <DEDENT> return res <NEW_LINE> <DEDENT> tier_low = fields.Float( string='Tier Price Low', digits=(6, 2), default=0) <NEW_LINE> tier_high = fields.Float( string='Tier Price High', digits=(6, 2), default=0) | All variants of same product without any code get the same reference number. | 62599094be7bc26dc9252cf6 |
class Matyas(Benchmark): <NEW_LINE> <INDENT> def __init__(self, dimensions=2): <NEW_LINE> <INDENT> Benchmark.__init__(self, dimensions) <NEW_LINE> self.bounds = list(zip([-10.0] * self.dimensions, [ 10.0] * self.dimensions)) <NEW_LINE> self.global_optimum = [0.0] * self.dimensions <NEW_LINE> self.fglob = 0.0 <NEW_LINE> <DEDENT> def evaluator(self, x, *args): <NEW_LINE> <INDENT> self.fun_evals += 1 <NEW_LINE> return 0.26*(x[0]**2 + x[1]**2) - 0.48*x[0]*x[1] | Matyas test objective function.
This class defines the Matyas global optimization problem. This
is a multimodal minimization problem defined as follows:
.. math::
f_{\text{Matyas}}(\mathbf{x}) = 0.26(x_1^2 + x_2^2) - 0.48x_1x_2
Here, :math:`n` represents the number of dimensions and :math:`x_i \in [-10, 10]` for :math:`i=1,2`.
.. figure:: figures/Matyas.png
:alt: Matyas function
:align: center
**Two-dimensional Matyas function**
*Global optimum*: :math:`f(x_i) = 0` for :math:`x_i = 0` for :math:`i=1,2` | 62599094283ffb24f3cf55e4 |
class BaseTestCase(TestCase): <NEW_LINE> <INDENT> @classmethod <NEW_LINE> def setUpClass(self): <NEW_LINE> <INDENT> cmds.file(new=True, force=True) <NEW_LINE> <DEDENT> def tearDown(self): <NEW_LINE> <INDENT> cmds.file(new=True, force=True) | Base Class for all unittests. | 6259909460cbc95b06365c0a |
class ServerExistsError(Exception): <NEW_LINE> <INDENT> pass | Is been raised when the port where the server tried to connect
is already in use. | 625990945fdd1c0f98e5fcbb |
class Watcher(object): <NEW_LINE> <INDENT> def __init__(self, fd, event): <NEW_LINE> <INDENT> self._fd = fd <NEW_LINE> self._event = tornado.ioloop.IOLoop.READ if event == 1 else tornado.ioloop.IOLoop.WRITE <NEW_LINE> self._greenlet = greenlet.getcurrent() <NEW_LINE> self._parent = self._greenlet.parent <NEW_LINE> self._ioloop = tornado.ioloop.IOLoop.current() <NEW_LINE> self._callback = None <NEW_LINE> self._args = None <NEW_LINE> self._kwargs = None <NEW_LINE> <DEDENT> def start(self, callback, *args, **kwargs): <NEW_LINE> <INDENT> self._callback = callback <NEW_LINE> self._args = args <NEW_LINE> self._kwargs = kwargs <NEW_LINE> self._ioloop.add_handler(self._fd, self._handle_event, self._event) <NEW_LINE> <DEDENT> def _handle_event(self, *args, **kwargs): <NEW_LINE> <INDENT> self._callback(*self._args, **self._kwargs) <NEW_LINE> <DEDENT> def stop(self): <NEW_LINE> <INDENT> self._ioloop.remove_handler(self._fd) | 这里传递过来的都是一些就绪的事件
watcher 用来替换 libev 中的 watcher
直接实例化一个 Watcher(fd, event) 对象，可以替换 greenify.pyx.wait_gevent 中的 hub.loop.io(fd, event) | 62599094adb09d7d5dc0c2a0 |
class Dict(dict): <NEW_LINE> <INDENT> def __init__(self, **kw): <NEW_LINE> <INDENT> super(Dict, self).__init__(**kw) <NEW_LINE> <DEDENT> def __getattr__(self, key): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> return self[key] <NEW_LINE> <DEDENT> except KeyError: <NEW_LINE> <INDENT> raise AttributeError(r"'Dict' object has no attribute '%s'" % key) <NEW_LINE> <DEDENT> <DEDENT> def __setattr__(self, key, value): <NEW_LINE> <INDENT> self[key] = value | Simple dict but also support access as x.y style
>>>d1=Dict()
>>>d1['x']=100
>>>d1.x
100
>>>d1.y=200
>>>d1['y']
200
>>>d2=Dict(a=1,b=2,c='3')
>>>d2.c
'3'
>>>d2['empty']
Traceback (most recent call last ):
...
KeyError:'empty'
>>>d2.empty
Traceback (most recent call last):
...
AttributeError:'Dict' object has no attrbute 'empty' | 62599094099cdd3c6367629d |
class HuffmanTree(): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.nodes = [] <NEW_LINE> self.head = None <NEW_LINE> self.dict = {} <NEW_LINE> self.reversed_dict = {} <NEW_LINE> <DEDENT> def add_text(self, text): <NEW_LINE> <INDENT> count = Counter(list(text)) <NEW_LINE> for key in count: <NEW_LINE> <INDENT> self.add_node(Node(key, count[key])) <NEW_LINE> <DEDENT> <DEDENT> def add_node(self, node): <NEW_LINE> <INDENT> self.nodes.append(node) <NEW_LINE> self.nodes.sort(key=lambda x: x.value, reverse=True) <NEW_LINE> <DEDENT> def mount(self): <NEW_LINE> <INDENT> while len(self.nodes) > 1: <NEW_LINE> <INDENT> node_left = self.nodes[-2] <NEW_LINE> node_right = self.nodes[-1] <NEW_LINE> node = Node(node_left.label + node_right.label, node_left.value + node_right.value) <NEW_LINE> node.left = node_left <NEW_LINE> node.right = node_right <NEW_LINE> self.nodes = self.nodes[:-2] <NEW_LINE> self.add_node(node) <NEW_LINE> <DEDENT> self.head = self.nodes[0] <NEW_LINE> self.__mount_dict() <NEW_LINE> self.__reverse_dict() <NEW_LINE> <DEDENT> def __mount_dict(self): <NEW_LINE> <INDENT> self.__nav_tree(self.head, '') <NEW_LINE> <DEDENT> def __nav_tree(self, node, code): <NEW_LINE> <INDENT> if node.left == node.right: <NEW_LINE> <INDENT> self.dict[node.label] = code <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> if node.left: <NEW_LINE> <INDENT> self.__nav_tree(node.left, code + '0') <NEW_LINE> <DEDENT> if node.right: <NEW_LINE> <INDENT> self.__nav_tree(node.right, code + '1') <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def __reverse_dict(self): <NEW_LINE> <INDENT> self.reversed_dict = {self.dict[key]: key for key in self.dict} <NEW_LINE> <DEDENT> def encode(self, text): <NEW_LINE> <INDENT> result = '' <NEW_LINE> for letter in list(text): <NEW_LINE> <INDENT> if self.dict.get(letter): <NEW_LINE> <INDENT> result += self.dict[letter] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> result += '?' <NEW_LINE> <DEDENT> <DEDENT> return result <NEW_LINE> <DEDENT> def decode(self, code): <NEW_LINE> <INDENT> result = '' <NEW_LINE> acc = '' <NEW_LINE> code = [c for c in code if c.isdigit()] <NEW_LINE> for number in code: <NEW_LINE> <INDENT> acc += number <NEW_LINE> if self.reversed_dict.get(acc): <NEW_LINE> <INDENT> result += self.reversed_dict[acc] <NEW_LINE> acc = '' <NEW_LINE> <DEDENT> <DEDENT> return result | Classe com a Árvore de Huffman
attr:
nodes(Node[]): lista de nós
head(Node): nó raíz
dict(dict): dicionário com os códigos
reversed_dict(dict): dicionário invertido | 625990943617ad0b5ee07e99 |
class TestContainerStartAPIView(TestContainerCreationMixin, TestAPIViewsBase): <NEW_LINE> <INDENT> def setUp(self): <NEW_LINE> <INDENT> super().setUp() <NEW_LINE> self.create_one_container() <NEW_LINE> self.create_fake_uuid() <NEW_LINE> <DEDENT> @patch("containers.tasks.container_task.apply_async") <NEW_LINE> def test_get_success(self, mock): <NEW_LINE> <INDENT> response = self.request_knox( reverse( "containers:api-start", kwargs={"container": self.container1.sodar_uuid}, ) ) <NEW_LINE> self.assertEqual(response.status_code, status.HTTP_200_OK) <NEW_LINE> self.assertEqual(ContainerBackgroundJob.objects.count(), 1) <NEW_LINE> job = ContainerBackgroundJob.objects.first() <NEW_LINE> self.assertEqual(job.action, ACTION_START) <NEW_LINE> self.assertEqual(job.container, self.container1) <NEW_LINE> mock.assert_called_with( kwargs={"job_id": job.pk}, countdown=CELERY_SUBMIT_COUNTDOWN ) <NEW_LINE> <DEDENT> def test_get_non_existent(self): <NEW_LINE> <INDENT> response = self.request_knox( reverse( "containers:api-start", kwargs={"container": self.fake_uuid}, ) ) <NEW_LINE> self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) | Tests for ``ContainerStartAPIView``. | 625990947cff6e4e811b778a |
class GpDescribeField(CoClass): <NEW_LINE> <INDENT> _reg_clsid_ = GUID('{540B9C6B-D49F-4218-B206-67789E19BE07}') <NEW_LINE> _idlflags_ = [] <NEW_LINE> _typelib_path_ = typelib_path <NEW_LINE> _reg_typelib_ = ('{C031A050-82C6-4F8F-8836-5692631CFFE6}', 10, 2) | Geoprocessing DescribeField object. | 62599094091ae3566870697c |
class TreatedPatient(Patient): <NEW_LINE> <INDENT> def __init__(self, viruses, maxPop): <NEW_LINE> <INDENT> Patient.__init__(self, viruses, maxPop) <NEW_LINE> self.activeDrugs = [] <NEW_LINE> <DEDENT> def addPrescription(self, newDrug): <NEW_LINE> <INDENT> if newDrug not in self.activeDrugs: <NEW_LINE> <INDENT> self.activeDrugs.append(newDrug) <NEW_LINE> <DEDENT> <DEDENT> def getPrescriptions(self): <NEW_LINE> <INDENT> return self.activeDrugs <NEW_LINE> <DEDENT> def getResistPop(self, drugResist): <NEW_LINE> <INDENT> numResistantViruses = 0 <NEW_LINE> for virus in self.viruses: <NEW_LINE> <INDENT> if virus.isResistantToAll(drugResist): <NEW_LINE> <INDENT> numResistantViruses += 1 <NEW_LINE> <DEDENT> <DEDENT> return numResistantViruses <NEW_LINE> <DEDENT> def update(self): <NEW_LINE> <INDENT> survivedViruses = [] <NEW_LINE> for virus in self.viruses: <NEW_LINE> <INDENT> if not virus.doesClear(): <NEW_LINE> <INDENT> survivedViruses.append(virus) <NEW_LINE> <DEDENT> <DEDENT> popDensity = float(len(survivedViruses)) / self.maxPop <NEW_LINE> self.viruses = survivedViruses <NEW_LINE> childViruses = [] <NEW_LINE> for virus in self.viruses: <NEW_LINE> <INDENT> childViruses.append(virus) <NEW_LINE> try: <NEW_LINE> <INDENT> child = virus.reproduce(popDensity, self.activeDrugs) <NEW_LINE> childViruses.append(child) <NEW_LINE> <DEDENT> except NoChildException: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> <DEDENT> self.viruses = childViruses <NEW_LINE> return self.getTotalPop() | Representation of a patient. The patient is able to take drugs and his/her
virus population can acquire resistance to the drugs he/she takes. | 625990943617ad0b5ee07e9b |
class ITB(FBOTableEntry): <NEW_LINE> <INDENT> def migrations(self): <NEW_LINE> <INDENT> return (("015_%s_table.sql" % self.record_type, self.sql_table(), "DROP TABLE %s;" % self.record_type),) | Model of a ITB (Invitation To Bid) | 62599094adb09d7d5dc0c2a4 |
class DataSourceManager(object): <NEW_LINE> <INDENT> _domDocument = None <NEW_LINE> def __init__(self, domDocument): <NEW_LINE> <INDENT> self._domDocument = domDocument <NEW_LINE> <DEDENT> def getDataSourceByName(self,stringName): <NEW_LINE> <INDENT> tabDataSourceElement = self._domDocument.getElementsByTagName("data-source") <NEW_LINE> elementToReturn = None <NEW_LINE> for elementDataSource in tabDataSourceElement: <NEW_LINE> <INDENT> if elementDataSource.hasAttribute("key"): <NEW_LINE> <INDENT> if elementDataSource.getAttribute("key") == stringName: <NEW_LINE> <INDENT> elementToReturn = elementDataSource <NEW_LINE> break <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> return elementToReturn | Create XML conf for sgoa project | 62599094d8ef3951e32c8d02 |
class ActorItem(ClassifierItem): <NEW_LINE> <INDENT> __uml__ = UML.Actor <NEW_LINE> HEAD = 11 <NEW_LINE> ARM = 19 <NEW_LINE> NECK = 10 <NEW_LINE> BODY = 20 <NEW_LINE> __style__ = { 'min-size': (ARM * 2, HEAD + NECK + BODY + ARM), 'name-align': (ALIGN_CENTER, ALIGN_BOTTOM), 'name-padding': (5, 0, 5, 0), 'name-outside': True, } <NEW_LINE> def __init__(self, id = None): <NEW_LINE> <INDENT> ClassifierItem.__init__(self, id) <NEW_LINE> self.drawing_style = self.DRAW_ICON <NEW_LINE> <DEDENT> def draw_icon(self, context): <NEW_LINE> <INDENT> super(ActorItem, self).draw(context) <NEW_LINE> cr = context.cairo <NEW_LINE> head, neck, arm, body = self.HEAD, self.NECK, self.ARM, self.BODY <NEW_LINE> fx = self.width / (arm * 2); <NEW_LINE> fy = self.height / (head + neck + body + arm) <NEW_LINE> x = arm * fx <NEW_LINE> y = (head / 2) * fy <NEW_LINE> cy = head * fy <NEW_LINE> cr.move_to(x + head * fy / 2.0, y) <NEW_LINE> cr.arc(x, y, head * fy / 2.0, 0, 2 * pi) <NEW_LINE> cr.move_to(x, y + cy / 2) <NEW_LINE> cr.line_to(arm * fx, (head + neck + body) * fy) <NEW_LINE> cr.move_to(0, (head + neck) * fy) <NEW_LINE> cr.line_to(arm * 2 * fx, (head + neck) * fy) <NEW_LINE> cr.move_to(0, (head + neck + body + arm) * fy) <NEW_LINE> cr.line_to(arm * fx, (head + neck + body) * fy) <NEW_LINE> cr.line_to(arm * 2 * fx, (head + neck + body + arm) * fy) <NEW_LINE> cr.stroke() | Actor item is a classifier in icon mode.
Maybe it should be possible to switch to comparment mode in the future. | 625990945fdd1c0f98e5fcc1 |
class DiscData(object): <NEW_LINE> <INDENT> def __init__(self, parent=None, accessible=None, tolink=None): <NEW_LINE> <INDENT> self._accessible = accessible or [] <NEW_LINE> self.parent = parent <NEW_LINE> self._link = None <NEW_LINE> self._tolink = tolink or [] <NEW_LINE> <DEDENT> def accessible(self): <NEW_LINE> <INDENT> return self._accessible <NEW_LINE> <DEDENT> def final(self): <NEW_LINE> <INDENT> return self._tolink == [] <NEW_LINE> <DEDENT> def tobedone(self): <NEW_LINE> <INDENT> return self._tolink <NEW_LINE> <DEDENT> def last_link(self): <NEW_LINE> <INDENT> return self._link <NEW_LINE> <DEDENT> def link(self, to_edu, from_edu, relation, rfc=RfcConstraint.full): <NEW_LINE> <INDENT> if True: <NEW_LINE> <INDENT> index = self.accessible().index(to_edu) <NEW_LINE> self._link = (to_edu, from_edu, relation) <NEW_LINE> if rfc == RfcConstraint.full and SUBORD_COORD.get(relation, "subord") == "coord": <NEW_LINE> <INDENT> self._accessible = self._accessible[:index] <NEW_LINE> <DEDENT> elif rfc == RfcConstraint.simple: <NEW_LINE> <INDENT> self._accessible = self._accessible[:index + 1] <NEW_LINE> <DEDENT> elif rfc == RfcConstraint.none: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise Exception("Unknown RFC: {}".format(rfc)) <NEW_LINE> <DEDENT> self._accessible.append(from_edu) <NEW_LINE> <DEDENT> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> template = ("{link}/ " "accessibility={accessibility}/ " "to attach={to_attach}") <NEW_LINE> return template.format(link=self._link, accessibility=self._accessible, to_attach=[str(x) for x in self._tolink]) <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return str(self) | Natural reading order decoding: incremental building of tree in order of
text (one edu at a time)
Basic discourse data for a state: chosen links between edus at that stage +
right-frontier state. To save space, only new links are stored. the
complete solution will be built with backpointers via the parent field
RF: right frontier, = admissible attachment point of current discourse unit
:param parent: parent state (previous decision)
:param link: current decision (a triplet: target edu, source edu, relation)
:type link: (string, string, string)
:param tolink: remaining unattached discourse units
:type tolink: [string] | 62599094be7bc26dc9252cfb |
class OrgsorgidprojectsprojectidbuildtargetsCredentialsSigning(object): <NEW_LINE> <INDENT> swagger_types = { 'credentialid': 'str', 'credential_resource_ref': 'OrgsorgidprojectsprojectidbuildtargetsCredentialsSigningCredentialResourceRef' } <NEW_LINE> attribute_map = { 'credentialid': 'credentialid', 'credential_resource_ref': 'credentialResourceRef' } <NEW_LINE> def __init__(self, credentialid=None, credential_resource_ref=None): <NEW_LINE> <INDENT> self._credentialid = None <NEW_LINE> self._credential_resource_ref = None <NEW_LINE> self.discriminator = None <NEW_LINE> if credentialid is not None: <NEW_LINE> <INDENT> self.credentialid = credentialid <NEW_LINE> <DEDENT> if credential_resource_ref is not None: <NEW_LINE> <INDENT> self.credential_resource_ref = credential_resource_ref <NEW_LINE> <DEDENT> <DEDENT> @property <NEW_LINE> def credentialid(self): <NEW_LINE> <INDENT> return self._credentialid <NEW_LINE> <DEDENT> @credentialid.setter <NEW_LINE> def credentialid(self, credentialid): <NEW_LINE> <INDENT> self._credentialid = credentialid <NEW_LINE> <DEDENT> @property <NEW_LINE> def credential_resource_ref(self): <NEW_LINE> <INDENT> return self._credential_resource_ref <NEW_LINE> <DEDENT> @credential_resource_ref.setter <NEW_LINE> def credential_resource_ref(self, credential_resource_ref): <NEW_LINE> <INDENT> self._credential_resource_ref = credential_resource_ref <NEW_LINE> <DEDENT> def to_dict(self): <NEW_LINE> <INDENT> result = {} <NEW_LINE> for attr, _ in six.iteritems(self.swagger_types): <NEW_LINE> <INDENT> value = getattr(self, attr) <NEW_LINE> if isinstance(value, list): <NEW_LINE> <INDENT> result[attr] = list(map( lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value )) <NEW_LINE> <DEDENT> elif hasattr(value, "to_dict"): <NEW_LINE> <INDENT> result[attr] = value.to_dict() <NEW_LINE> <DEDENT> elif isinstance(value, dict): <NEW_LINE> <INDENT> result[attr] = dict(map( lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item, value.items() )) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> result[attr] = value <NEW_LINE> <DEDENT> <DEDENT> if issubclass(OrgsorgidprojectsprojectidbuildtargetsCredentialsSigning, dict): <NEW_LINE> <INDENT> for key, value in self.items(): <NEW_LINE> <INDENT> result[key] = value <NEW_LINE> <DEDENT> <DEDENT> return result <NEW_LINE> <DEDENT> def to_str(self): <NEW_LINE> <INDENT> return pprint.pformat(self.to_dict()) <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return self.to_str() <NEW_LINE> <DEDENT> def __eq__(self, other): <NEW_LINE> <INDENT> if not isinstance(other, OrgsorgidprojectsprojectidbuildtargetsCredentialsSigning): <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> return self.__dict__ == other.__dict__ <NEW_LINE> <DEDENT> def __ne__(self, other): <NEW_LINE> <INDENT> return not self == other | NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually. | 62599094d8ef3951e32c8d03 |
class JSONEncodedError(Exception): <NEW_LINE> <INDENT> @property <NEW_LINE> def data(self): <NEW_LINE> <INDENT> return self.args[0] | An error that can be encoded in JSON and should be the return value for an
RPC method failure mode. | 625990947cff6e4e811b7790 |
@override_flag('foo', active=False) <NEW_LINE> class OverrideFlagOnClassTransactionTestCase(OverrideFlagOnClassTestsMixin, TransactionTestCase): <NEW_LINE> <INDENT> pass | Run tests with Django TransactionTestCase | 62599094dc8b845886d55306 |
class my_install_data(install_data): <NEW_LINE> <INDENT> def finalize_options(self): <NEW_LINE> <INDENT> if self.install_dir is None: <NEW_LINE> <INDENT> installobj = self.distribution.get_command_obj('install') <NEW_LINE> self.install_dir = installobj.install_lib <NEW_LINE> <DEDENT> print('Installing data files to %s' % self.install_dir) <NEW_LINE> install_data.finalize_options(self) | A custom install_data command, which will install it's files
into the standard directories (normally lib/site-packages). | 6259909460cbc95b06365c0f |
class SQLCustomType(object): <NEW_LINE> <INDENT> def __init__(self, type='string', native=None, encoder=None, decoder=None, validator=None, _class=None, widget=None, represent=None): <NEW_LINE> <INDENT> self.type = type <NEW_LINE> self.native = native <NEW_LINE> self.encoder = encoder or (lambda x: x) <NEW_LINE> self.decoder = decoder or (lambda x: x) <NEW_LINE> self.validator = validator <NEW_LINE> self._class = _class or type <NEW_LINE> self.widget = widget <NEW_LINE> self.represent = represent <NEW_LINE> <DEDENT> def startswith(self, text=None): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> return self.type.startswith(self, text) <NEW_LINE> <DEDENT> except TypeError: <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> <DEDENT> def endswith(self, text=None): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> return self.type.endswith(self, text) <NEW_LINE> <DEDENT> except TypeError: <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> <DEDENT> def __getslice__(self, a=0, b=100): <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> def __getitem__(self, i): <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return self._class | Allows defining of custom SQL types
Args:
type: the web2py type (default = 'string')
native: the backend type
encoder: how to encode the value to store it in the backend
decoder: how to decode the value retrieved from the backend
validator: what validators to use ( default = None, will use the
default validator for type)
Example::
Define as:
decimal = SQLCustomType(
type ='double',
native ='integer',
encoder =(lambda x: int(float(x) * 100)),
decoder = (lambda x: Decimal("0.00") + Decimal(str(float(x)/100)) )
)
db.define_table(
'example',
Field('value', type=decimal)
) | 625990947cff6e4e811b7792 |
class Rectangle: <NEW_LINE> <INDENT> number_of_instances = 0 <NEW_LINE> print_symbol = "#" <NEW_LINE> def __init__(self, width=0, height=0): <NEW_LINE> <INDENT> if type(width) != int: <NEW_LINE> <INDENT> raise TypeError("width must be an integer") <NEW_LINE> <DEDENT> if type(height) != int: <NEW_LINE> <INDENT> raise TypeError("height must be an integer") <NEW_LINE> <DEDENT> if width < 0: <NEW_LINE> <INDENT> raise ValueError("width must be >= 0") <NEW_LINE> <DEDENT> if height < 0: <NEW_LINE> <INDENT> raise ValueError("height must be >= 0") <NEW_LINE> <DEDENT> self.__width = width <NEW_LINE> self.__height = height <NEW_LINE> type(self).number_of_instances += 1 <NEW_LINE> <DEDENT> def area(self): <NEW_LINE> <INDENT> area = self.__width * self.__height <NEW_LINE> return area <NEW_LINE> <DEDENT> def perimeter(self): <NEW_LINE> <INDENT> if self.__width == 0 or self.__height == 0: <NEW_LINE> <INDENT> perimeter = 0 <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> perimeter = (self.__width * 2) + (self.__height * 2) <NEW_LINE> <DEDENT> return perimeter <NEW_LINE> <DEDENT> @property <NEW_LINE> def width(self): <NEW_LINE> <INDENT> return self.__width <NEW_LINE> <DEDENT> @width.setter <NEW_LINE> def width(self, value): <NEW_LINE> <INDENT> if type(value) != int: <NEW_LINE> <INDENT> raise TypeError('width must be an integer') <NEW_LINE> <DEDENT> if value < 0: <NEW_LINE> <INDENT> raise ValueError('width must be >= 0') <NEW_LINE> <DEDENT> self.__width = value <NEW_LINE> <DEDENT> @property <NEW_LINE> def height(self): <NEW_LINE> <INDENT> return self.__height <NEW_LINE> <DEDENT> @height.setter <NEW_LINE> def height(self, value): <NEW_LINE> <INDENT> if type(value) != int: <NEW_LINE> <INDENT> raise TypeError('height must be an integer') <NEW_LINE> <DEDENT> if value < 0: <NEW_LINE> <INDENT> raise ValueError('height must be >= 0') <NEW_LINE> <DEDENT> self.__height = value <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> numeral = "" <NEW_LINE> if self.__width == 0 or self.__height == 0: <NEW_LINE> <INDENT> return "" <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> for i in range(self.__height): <NEW_LINE> <INDENT> for x in range(self.__width): <NEW_LINE> <INDENT> numeral += str(self.print_symbol) <NEW_LINE> <DEDENT> if i < self.__height - 1: <NEW_LINE> <INDENT> numeral += "\n" <NEW_LINE> <DEDENT> <DEDENT> return numeral <NEW_LINE> <DEDENT> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return 'Rectangle({}, {})'.format(self.__width, self.__height) <NEW_LINE> <DEDENT> def __del__(self): <NEW_LINE> <INDENT> print("Bye rectangle...") <NEW_LINE> type(self).number_of_instances -= 1 <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def bigger_or_equal(rect_1, rect_2): <NEW_LINE> <INDENT> if not isinstance(rect_1, Rectangle): <NEW_LINE> <INDENT> raise TypeError('rect_1 must be an instance of Rectangle') <NEW_LINE> <DEDENT> if not isinstance(rect_2, Rectangle): <NEW_LINE> <INDENT> raise TypeError('rect_2 must be an instance of Rectangle') <NEW_LINE> <DEDENT> if rect_1.area() == rect_2.area() or rect_1.area() > rect_2.area(): <NEW_LINE> <INDENT> return rect_1 <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return rect_2 | Class Rectangle | 62599094be7bc26dc9252cfd |
class ModifyAlarmAttributeRequest(AbstractModel): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.Attribute = None <NEW_LINE> self.Value = None <NEW_LINE> <DEDENT> def _deserialize(self, params): <NEW_LINE> <INDENT> self.Attribute = params.get("Attribute") <NEW_LINE> self.Value = params.get("Value") | ModifyAlarmAttribute请求参数结构体
| 62599094adb09d7d5dc0c2aa |
class Cpp17Gpp(CompiledLanguage): <NEW_LINE> <INDENT> @property <NEW_LINE> def name(self): <NEW_LINE> <INDENT> return "C++17 / g++" <NEW_LINE> <DEDENT> @property <NEW_LINE> def source_extensions(self): <NEW_LINE> <INDENT> return [".cpp", ".cc", ".cxx", ".c++", ".C"] <NEW_LINE> <DEDENT> @property <NEW_LINE> def header_extensions(self): <NEW_LINE> <INDENT> return [".h"] <NEW_LINE> <DEDENT> @property <NEW_LINE> def object_extensions(self): <NEW_LINE> <INDENT> return [".o"] <NEW_LINE> <DEDENT> def get_compilation_commands(self, source_filenames, executable_filename, for_evaluation=True): <NEW_LINE> <INDENT> command = ["/usr/bin/g++"] <NEW_LINE> if for_evaluation: <NEW_LINE> <INDENT> command += ["-DEVAL"] <NEW_LINE> <DEDENT> command += ["-std=gnu++17", "-O2", "-pipe", "-static", "-s", "-o", executable_filename] <NEW_LINE> command += source_filenames <NEW_LINE> return [command] | This defines the C++ programming language, compiled with g++ (the
version available on the system) using the C++17 standard. | 62599094ad47b63b2c5a958c |
class HeartbeatController(BaseController): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> super(HeartbeatController, self).__init__( NS_HEARTBEAT, target_platform=True) <NEW_LINE> <DEDENT> def receive_message(self, message, data): <NEW_LINE> <INDENT> if self._socket_client.is_stopped: <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> if data[MESSAGE_TYPE] == TYPE_PING: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> self._socket_client.send_message( PLATFORM_DESTINATION_ID, self.namespace, {MESSAGE_TYPE: TYPE_PONG}, no_add_request_id=True) <NEW_LINE> <DEDENT> except PyChromecastStopped: <NEW_LINE> <INDENT> self._socket_client.logger.exception( "Heartbeat error when sending response, " "Chromecast connection has stopped") <NEW_LINE> <DEDENT> return True <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return False | Controller to respond to heartbeat messages. | 6259909450812a4eaa621a6f |
class CIM_Foo_sub_sub_RejectDeleteProvider(InstanceWriteProvider): <NEW_LINE> <INDENT> provider_classnames = 'CIM_Foo_sub_sub' <NEW_LINE> def DeleteInstance(self, InstanceName): <NEW_LINE> <INDENT> raise CIMError( CIM_ERR_FAILED, "Deletion of {} instances is rejected". format(self.provider_classnames)) | Implements a user defined provider for the class CIM_Foo_sub_sub where
DeleteInstance is rejected with CIM_ERR_FAILED. | 62599094d8ef3951e32c8d05 |
class MP_PrintPlaylist(bpy.types.Operator): <NEW_LINE> <INDENT> bl_idname = "sound.printplaylist" <NEW_LINE> bl_label = "print playlist" <NEW_LINE> def execute(self, context): <NEW_LINE> <INDENT> pl = [a.playlist for a in context.scene.mp_playlist] <NEW_LINE> print ('Playlist: \n') <NEW_LINE> for i, p in enumerate(pl): <NEW_LINE> <INDENT> print (str(i+1)+ '.', p) <NEW_LINE> <DEDENT> return {'FINISHED'} | Print playlist | 625990947cff6e4e811b7794 |
class TestAddFileReplyPacket(object): <NEW_LINE> <INDENT> def test_get_message(self): <NEW_LINE> <INDENT> state = RET_SUCCESS <NEW_LINE> info = 'test infomation' <NEW_LINE> packet = AddFileReplyPacket(state, info) <NEW_LINE> msg = packet.get_message() <NEW_LINE> eq_(OP_ADD_FILE_REPLY, msg['method']) <NEW_LINE> eq_(state, msg['state']) <NEW_LINE> eq_(info, msg['info']) <NEW_LINE> state = RET_FAILURE <NEW_LINE> info = {'error id': 12, 'error msg': 'test error'} <NEW_LINE> packet = AddFileReplyPacket(state, info) <NEW_LINE> msg = packet.get_message() <NEW_LINE> eq_(OP_ADD_FILE_REPLY, msg['method']) <NEW_LINE> eq_(state, msg['state']) <NEW_LINE> eq_(info, msg['info']) | the add file packet | 62599094adb09d7d5dc0c2ac |
class PDFGrid(object): <NEW_LINE> <INDENT> def __init__(self, x, Q, xfgrid, flavors): <NEW_LINE> <INDENT> self.x = x <NEW_LINE> self.Q = Q <NEW_LINE> self.logx = np.log(self.x) <NEW_LINE> self.logQ2 = np.log(self.Q**2) <NEW_LINE> self.xfgrid = xfgrid <NEW_LINE> self.flavors = flavors <NEW_LINE> self._interpolators = {} <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def from_block(cls, block): <NEW_LINE> <INDENT> lines = block.splitlines() <NEW_LINE> x = np.loadtxt(StringIO(lines[0])) <NEW_LINE> Q = np.loadtxt(StringIO(lines[1])) <NEW_LINE> flavors = np.loadtxt(StringIO(lines[2]), dtype=int) <NEW_LINE> xfgrid = np.loadtxt(StringIO('\n'.join(lines[3:]))) <NEW_LINE> return cls(x, Q, xfgrid, flavors) <NEW_LINE> <DEDENT> def flav_index(self, flavor): <NEW_LINE> <INDENT> if flavor == 0: <NEW_LINE> <INDENT> return self.flav_index(21) <NEW_LINE> <DEDENT> if not np.isin(flavor, self.flavors): <NEW_LINE> <INDENT> raise ValueError("Flavor {} not contained in flavors {}".format(flavor, self.flavors)) <NEW_LINE> <DEDENT> i, = np.where(self.flavors == flavor) <NEW_LINE> return i <NEW_LINE> <DEDENT> def interpolator(self, flavor): <NEW_LINE> <INDENT> if flavor not in self._interpolators: <NEW_LINE> <INDENT> m = len(self.x) <NEW_LINE> n = len(self.Q) <NEW_LINE> i = self.flav_index(flavor) <NEW_LINE> self._interpolators[flavor] = MyRectBivariateSpline(self.logx, self.logQ2, self.xfgrid[:, i].reshape(m, n), bounds_error=False, fill_value=np.nan) <NEW_LINE> <DEDENT> return self._interpolators[flavor] <NEW_LINE> <DEDENT> def xfxQ2(self, flavor, x, Q2): <NEW_LINE> <INDENT> return self.interpolator(flavor)(np.log(x), np.log(Q2)) | Class representing an individual subgrid of a PDF in 'lhagrid1' format.
| 62599094283ffb24f3cf55ec |
class RequestStorage(object): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.queryset_stats = [] <NEW_LINE> <DEDENT> def add_queryset_storage_instance(self, queryset_storage): <NEW_LINE> <INDENT> self.queryset_stats.append(queryset_storage) <NEW_LINE> <DEDENT> @property <NEW_LINE> def total_wasted_memory(self): <NEW_LINE> <INDENT> wasted_memory = 0 <NEW_LINE> for qs_storage in self.queryset_stats: <NEW_LINE> <INDENT> wasted_memory += qs_storage.total_wasted_memory <NEW_LINE> <DEDENT> return wasted_memory <NEW_LINE> <DEDENT> def print_stats(self): <NEW_LINE> <INDENT> if not self.queryset_stats: <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> term.writeLine("\n\t ERASERHEAD STATS \n", term.bold, term.reverse) <NEW_LINE> for queryset_storage in self.queryset_stats: <NEW_LINE> <INDENT> queryset_storage.print_stats() <NEW_LINE> <DEDENT> print() <NEW_LINE> term.write("\t TOTAL WASTED MEMORY: ", term.bold, term.reverse) <NEW_LINE> term.write(" {}".format(humanfriendly.format_size(self.total_wasted_memory)), term.red) <NEW_LINE> print() | Stores statistics about single request | 62599094099cdd3c636762a3 |
class AnonymousSurvey(object): <NEW_LINE> <INDENT> def __init__(self, question): <NEW_LINE> <INDENT> self.question = question <NEW_LINE> self.responses = [] <NEW_LINE> <DEDENT> def show_question(self): <NEW_LINE> <INDENT> print(self.question) <NEW_LINE> <DEDENT> def store_responses(self, new_response): <NEW_LINE> <INDENT> self.responses.append(new_response) <NEW_LINE> <DEDENT> def show_results(self): <NEW_LINE> <INDENT> print("Survey results:") <NEW_LINE> for responses in self.responses: <NEW_LINE> <INDENT> print('- ' + responses) | 收集匿名调查问卷的答案 | 62599094dc8b845886d5530c |
class ChartError(Exception): <NEW_LINE> <INDENT> pass | Base chart exception. | 62599094adb09d7d5dc0c2b0 |
class DbDustDumpException(Exception): <NEW_LINE> <INDENT> pass | Base exception for all dump exception | 62599094099cdd3c636762a5 |
class Brand(BaseModel): <NEW_LINE> <INDENT> name = models.CharField(max_length=20, verbose_name='名称') <NEW_LINE> logo = models.ImageField(verbose_name='Logo图片') <NEW_LINE> first_letter = models.CharField(max_length=1, verbose_name='品牌首字母') <NEW_LINE> class Meta: <NEW_LINE> <INDENT> db_table = 'tb_brand' <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return self.name | 品牌 | 62599094d8ef3951e32c8d08 |
class PerMessageBzip2(PerMessageCompress, PerMessageBzip2Mixin): <NEW_LINE> <INDENT> DEFAULT_COMPRESS_LEVEL = 9 <NEW_LINE> @classmethod <NEW_LINE> def createFromResponseAccept(Klass, isServer, accept): <NEW_LINE> <INDENT> pmce = Klass(isServer, accept.response.s2c_max_compress_level, accept.compressLevel if accept.compressLevel is not None else accept.response.c2s_max_compress_level) <NEW_LINE> return pmce <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def createFromOfferAccept(Klass, isServer, accept): <NEW_LINE> <INDENT> pmce = Klass(isServer, accept.compressLevel if accept.compressLevel is not None else accept.offer.requestMaxCompressLevel, accept.requestMaxCompressLevel) <NEW_LINE> return pmce <NEW_LINE> <DEDENT> def __init__(self, isServer, s2c_max_compress_level, c2s_max_compress_level): <NEW_LINE> <INDENT> self._isServer = isServer <NEW_LINE> self._compressor = None <NEW_LINE> self._decompressor = None <NEW_LINE> self.s2c_max_compress_level = s2c_max_compress_level if s2c_max_compress_level != 0 else self.DEFAULT_COMPRESS_LEVEL <NEW_LINE> self.c2s_max_compress_level = c2s_max_compress_level if c2s_max_compress_level != 0 else self.DEFAULT_COMPRESS_LEVEL <NEW_LINE> <DEDENT> def __json__(self): <NEW_LINE> <INDENT> return {'extension': self.EXTENSION_NAME, 'isServer': self._isServer, 's2c_max_compress_level': self.s2c_max_compress_level, 'c2s_max_compress_level': self.c2s_max_compress_level} <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return "PerMessageBzip2(isServer = %s, s2c_max_compress_level = %s, c2s_max_compress_level = %s)" % (self._isServer, self.s2c_max_compress_level, self.c2s_max_compress_level) <NEW_LINE> <DEDENT> def startCompressMessage(self): <NEW_LINE> <INDENT> if self._isServer: <NEW_LINE> <INDENT> if self._compressor is None: <NEW_LINE> <INDENT> self._compressor = bz2.BZ2Compressor(self.s2c_max_compress_level) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> if self._compressor is None: <NEW_LINE> <INDENT> self._compressor = bz2.BZ2Compressor(self.c2s_max_compress_level) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def compressMessageData(self, data): <NEW_LINE> <INDENT> return self._compressor.compress(data) <NEW_LINE> <DEDENT> def endCompressMessage(self): <NEW_LINE> <INDENT> data = self._compressor.flush() <NEW_LINE> self._compressor = None <NEW_LINE> return data <NEW_LINE> <DEDENT> def startDecompressMessage(self): <NEW_LINE> <INDENT> if self._decompressor is None: <NEW_LINE> <INDENT> self._decompressor = bz2.BZ2Decompressor() <NEW_LINE> <DEDENT> <DEDENT> def decompressMessageData(self, data): <NEW_LINE> <INDENT> return self._decompressor.decompress(data) <NEW_LINE> <DEDENT> def endDecompressMessage(self): <NEW_LINE> <INDENT> self._decompressor = None | `permessage-bzip2` WebSocket extension processor. | 625990947cff6e4e811b779a |
class TestOrganizationExternalDatabaseTableColumnsPair(unittest.TestCase): <NEW_LINE> <INDENT> def setUp(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def tearDown(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def make_instance(self, include_optional): <NEW_LINE> <INDENT> if include_optional : <NEW_LINE> <INDENT> return OrganizationExternalDatabaseTableColumnsPair( table = openlattice.models.organization_external_database_table.OrganizationExternalDatabaseTable( id = '0', name = '0', title = '0', description = '0', organization_id = '0', ), columns = [ openlattice.models.organization_external_database_column.OrganizationExternalDatabaseColumn( id = '0', name = '0', title = '0', description = '0', table_id = '0', organization_id = '0', data_type = 'SMALLINT', primary_key = True, ordinal_position = 56, ) ] ) <NEW_LINE> <DEDENT> else : <NEW_LINE> <INDENT> return OrganizationExternalDatabaseTableColumnsPair( ) <NEW_LINE> <DEDENT> <DEDENT> def testOrganizationExternalDatabaseTableColumnsPair(self): <NEW_LINE> <INDENT> inst_req_only = self.make_instance(include_optional=False) <NEW_LINE> inst_req_and_optional = self.make_instance(include_optional=True) | OrganizationExternalDatabaseTableColumnsPair unit test stubs | 62599094dc8b845886d55310 |
class VoteSerializer(serializers.ModelSerializer): <NEW_LINE> <INDENT> answers = AnswerSerializer(many=True) <NEW_LINE> poll = PollSerializer(read_only=True) <NEW_LINE> poll_id = ObjectIDField( queryset=Poll.objects.filter(end_date__gte=datetime.date.today()), write_only=True ) <NEW_LINE> class Meta: <NEW_LINE> <INDENT> model = Vote <NEW_LINE> fields = ('id', 'poll_id', 'poll', 'user', 'date', 'answers') <NEW_LINE> read_only_fields = ('id', 'user', 'date') <NEW_LINE> <DEDENT> def create(self, validated_data): <NEW_LINE> <INDENT> answers = validated_data.pop('answers', []) <NEW_LINE> instance = Vote.objects.create(**validated_data) <NEW_LINE> Answer.objects.bulk_create([ Answer(vote=instance, **a) for a in answers ]) <NEW_LINE> return instance | Vote on Poll read/write serializer. | 62599094adb09d7d5dc0c2b2 |
class AlignBottom(bpy.types.Operator): <NEW_LINE> <INDENT> bl_idname = "object.align_bottom" <NEW_LINE> bl_label = "Align Objects Horizontal Bottom" <NEW_LINE> bl_options = { 'REGISTER', 'UNDO' } <NEW_LINE> def execute(self, context): <NEW_LINE> <INDENT> scene = context.scene <NEW_LINE> bpy.ops.object.align(align_mode='OPT_1', relative_to='OPT_4', align_axis={'Y'}) <NEW_LINE> return {'FINISHED'} | Horizontal Bottom Align | 62599095dc8b845886d55314 |
class InvalidGradingValuesError(Exception): <NEW_LINE> <INDENT> pass | Raised when expecting a list of dictionaries of the
format:
{ count : int,
pct_credit : float
}
But got something bad | 62599095ad47b63b2c5a9591 |
class CombinedParentsChooser(ParentChooser): <NEW_LINE> <INDENT> thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') <NEW_LINE> __repr__ = _swig_repr <NEW_LINE> def __init__(self, fatherChooser: 'ParentChooser', motherChooser: 'ParentChooser', allowSelfing: 'bool'=True): <NEW_LINE> <INDENT> _simuPOP_lin.CombinedParentsChooser_swiginit(self, _simuPOP_lin.new_CombinedParentsChooser(fatherChooser, motherChooser, allowSelfing)) <NEW_LINE> <DEDENT> __swig_destroy__ = _simuPOP_lin.delete_CombinedParentsChooser | Details:
This parent chooser accepts two parent choosers. It takes one
parent from each parent chooser and return them as father and
mother. Because two parent choosers do not have to choose parents
from the same virtual subpopulation, this parent chooser allows
you to choose parents from different subpopulations. | 62599095091ae35668706990 |
class TestMin(TestSymbolic): <NEW_LINE> <INDENT> def test_overload(self): <NEW_LINE> <INDENT> A, B, C, n1, n2, n3 = self.A, self.B, self.C, self.n1, self.n2, self.n3 <NEW_LINE> self.assertEqual(min(A, B), Min(A, B)) <NEW_LINE> self.assertEqual(min(A + B), Min(A + B)) <NEW_LINE> <DEDENT> def test_simplify(self): <NEW_LINE> <INDENT> A, B, C, n1, n2, n3 = self.A, self.B, self.C, self.n1, self.n2, self.n3 <NEW_LINE> self.assertEqual(min(min(A, B), C)(), min(A, min(B, C))()) <NEW_LINE> self.assertEqual(Min(A)(), A) <NEW_LINE> self.assertEqual(Min()(), None) <NEW_LINE> self.assertEqual(Min(n1, n2)(), __builtin__.min(n1, n2)) <NEW_LINE> <DEDENT> def test_str(self): <NEW_LINE> <INDENT> A, B, C, n1, n2, n3 = self.A, self.B, self.C, self.n1, self.n2, self.n3 <NEW_LINE> self.assertEqual(str(min(A + B)), "min(A + B)") <NEW_LINE> self.assertEqual(str(min(A, B)), "min(A, B)") | Tests for Min. | 62599095dc8b845886d55316 |
class TodoSerializer(serializers.ModelSerializer): <NEW_LINE> <INDENT> id = serializers.UUIDField(read_only=True) <NEW_LINE> title = serializers.CharField(default='') <NEW_LINE> description = serializers.CharField(required=True) <NEW_LINE> completed = serializers.BooleanField(default=False) <NEW_LINE> class Meta: <NEW_LINE> <INDENT> model = Todo <NEW_LINE> fields = ('id', 'title', 'description', 'completed') | Converts the model into JSON a json object. | 62599095283ffb24f3cf55f8 |
class ParametricRegressor(SemiParametricRegressor): <NEW_LINE> <INDENT> def __init__(self, regressor, features, appearance_model, transform, update='composition'): <NEW_LINE> <INDENT> super(ParametricRegressor, self).__init__( regressor, features, transform, update=update) <NEW_LINE> self.appearance_model = appearance_model <NEW_LINE> self.template = appearance_model.mean <NEW_LINE> <DEDENT> @property <NEW_LINE> def algorithm(self): <NEW_LINE> <INDENT> return "Parametric" <NEW_LINE> <DEDENT> def _create_fitting_result(self, image, parameters, gt_shape=None): <NEW_LINE> <INDENT> self.transform.from_vector_inplace(parameters) <NEW_LINE> return ParametricFittingResult( image, self, parameters=[self.transform.as_vector()], gt_shape=gt_shape) | Fitter of Parametric Regressor.
Parameters
----------
regressor: function/closure
The regressor to be used from
`menpo.fit.regression.regressionfunctions.py`.
features:
The features used to regress. | 625990955fdd1c0f98e5fcd4 |
@dataclass <NEW_LINE> class AirlySensorEntityDescription(SensorEntityDescription): <NEW_LINE> <INDENT> value: Callable = round | Class describing Airly sensor entities. | 62599095be7bc26dc9252d05 |
class Cmd_Multiview_List_Test(CmdTestCase): <NEW_LINE> <INDENT> @set_storage(extras=['host','plugin','source']) <NEW_LINE> def setUp(self): <NEW_LINE> <INDENT> super(Cmd_Multiview_List_Test, self).setUp() <NEW_LINE> <DEDENT> def test_empty_list(self): <NEW_LINE> <INDENT> argv = ['', 'multiview', 'list'] <NEW_LINE> Command().run_from_argv(argv) <NEW_LINE> out = self.stdout.getvalue() <NEW_LINE> self.assertTrue(out, "No output.") <NEW_LINE> self.assertIn("Count: 0", out, "Output isn't showing total count.") <NEW_LINE> <DEDENT> def test_list(self): <NEW_LINE> <INDENT> self.multiview = create_multiview() <NEW_LINE> argv = ['', 'multiview', 'list'] <NEW_LINE> Command().run_from_argv(argv) <NEW_LINE> out = self.stdout.getvalue() <NEW_LINE> self.assertTrue(out, "No output.") <NEW_LINE> self.assertIn("Count: 1", out, "Output isn't showing total count.") | Test ``manage.py multiview list``. | 62599095283ffb24f3cf55fa |
class QuadFcnOnSphere(EqConstDeclarativeNode): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> super().__init__() <NEW_LINE> <DEDENT> def objective(self, x, y): <NEW_LINE> <INDENT> return 0.5 * torch.einsum('bm,bm->b', (y, y)) - torch.einsum('bm,bm->b', (y, x)) <NEW_LINE> <DEDENT> def equality_constraints(self, x, y): <NEW_LINE> <INDENT> return torch.einsum('bm,bm->b', (y, y)) - 1.0 <NEW_LINE> <DEDENT> def solve(self, x): <NEW_LINE> <INDENT> y = x / torch.sqrt(torch.einsum('bm,bm->b', (x, x))).unsqueeze(-1) <NEW_LINE> return y, None <NEW_LINE> <DEDENT> def gradient(self, x, y=None, v=None, ctx=None): <NEW_LINE> <INDENT> x = x.detach() <NEW_LINE> if v is None: <NEW_LINE> <INDENT> v = torch.ones_like(x) <NEW_LINE> <DEDENT> x_inner = torch.einsum('bm,bm->b', (x, x)) <NEW_LINE> x_outer = torch.einsum('bm,bn->bmn', (x, x)) <NEW_LINE> eye_batch = torch.eye(x.size(1), dtype=x.dtype, device=x.device).expand_as(x_outer) <NEW_LINE> Dy_at_x = (torch.einsum('b,bmn->bmn', (x_inner, eye_batch)) - x_outer) / torch.pow(torch.einsum('bm,bm->b', (x, x)), 1.5).unsqueeze(-1).unsqueeze(-1) <NEW_LINE> return torch.einsum('bm,bmn->bn', (v, Dy_at_x)), | Solves the problem
minimize f(x, y) = 0.5 * y^Ty - x^T y
subject to h(y) = \|y\|^2 = 1 | 6259909550812a4eaa621a78 |
class AbstractResponseInterceptor(object): <NEW_LINE> <INDENT> __metaclass__ = ABCMeta <NEW_LINE> @abstractmethod <NEW_LINE> def process(self, handler_input, response): <NEW_LINE> <INDENT> pass | Interceptor that runs after the handler is called.
The process method has to be implemented, to run custom logic on
the input and the response generated after the handler is executed
on the input. | 62599095d8ef3951e32c8d0e |
class RegexTransformBase(object): <NEW_LINE> <INDENT> regexes = {} <NEW_LINE> def __init__(self): <NEW_LINE> <INDENT> if not hasattr(self.__class__, '_compiled'): <NEW_LINE> <INDENT> self.__class__._compiled = self.compile() <NEW_LINE> <DEDENT> <DEDENT> def compile(self): <NEW_LINE> <INDENT> c = {} <NEW_LINE> for cls in self.__class__.__mro__: <NEW_LINE> <INDENT> if cls is RegexTransformBase: <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> for uncompiled, handler in cls.regexes.iteritems(): <NEW_LINE> <INDENT> if type(uncompiled) in types.StringTypes: <NEW_LINE> <INDENT> compiled = re.compile(uncompiled) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> compiled = uncompiled <NEW_LINE> <DEDENT> c[compiled] = handler <NEW_LINE> <DEDENT> <DEDENT> return c <NEW_LINE> <DEDENT> def apply(self, tree, memo={}): <NEW_LINE> <INDENT> if type(tree) is tuple or type(tree) is list: <NEW_LINE> <INDENT> return [self.apply(item, memo) for item in tree] <NEW_LINE> <DEDENT> elif type(tree) in types.StringTypes: <NEW_LINE> <INDENT> memo = dict(memo) <NEW_LINE> for regex, handler in self.__class__._compiled.iteritems(): <NEW_LINE> <INDENT> if regex in memo: <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> memo[regex] = 1 <NEW_LINE> results = [] <NEW_LINE> allStrings = True <NEW_LINE> lastMatch = None <NEW_LINE> for match in regex.finditer(tree): <NEW_LINE> <INDENT> if lastMatch: <NEW_LINE> <INDENT> start = lastMatch.end() <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> start = 0 <NEW_LINE> <DEDENT> results.append(tree[start:match.start()]) <NEW_LINE> transformed = handler(self, match) <NEW_LINE> results.append(transformed) <NEW_LINE> if type(transformed) not in types.StringTypes: <NEW_LINE> <INDENT> allStrings = False <NEW_LINE> <DEDENT> lastMatch = match <NEW_LINE> <DEDENT> if lastMatch: <NEW_LINE> <INDENT> results.append(tree[lastMatch.end():]) <NEW_LINE> if allStrings: <NEW_LINE> <INDENT> tree = "".join(results) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return [self.apply(item, memo) for item in results] <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> return tree <NEW_LINE> <DEDENT> elif isinstance(tree, Nouvelle.tag): <NEW_LINE> <INDENT> return tree[self.apply(tree.content, memo)] <NEW_LINE> <DEDENT> return tree | Abstract base class for regex transformation engines. Subclasses
must provide their own 'regexes' dictionary, mapping regex
strings or compiled regexes to member functions. The constructor
for this class walks through the class' ancestors and compiles
regular expressions as necessary. | 62599095adb09d7d5dc0c2be |
class BadArguments(PasswordManagerException): <NEW_LINE> <INDENT> pass | Bad arguments passed to command | 62599095f9cc0f698b1c617f |
class BLENDYN_PT_active_object(BLENDYN_PT_tool_bar, bpy.types.Panel): <NEW_LINE> <INDENT> bl_idname = "BLENDYN_PT_active_object" <NEW_LINE> bl_label = "Active Object info" <NEW_LINE> bl_options = {'DEFAULT_CLOSED'} <NEW_LINE> def draw(self, context): <NEW_LINE> <INDENT> layout = self.layout <NEW_LINE> obj = context.object <NEW_LINE> mbs = context.scene.mbdyn <NEW_LINE> nd = mbs.nodes <NEW_LINE> ed = mbs.elems <NEW_LINE> rd = mbs.references <NEW_LINE> if bpy.context.active_object: <NEW_LINE> <INDENT> col = layout.column() <NEW_LINE> row = col.row() <NEW_LINE> row.label(text = "Active Object") <NEW_LINE> row = col.row() <NEW_LINE> try: <NEW_LINE> <INDENT> row.prop(obj, "name") <NEW_LINE> node = [node for node in nd if node.blender_object == obj.name] <NEW_LINE> if node: <NEW_LINE> <INDENT> row = col.row() <NEW_LINE> col = layout.column(align=True) <NEW_LINE> col.prop(node[0], "int_label") <NEW_LINE> col = layout.column(align=True) <NEW_LINE> col.prop(node[0], "string_label", text="") <NEW_LINE> col.prop(node[0], "parametrization", text="") <NEW_LINE> col.enabled = False <NEW_LINE> return <NEW_LINE> <DEDENT> elem = [elem for elem in ed if elem.blender_object == obj.name] <NEW_LINE> if elem: <NEW_LINE> <INDENT> row = layout.row() <NEW_LINE> row.label(text = "MBDyn's element info:") <NEW_LINE> eval(elem[0].info_draw + "(elem[0], layout)") <NEW_LINE> if elem[0].update_info_operator != 'none' and elem[0].is_imported == True: <NEW_LINE> <INDENT> row = layout.row() <NEW_LINE> row.operator(elem[0].update_info_operator, text = "Update element info").elem_key = elem[0].name <NEW_LINE> <DEDENT> if elem[0].write_operator != 'none' and elem[0].is_imported == True: <NEW_LINE> <INDENT> row = layout.row() <NEW_LINE> row.operator(elem[0].write_operator, text = "Write element input").elem_key = elem[0].name <NEW_LINE> <DEDENT> return <NEW_LINE> <DEDENT> ref = [ref for ref in rd if node.blender_object == obj.name] <NEW_LINE> if ref: <NEW_LINE> <INDENT> reference_info_draw(ref[0], layout) <NEW_LINE> return <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> <DEDENT> except AttributeError: <NEW_LINE> <INDENT> row.label(text = "No active objects") <NEW_LINE> pass <NEW_LINE> <DEDENT> except TypeError: <NEW_LINE> <INDENT> pass | Visualizes MBDyn data relative to the current active object - Toolbar Panel | 62599095091ae3566870699a |
class Json(dict, HttpBody): <NEW_LINE> <INDENT> content_type = 'application/json' <NEW_LINE> def __init__(self, d=None): <NEW_LINE> <INDENT> if d is not None: <NEW_LINE> <INDENT> self.update(d) <NEW_LINE> <DEDENT> <DEDENT> def dumps(self, serializer=None): <NEW_LINE> <INDENT> return json.dumps(self) <NEW_LINE> <DEDENT> def loads(self, data, confs=None, serializer=None): <NEW_LINE> <INDENT> d = json.loads(data) <NEW_LINE> self.clear() <NEW_LINE> self.update(d) <NEW_LINE> <DEDENT> def matched_content_type(self, content_type): <NEW_LINE> <INDENT> data_type = content_type.split("/")[-1] <NEW_LINE> return "json" in data_type | json http body
| 6259909560cbc95b06365c1d |
class Timeout: <NEW_LINE> <INDENT> def __init__(self, timeout, error_message, warn=False): <NEW_LINE> <INDENT> self.start = None <NEW_LINE> self.running = False <NEW_LINE> self.timeout = timeout <NEW_LINE> self.error_message = error_message <NEW_LINE> self.warn = warn <NEW_LINE> self.exception = TimeoutException(self.error_message) <NEW_LINE> <DEDENT> def run(self): <NEW_LINE> <INDENT> if not self.running: <NEW_LINE> <INDENT> self.start = datetime.datetime.now() <NEW_LINE> self.running = True <NEW_LINE> <DEDENT> if ( self.start + datetime.timedelta(seconds=self.timeout) < datetime.datetime.now() ): <NEW_LINE> <INDENT> if self.warn: <NEW_LINE> <INDENT> warnings.warn(self.error_message) <NEW_LINE> return False <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise self.exception <NEW_LINE> <DEDENT> <DEDENT> return True <NEW_LINE> <DEDENT> def set_exception(self, e): <NEW_LINE> <INDENT> self.exception = e | A timeout object for use in ``while True`` loops instead of ``True``.
Create an instance of this class before beginning an infinite loop and
call ``run()`` instead of ``True``.
Parameters
----------
timeout: int
Seconds before loop should timeout.
error_message: str
Error message to raise in an exception if timeout occurs.
warn: bool
Only raise a warning instead of a TimeoutException.
Default ``False``.
Examples
--------
>>> timeout = Timeout(10, "Oh no! We timed out.")
>>> while timeout.run():
... time.sleep(1) # Will timeout after 10 iterations
TimeoutException: Oh no! We timed out.
You can also pass an exception to raise if you are supressing for a set
amount of time.
>>> timeout = Timeout(10, "Oh no! We timed out.")
>>> while timeout.run():
... try:
... some_function_that_raises()
... break
... except Exception as e:
... timeout.set_exception(e)
... time.sleep(1) # Will timeout after 10 iterations
Exception: The exception from ``some_function_that_raises`` | 62599095f9cc0f698b1c6181 |
class ApplicationError(Exception): <NEW_LINE> <INDENT> pass | ApplicationError raises when an error occurs
| 625990958a349b6b43687fcc |
class MysqlColumn(Column): <NEW_LINE> <INDENT> def __init__(self, name, field_class, raw_column_type, nullable, primary_key=False, column_name=None, index=False, unique=False, default=None, extra_parameters=None, help_text=''): <NEW_LINE> <INDENT> super(MysqlColumn, self).__init__(name, field_class, raw_column_type, nullable, primary_key=primary_key, column_name=column_name, index=index, unique=unique, default=default, extra_parameters=extra_parameters) <NEW_LINE> self.help_text = help_text <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> attrs = [ 'field_class', 'raw_column_type', 'nullable', 'primary_key', 'column_name', 'default', 'help_text', ] <NEW_LINE> keyword_args = ', '.join( '%s=%s' % (attr, getattr(self, attr)) for attr in attrs) <NEW_LINE> return 'Column(%s, %s)' % (self.name, keyword_args) <NEW_LINE> <DEDENT> def get_field_parameters(self): <NEW_LINE> <INDENT> params = {} <NEW_LINE> if self.extra_parameters is not None: <NEW_LINE> <INDENT> params.update(self.extra_parameters) <NEW_LINE> <DEDENT> if self.nullable: <NEW_LINE> <INDENT> params['null'] = True <NEW_LINE> <DEDENT> if self.field_class is ForeignKeyField or self.name != self.column_name: <NEW_LINE> <INDENT> params['column_name'] = "'%s'" % self.column_name <NEW_LINE> <DEDENT> if self.primary_key and not issubclass(self.field_class, AutoField): <NEW_LINE> <INDENT> params['primary_key'] = True <NEW_LINE> <DEDENT> if self.default is not None: <NEW_LINE> <INDENT> params['constraints'] = '[SQL("DEFAULT %s")]' % self.default <NEW_LINE> <DEDENT> if self.is_foreign_key(): <NEW_LINE> <INDENT> params['model'] = self.rel_model <NEW_LINE> if self.to_field: <NEW_LINE> <INDENT> params['field'] = "'%s'" % self.to_field <NEW_LINE> <DEDENT> if self.related_name: <NEW_LINE> <INDENT> params['backref'] = "'%s'" % self.related_name <NEW_LINE> <DEDENT> <DEDENT> if not self.is_primary_key(): <NEW_LINE> <INDENT> if self.unique: <NEW_LINE> <INDENT> params['unique'] = 'True' <NEW_LINE> <DEDENT> elif self.index and not self.is_foreign_key(): <NEW_LINE> <INDENT> params['index'] = 'True' <NEW_LINE> <DEDENT> <DEDENT> if self.help_text: <NEW_LINE> <INDENT> params['help_text'] = "'%s'" % self.help_text <NEW_LINE> <DEDENT> return params | Store metadata about a database column. | 62599095283ffb24f3cf5606 |
class TestModule(object): <NEW_LINE> <INDENT> def tests(self): <NEW_LINE> <INDENT> return { 'a_module': a_module, } | Ansible jinja2 tests | 62599095be7bc26dc9252d0c |
class pAdicRingLattice(pAdicLatticeGeneric, pAdicRingBaseGeneric): <NEW_LINE> <INDENT> def __init__(self, p, prec, subtype, print_mode, names, label=None): <NEW_LINE> <INDENT> self._subtype = subtype <NEW_LINE> if isinstance(prec,tuple): <NEW_LINE> <INDENT> pAdicRingBaseGeneric.__init__(self, p, prec[1], print_mode, names, None) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> pAdicRingBaseGeneric.__init__(self, p, prec, print_mode, names, None) <NEW_LINE> <DEDENT> pAdicLatticeGeneric.__init__(self, p, prec, print_mode, names, label) <NEW_LINE> <DEDENT> def _coerce_map_from_(self, R): <NEW_LINE> <INDENT> if isinstance(R, pAdicRingLattice) and R.precision() is self.precision(): <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> <DEDENT> def random_element(self, prec=None): <NEW_LINE> <INDENT> p = self.prime() <NEW_LINE> if self._subtype == 'cap': <NEW_LINE> <INDENT> if prec is None: <NEW_LINE> <INDENT> prec = self._prec_cap_absolute <NEW_LINE> <DEDENT> x = ZZ.random_element(p**prec) <NEW_LINE> relcap = x.valuation(p) + self._prec_cap_relative <NEW_LINE> if relcap < prec: <NEW_LINE> <INDENT> prec = relcap <NEW_LINE> <DEDENT> return self._element_class(self, x, prec=prec) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> if prec is None: <NEW_LINE> <INDENT> cap = self._prec_cap_relative <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> cap = prec <NEW_LINE> <DEDENT> x = ZZ.random_element(p**cap) <NEW_LINE> v = x.valuation(p) <NEW_LINE> if prec is None and v > 0: <NEW_LINE> <INDENT> x += p**cap * ZZ.random_element(p**v) <NEW_LINE> <DEDENT> return self._element_class(self, x, prec=prec) | An implementation of the `p`-adic integers with lattice precision.
INPUT:
- ``p`` -- prime
- ``prec`` -- precision cap, given as a pair (``relative_cap``, ``absolute_cap``)
- ``subtype`` -- either ``'cap'`` or ``'float'``
- ``print_mode`` -- dictionary with print options
- ``names`` -- how to print the prime
- ``label`` -- the label of this ring
.. SEEALSO::
:meth:`label`
EXAMPLES::
sage: R = ZpLC(next_prime(10^60)) # indirect doctest
doctest:...: FutureWarning: This class/method/function is marked as experimental. It, its functionality or its interface might change without a formal deprecation.
See http://trac.sagemath.org/23505 for details.
sage: type(R)
<class 'sage.rings.padics.padic_base_leaves.pAdicRingLattice_with_category'>
sage: R = ZpLC(2, label='init') # indirect doctest
sage: R
2-adic Ring with lattice-cap precision (label: init) | 62599095f9cc0f698b1c6182 |
class Publish(ndb.Model): <NEW_LINE> <INDENT> STATUSES = ('new', 'complete', 'failed') <NEW_LINE> _use_cache = False <NEW_LINE> _use_memcache = False <NEW_LINE> type = ndb.StringProperty(choices=TYPES) <NEW_LINE> type_label = ndb.StringProperty() <NEW_LINE> status = ndb.StringProperty(choices=STATUSES, default='new') <NEW_LINE> source = ndb.KeyProperty() <NEW_LINE> html = ndb.TextProperty() <NEW_LINE> published = ndb.JsonProperty(compressed=True) <NEW_LINE> created = ndb.DateTimeProperty(auto_now_add=True) <NEW_LINE> updated = ndb.DateTimeProperty(auto_now=True) | A comment, like, repost, or RSVP published into a silo.
Child of a PublishedPage entity. | 625990955fdd1c0f98e5fce3 |
class CanIsoTpSocket: <NEW_LINE> <INDENT> def __init__(self, interface: str, rx_addr: int, tx_addr: int): <NEW_LINE> <INDENT> self.s = socket.socket(socket.AF_CAN,socket.SOCK_DGRAM,socket.CAN_ISOTP) <NEW_LINE> self.s.bind((interface, rx_addr, tx_addr)) <NEW_LINE> <DEDENT> def __del__(self): <NEW_LINE> <INDENT> self.s.close() <NEW_LINE> <DEDENT> def send(self, data: bytes): <NEW_LINE> <INDENT> return self.s.send(data) <NEW_LINE> <DEDENT> def recv(self, bufsize: int): <NEW_LINE> <INDENT> return self.s.recv(bufsize) | A socket to IsoTp
@param interface: name
@param rx_addr: the can_id that is received
@param tx_addr: the can_id that is transmitted | 62599095be7bc26dc9252d0d |
class MongoConfiguration(Configuration): <NEW_LINE> <INDENT> schema = Schema("mongo", definition={ "datas": Data("the collection's to store datas", default="datas"), "increments": Data("the collection's to store auto increments", default="increments"), }) <NEW_LINE> default_file = "dc/mongo/parameters.yml" | Class defining the default configuration for the Mongo DC. | 625990957cff6e4e811b77b2 |
class _DevelopmentWE(WebElement): <NEW_LINE> <INDENT> def __init__(self, element, driver): <NEW_LINE> <INDENT> super(_DevelopmentWE, self).__init__(element) <NEW_LINE> self._d = driver <NEW_LINE> <DEDENT> @property <NEW_LINE> def web_development(self): <NEW_LINE> <INDENT> e = self.find_element_by_locator("class=ud_web-development") <NEW_LINE> e.click() <NEW_LINE> return WebDevelopment(self._d).wait_until_loaded() | In case of hover, DevelopmentWebElement will expose
all sub categories as properties | 62599095d8ef3951e32c8d15 |
class ResourceLoader(Loader): <NEW_LINE> <INDENT> @abc.abstractmethod <NEW_LINE> def get_data(self, path): <NEW_LINE> <INDENT> raise NotImplementedError | Abstract base class for loaders which can return data from their
back-end storage.
This ABC represents one of the optional protocols specified by PEP 302. | 625990958a349b6b43687fd2 |
class Pitch(db.Model): <NEW_LINE> <INDENT> __tablename__ = "pitches" <NEW_LINE> id = db.Column(db.Integer, primary_key = True) <NEW_LINE> title = db.Column(db.String) <NEW_LINE> content = db.Column(db.String) <NEW_LINE> category = db.Column(db.String) <NEW_LINE> date = db.Column(db.String) <NEW_LINE> time = db.Column(db.String) <NEW_LINE> user_id = db.Column(db.Integer, db.ForeignKey("users.id")) <NEW_LINE> comments = db.relationship("Comment", backref = "pitch", lazy = "dynamic") <NEW_LINE> def save_pitch(self): <NEW_LINE> <INDENT> db.session.add(self) <NEW_LINE> db.session.commit() <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def get_pitch_comments(self): <NEW_LINE> <INDENT> pitch = Pitch.query.filter_by(id = self.id).first() <NEW_LINE> comments = Comment.query.filter_by(pitch_id = pitch.id).order_by(Comment.time.desc()) <NEW_LINE> return comments | This is the class which we will use to create the pitches for the app | 625990953617ad0b5ee07ec3 |
class DeploymentmanagerTypesListRequest(_messages.Message): <NEW_LINE> <INDENT> filter = _messages.StringField(1) <NEW_LINE> maxResults = _messages.IntegerField(2, variant=_messages.Variant.UINT32, default=500) <NEW_LINE> pageToken = _messages.StringField(3) <NEW_LINE> project = _messages.StringField(4, required=True) | A DeploymentmanagerTypesListRequest object.
Fields:
filter: Sets a filter expression for filtering listed resources, in the
form filter={expression}. Your {expression} must be in the format:
field_name comparison_string literal_string. The field_name is the name
of the field you want to compare. Only atomic field types are supported
(string, number, boolean). The comparison_string must be either eq
(equals) or ne (not equals). The literal_string is the string value to
filter to. The literal value must be valid for the type of field you are
filtering by (string, number, boolean). For string fields, the literal
value is interpreted as a regular expression using RE2 syntax. The
literal value must match the entire field. For example, to filter for
instances whose name is not equal to example-instance, you would use
filter=name ne example-instance. Compute Engine Beta API Only: If you
use filtering in the Beta API, you can also filter on nested fields. For
example, you could filter on instances that have set the
scheduling.automaticRestart field to true. In particular, use filtering
on nested fields to take advantage of instance labels to organize and
filter results based on label values. The Beta API also supports
filtering on multiple expressions by providing each separate expression
within parentheses. For example, (scheduling.automaticRestart eq true)
(zone eq us-central1-f). Multiple expressions are treated as AND
expressions meaning that resources must match all expressions to pass
the filters.
maxResults: The maximum number of results per page that should be
returned. If the number of available results is larger than maxResults,
Compute Engine returns a nextPageToken that can be used to get the next
page of results in subsequent list requests.
pageToken: Specifies a page token to use. Set pageToken to the
nextPageToken returned by a previous list request to get the next page
of results.
project: The project ID for this request. | 62599095adb09d7d5dc0c2ce |
class UnboundedBucketCeiling(MaturityBucketCeiling): <NEW_LINE> <INDENT> def __init__(self, description=None): <NEW_LINE> <INDENT> super(UnboundedBucketCeiling, self).__init__( periods=1, description=description) <NEW_LINE> <DEDENT> def ceiling_string(self): <NEW_LINE> <INDENT> return "unbounded" <NEW_LINE> <DEDENT> def display(self, prefix=""): <NEW_LINE> <INDENT> return prefix + "time to maturity unbounded" <NEW_LINE> <DEDENT> @property <NEW_LINE> def period_name(self): <NEW_LINE> <INDENT> return "unbounded" <NEW_LINE> <DEDENT> def end_date_from(self, base_date): <NEW_LINE> <INDENT> return None | This ceiling would used as a catch all.
For example, Interest Rate Derivatives / Swaptions have a time to maturuty
bucket for the option which is "over 10 years".
... so this class will be developed when we need to implement Interest Rate Derivatives / Swaptions | 62599095283ffb24f3cf560e |
class InvalidSimpleArchive(InvalidArchive): <NEW_LINE> <INDENT> pass | The simple archive appears to be invalid. | 62599095091ae356687069a6 |
class HTTPServerHandler(BaseHTTPRequestHandler): <NEW_LINE> <INDENT> def __init__(self, request, address, server, access_uri): <NEW_LINE> <INDENT> self.access_uri = access_uri <NEW_LINE> BaseHTTPRequestHandler.__init__(self, request, address, server) <NEW_LINE> <DEDENT> def do_GET(self): <NEW_LINE> <INDENT> self.send_response(200) <NEW_LINE> self.send_header('Content-type', 'text/html') <NEW_LINE> self.end_headers() <NEW_LINE> if 'code' in self.path: <NEW_LINE> <INDENT> self.auth_code = self.path.split('=')[1] <NEW_LINE> self.wfile.write(bytes('<html><h1>You may now close this window.' + '</h1></html>', 'utf-8')) <NEW_LINE> self.server.access_token = self.auth_code <NEW_LINE> <DEDENT> <DEDENT> def log_message(self, format, *args): <NEW_LINE> <INDENT> return | HTTP Server callbacks to handle Box OAuth redirects | 62599095c4546d3d9def8158 |
class LogEntry(models.Model): <NEW_LINE> <INDENT> LOG_ENTRY_TYPES = ( ("AR", "Access Reqeust"), ("AG", "Access Granted"), ("ADL", "Access Denied Access Level"), ("ADR", "Access Denied Reservation"), ("ADM", "Access Denied Membership") ) <NEW_LINE> created_at = models.DateTimeField() <NEW_LINE> entry_type = models.CharField(max_length=3, choices=LOG_ENTRY_TYPES) <NEW_LINE> profile = models.ForeignKey(Profile, related_name='logEntries', null=False, default=0) <NEW_LINE> machine = models.ForeignKey(Machine, related_name='logEntries', null=False) | Log Entry
This model represents a log entry. | 62599095d8ef3951e32c8d18 |
Subsets and Splits