code
stringlengths 4
4.48k
| docstring
stringlengths 1
6.45k
| _id
stringlengths 24
24
|
|---|---|---|
class ModalBody(DWidgetT): <NEW_LINE> <INDENT> def __init__(self, body): <NEW_LINE> <INDENT> template = '<div class="modal-body">\n' ' {body}\n' '</div>\n' <NEW_LINE> super(ModalBody, self).__init__(template, {'body': body}) <NEW_LINE> return | Modal body definition
:param body: Modal body
:return: body HTML
:rtype: unicode | 6259908b283ffb24f3cf54b8 |
class ATM(EasyFrame): <NEW_LINE> <INDENT> def __init__(self, bank): <NEW_LINE> <INDENT> EasyFrame.__init__(self, title = "ATM") <NEW_LINE> self.bank = bank <NEW_LINE> self.account = None <NEW_LINE> self.nameLabel = self.addLabel(row = 0, column = 0, text = "Name") <NEW_LINE> self.pinLabel = self.addLabel(row = 1, column = 0, text = "PIN") <NEW_LINE> self.amountLabel = self.addLabel(row = 2, column = 0, text = "Amount") <NEW_LINE> self.statusLabel = self.addLabel(row = 3, column = 0, text = "Status") <NEW_LINE> self.nameField = self.addTextField(row = 0, column = 1, text = "") <NEW_LINE> self.pinField = self.addTextField(row = 1, column = 1, text = "") <NEW_LINE> self.amountField = self.addFloatField(row = 2, column = 1, value = 0.0) <NEW_LINE> self.statusField = self.addTextField(row = 3, column = 1, text = "Welcome to the Bank!", state = "readonly") <NEW_LINE> self.balanceButton = self.addButton(row = 0, column = 2, text = "Balance", command = self.getBalance, state = "disabled") <NEW_LINE> self.depositButton = self.addButton(row = 1, column = 2, text = "Deposit", command = self.deposit, state = "disabled") <NEW_LINE> self.withdrawButton = self.addButton(row = 2, column = 2, text = "Withdraw", command = self.withdraw, state = "disabled") <NEW_LINE> self.loginButton = self.addButton(row = 3, column = 2, text = "Login", command = self.login) <NEW_LINE> <DEDENT> def login(self): <NEW_LINE> <INDENT> name = self.nameField.getText() <NEW_LINE> pin = self.pinField.getText() <NEW_LINE> self.account = self.bank.get(name, pin) <NEW_LINE> if self.account: <NEW_LINE> <INDENT> self.statusField.setText("Hello, " + name + "!") <NEW_LINE> self.balanceButton["state"] = "normal" <NEW_LINE> self.depositButton["state"] = "normal" <NEW_LINE> self.withdrawButton["state"] = "normal" <NEW_LINE> self.loginButton["text"] = "Logout" <NEW_LINE> self.loginButton["command"] = self.logout <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.statusField.setText("Name and pin not found!") <NEW_LINE> <DEDENT> <DEDENT> def logout(self): <NEW_LINE> <INDENT> self.account = None <NEW_LINE> self.nameField.setText("") <NEW_LINE> self.pinField.setText("") <NEW_LINE> self.amountField.setNumber(0.0) <NEW_LINE> self.statusField.setText("Welcome to the Bank!") <NEW_LINE> self.balanceButton["state"] = "disabled" <NEW_LINE> self.depositButton["state"] = "disabled" <NEW_LINE> self.withdrawButton["state"] = "disabled" <NEW_LINE> self.loginButton["text"] = "Login" <NEW_LINE> self.loginButton["command"] = self.login <NEW_LINE> <DEDENT> def getBalance(self): <NEW_LINE> <INDENT> text = "Balance = $" + str(self.account.getBalance()) <NEW_LINE> self.statusField.setText(text) <NEW_LINE> <DEDENT> def deposit(self): <NEW_LINE> <INDENT> amount = self.amountField.getNumber() <NEW_LINE> message = self.account.deposit(amount) <NEW_LINE> if not message: <NEW_LINE> <INDENT> self.statusField.setText("Deposit successful") <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.statusField.setText(message) <NEW_LINE> <DEDENT> <DEDENT> def withdraw(self): <NEW_LINE> <INDENT> amount = self.amountField.getNumber() <NEW_LINE> message = self.account.withdraw(amount) <NEW_LINE> if not message: <NEW_LINE> <INDENT> self.statusField.setText("Withdrawal successful") <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.statusField.setText(message) | Represents an ATM window.
The window tracks the bank and the current account.
The current account is None at startup and logout. | 6259908be1aae11d1e7cf620 |
class LoginForm(Form): <NEW_LINE> <INDENT> card = StringField('Account', validators=[DataRequired(), Length(3, 8), Regexp('[0-9]', 0, 'Account must be numbers')]) <NEW_LINE> password = PasswordField('Password', validators=[DataRequired()]) <NEW_LINE> remember_me = BooleanField('Keep me logged in') <NEW_LINE> submit = SubmitField('Log In') | email = StringField('Email', validators=[DataRequired(), Length(1, 64),
Email()]) | 6259908bfff4ab517ebcf42f |
class TestModel_AddressIPAddress(): <NEW_LINE> <INDENT> def test_address_ip_address_serialization(self): <NEW_LINE> <INDENT> address_ip_address_model_json = {} <NEW_LINE> address_ip_address_model_json['type'] = 'ipAddress' <NEW_LINE> address_ip_address_model_json['value'] = 'testString' <NEW_LINE> address_ip_address_model = AddressIPAddress.from_dict(address_ip_address_model_json) <NEW_LINE> assert address_ip_address_model != False <NEW_LINE> address_ip_address_model_dict = AddressIPAddress.from_dict(address_ip_address_model_json).__dict__ <NEW_LINE> address_ip_address_model2 = AddressIPAddress(**address_ip_address_model_dict) <NEW_LINE> assert address_ip_address_model == address_ip_address_model2 <NEW_LINE> address_ip_address_model_json2 = address_ip_address_model.to_dict() <NEW_LINE> assert address_ip_address_model_json2 == address_ip_address_model_json | Test Class for AddressIPAddress | 6259908bec188e330fdfa4c7 |
class Libdivsufsort(CMakePackage): <NEW_LINE> <INDENT> homepage = "https://github.com/y-256/libdivsufsort" <NEW_LINE> url = "https://github.com/y-256/libdivsufsort/archive/2.0.1.tar.gz" <NEW_LINE> version('2.0.1', sha256='9164cb6044dcb6e430555721e3318d5a8f38871c2da9fd9256665746a69351e0') <NEW_LINE> def cmake_args(self): <NEW_LINE> <INDENT> args = ['-DBUILD_DIVSUFSORT64=ON'] <NEW_LINE> return args | libdivsufsort is a software library that implements a
lightweight suffix array construction algorithm. | 6259908b167d2b6e312b83a4 |
@endpoints.api(name='rol', version='v1') <NEW_LINE> class RolApi(remote.Service): <NEW_LINE> <INDENT> @endpoints.method(message_types.VoidMessage, RolMessage, path='rol', http_method='GET', name='rol') <NEW_LINE> def greetings_list(self, _): <NEW_LINE> <INDENT> return RolMessage(text=generate_rol()) | Reflection on Learning API v1. | 6259908b283ffb24f3cf54b9 |
class DualWiseOpKernel: <NEW_LINE> <INDENT> def get_forward_kernel_text(self): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> def get_backward_A_kernel_text(self): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> def get_backward_B_kernel_text(self): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> def get_op_name(self): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> def __str__(self): return f'DualWiseOpKernel ({self.get_op_name()})' <NEW_LINE> def __repr__(self): return self.__str__() | Base class for kernels to use in dual_wise_op() | 6259908b55399d3f0562812e |
class Venues(ViewSet): <NEW_LINE> <INDENT> permission_classes= [ IsOwnerOrReadOnly ] <NEW_LINE> def list(self, request): <NEW_LINE> <INDENT> venues = Venue.objects.all() <NEW_LINE> serializer = VenueSerializer(venues, many=True, context={'request': request}) <NEW_LINE> return Response(serializer.data) <NEW_LINE> <DEDENT> def update(self, request, pk=None): <NEW_LINE> <INDENT> venue = Venue.objects.get(user=request.auth.user) <NEW_LINE> venue.user.username = request.data['username'] <NEW_LINE> venue.user.first_name = request.data['first_name'] <NEW_LINE> venue.user.last_name = request.data['last_name'] <NEW_LINE> venue.user.email = request.data['email'] <NEW_LINE> venue.venue_name = request.data['venue_name'] <NEW_LINE> venue.address = request.data['address'] <NEW_LINE> venue.booking_info = request.data['booking_info'] <NEW_LINE> venue.description = request.data['description'] <NEW_LINE> venue.is_all_ages = request.data['is_all_ages'] <NEW_LINE> venue.has_backline = request.data['has_backline'] <NEW_LINE> venue.website = request.data['website'] <NEW_LINE> if "photos" in request.data and request.data['photos'] is not None: <NEW_LINE> <INDENT> if ";base64" in request.data["photos"]: <NEW_LINE> <INDENT> format, imgstr = request.data['photos'].split(';base64,') <NEW_LINE> ext = format.split('/')[-1] <NEW_LINE> data = ContentFile(base64.b64decode(imgstr), name=f"{venue.id}-{request.data['venue_name']}.{ext}") <NEW_LINE> venue.photos = data <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> junk, file = request.data["photos"].split('http://localhost:8000/media') <NEW_LINE> venue.photos = file <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> venue.photos = None <NEW_LINE> <DEDENT> venue.user.save() <NEW_LINE> venue.save() <NEW_LINE> return Response({}, status=status.HTTP_204_NO_CONTENT) <NEW_LINE> <DEDENT> def retrieve(self,request,pk=None): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> venue = Venue.objects.get(pk=pk) <NEW_LINE> serializer = VenueSerializer(venue, many=False, context={'request': request}) <NEW_LINE> return Response(serializer.data) <NEW_LINE> <DEDENT> except Venue.DoesNotExist as ex: <NEW_LINE> <INDENT> return Response( {"mesage": "The requested venue does not exist, or you do not have permission to access it"}, status=status.HTTP_404_NOT_FOUND ) <NEW_LINE> <DEDENT> except Exception as ex: <NEW_LINE> <INDENT> return HttpResponseServerError(ex) <NEW_LINE> <DEDENT> <DEDENT> def destroy(self, request, pk=None): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> venue = Venue.objects.get(pk=pk) <NEW_LINE> user = User.objects.get(pk=request.auth.user.id) <NEW_LINE> venue.delete() <NEW_LINE> user.delete() <NEW_LINE> return Response({}, status=status.HTTP_204_NO_CONTENT) <NEW_LINE> <DEDENT> except Venue.DoesNotExist as ex: <NEW_LINE> <INDENT> return Response({'message': ex.args[0]}, status=status.HTTP_404_NOT_FOUND) <NEW_LINE> <DEDENT> except Exception as ex: <NEW_LINE> <INDENT> return Response({"message": ex.args[0]}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) | Request handler for Venues in the EconoShows platform | 6259908b3346ee7daa33846f |
class FanInFanOut_ABC(Initialization_ABC) : <NEW_LINE> <INDENT> def __init__(self, parameter, forceGain=None, **kwargs) : <NEW_LINE> <INDENT> super(FanInFanOut_ABC, self).__init__(parameter, **kwargs) <NEW_LINE> self.setHP("forceGain", forceGain) <NEW_LINE> self.gain = None <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def _getGain(cls, activation) : <NEW_LINE> <INDENT> if activation.__class__ is MA.ReLU : <NEW_LINE> <INDENT> if activation.leakiness == 0 : <NEW_LINE> <INDENT> return numpy.sqrt(2) <NEW_LINE> <DEDENT> else : <NEW_LINE> <INDENT> return numpy.sqrt(2/(1+activation.leakiness**2)) <NEW_LINE> <DEDENT> <DEDENT> return 1.0 <NEW_LINE> <DEDENT> def setup(self, abstraction) : <NEW_LINE> <INDENT> self.gain = self._getGain(abstraction.abstractions["activation"]) <NEW_LINE> <DEDENT> def apply(self, abstraction) : <NEW_LINE> <INDENT> import Mariana.activations as MA <NEW_LINE> forceGain = self.getHP("forceGain") <NEW_LINE> if forceGain : <NEW_LINE> <INDENT> self.gain = forceGain <NEW_LINE> <DEDENT> else : <NEW_LINE> <INDENT> self.gain = self._getGain(abstraction.abstractions["activation"]) <NEW_LINE> <DEDENT> return super(FanInFanOut_ABC, self).apply(abstraction) | Abtract class for fan_in/_out inits (Glorot and He)
Over the time people have introduced
ways to make it work with other various activation functions by modifying a gain factor.
You can force the gain using the *forceGain* argument, otherwise Mariana will choose
one for you depending on the abstraction's activation.
* ReLU: sqrt(2)
* LeakyReLU: sqrt(2/(1+alpha**2)) where alpha is the leakiness
* Everything else : 1.0
This is an abtract class: see *GlorotNormal*, *GlorotUniform* | 6259908b4a966d76dd5f0b00 |
class XvfbStartException (Exception): <NEW_LINE> <INDENT> pass | Xvfb failed to start. | 6259908bfff4ab517ebcf431 |
class OffensiveReflexAgent(ReflexCaptureAgent): <NEW_LINE> <INDENT> def chooseAction(self, gameState): <NEW_LINE> <INDENT> actions = gameState.getLegalActions(self.index) <NEW_LINE> values = [self.evaluate(gameState, a) for a in actions] <NEW_LINE> maxValue = max(values) <NEW_LINE> bestActions = [a for a, v in zip(actions, values) if v == maxValue] <NEW_LINE> foodLeft = len(self.getFood(gameState).asList()) <NEW_LINE> successor = self.getSuccessor(gameState, Directions.STOP) <NEW_LINE> myState = successor.getAgentState(self.index) <NEW_LINE> if not myState.isPacman: <NEW_LINE> <INDENT> self.foodListCopy = list(self.getFood(gameState).asList()) <NEW_LINE> <DEDENT> if abs(foodLeft - len(self.foodListCopy)) > 2: <NEW_LINE> <INDENT> bestDist = 9999 <NEW_LINE> for action in actions: <NEW_LINE> <INDENT> successor = self.getSuccessor(gameState, action) <NEW_LINE> pos2 = successor.getAgentPosition(self.index) <NEW_LINE> dist = self.distancer.getDistance(self.start, pos2) <NEW_LINE> if dist < bestDist: <NEW_LINE> <INDENT> bestAction = action <NEW_LINE> bestDist = dist <NEW_LINE> <DEDENT> <DEDENT> return bestAction <NEW_LINE> <DEDENT> return bestActions[0] <NEW_LINE> <DEDENT> def getFeatures(self, gameState, action): <NEW_LINE> <INDENT> features = util.Counter() <NEW_LINE> successor = self.getSuccessor(gameState, action) <NEW_LINE> foodList = self.getFood(successor).asList() <NEW_LINE> features['successorScore'] = -len(foodList) <NEW_LINE> myState = successor.getAgentState(self.index) <NEW_LINE> myPos = myState.getPosition() <NEW_LINE> if len(foodList) > 0: <NEW_LINE> <INDENT> myPos = successor.getAgentState(self.index).getPosition() <NEW_LINE> minDistance = min([self.distancer.getDistance(myPos, food) for food in foodList]) <NEW_LINE> features['distanceToFood'] = minDistance <NEW_LINE> enemies = [successor.getAgentState(i) for i in self.getOpponents(successor)] <NEW_LINE> home_basers = [a for a in enemies if not a.isPacman and a.getPosition() != None] <NEW_LINE> team = [successor.getAgentState(i) for i in self.getTeam(successor)] <NEW_LINE> if len(home_basers) > 0: <NEW_LINE> <INDENT> smallest_dist = min([self.distancer.getDistance(myPos, x.getPosition()) for x in home_basers]) <NEW_LINE> if myState.isPacman: <NEW_LINE> <INDENT> features['closeToEvil'] = smallest_dist <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> features['closeToEvil'] = 0 <NEW_LINE> <DEDENT> <DEDENT> if myState.isPacman: <NEW_LINE> <INDENT> features['isPacman'] = 1 <NEW_LINE> <DEDENT> if action == Directions.STOP: <NEW_LINE> <INDENT> features['stopped'] = 1 <NEW_LINE> <DEDENT> <DEDENT> return features <NEW_LINE> <DEDENT> def getWeights(self, gameState, action): <NEW_LINE> <INDENT> return {'successorScore': 100, 'distanceToFood': -10, "closeToEvil": 5, "isPacman": 20, 'stopped': -10000000000} | A reflex agent that seeks food. This is an agent
we give you to get an idea of what an offensive agent might look like,
but it is by no means the best or only way to build an offensive agent. | 6259908b3617ad0b5ee07d6c |
class FormatLabel(FormatWidgetMixin, WidthWidgetMixin): <NEW_LINE> <INDENT> mapping = { 'finished': ('end_time', None), 'last_update': ('last_update_time', None), 'max': ('max_value', None), 'seconds': ('seconds_elapsed', None), 'start': ('start_time', None), 'elapsed': ('total_seconds_elapsed', _format_time), 'value': ('value', None), } <NEW_LINE> def __init__(self, format, **kwargs): <NEW_LINE> <INDENT> FormatWidgetMixin.__init__(self, format=format, **kwargs) <NEW_LINE> WidthWidgetMixin.__init__(self, **kwargs) <NEW_LINE> <DEDENT> def __call__(self, progress, data): <NEW_LINE> <INDENT> if not self.check_size(progress): <NEW_LINE> <INDENT> return '' <NEW_LINE> <DEDENT> for name, (key, transform) in self.mapping.items(): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> if transform is None: <NEW_LINE> <INDENT> data[name] = data[key] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> data[name] = transform(data[key]) <NEW_LINE> <DEDENT> <DEDENT> except: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> <DEDENT> return FormatWidgetMixin.__call__(self, progress, data) | Displays a formatted label
>>> label = FormatLabel('%(value)s', min_width=5, max_width=10)
>>> class Progress(object):
... pass
>>> Progress.term_width = 0
>>> label(Progress, dict(value='test'))
''
>>> Progress.term_width = 5
>>> label(Progress, dict(value='test'))
'test'
>>> Progress.term_width = 10
>>> label(Progress, dict(value='test'))
'test'
>>> Progress.term_width = 11
>>> label(Progress, dict(value='test'))
'' | 6259908bbe7bc26dc9252c63 |
class ModuleBreakpoints(dict): <NEW_LINE> <INDENT> def __init__(self, filename, lineno_cache): <NEW_LINE> <INDENT> if filename not in _modules: <NEW_LINE> <INDENT> _modules[filename] = BdbModule(filename) <NEW_LINE> <DEDENT> self.bdb_module = _modules[filename] <NEW_LINE> self.lineno_cache = lineno_cache <NEW_LINE> <DEDENT> def reset(self): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> do_reset = self.bdb_module.reset() <NEW_LINE> <DEDENT> except BdbSourceError: <NEW_LINE> <INDENT> do_reset = True <NEW_LINE> <DEDENT> if do_reset: <NEW_LINE> <INDENT> bplist = self.all_breakpoints() <NEW_LINE> self.clear() <NEW_LINE> for bp in bplist: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> bp.actual_bp = self.add_breakpoint(bp) <NEW_LINE> <DEDENT> except BdbSourceError: <NEW_LINE> <INDENT> bp.deleteMe() <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> <DEDENT> def add_breakpoint(self, bp): <NEW_LINE> <INDENT> firstlineno, actual_lno = self.bdb_module.get_actual_bp(bp.line) <NEW_LINE> if firstlineno not in self: <NEW_LINE> <INDENT> self[firstlineno] = {} <NEW_LINE> self.lineno_cache.add(firstlineno) <NEW_LINE> <DEDENT> code_bps = self[firstlineno] <NEW_LINE> if actual_lno not in code_bps: <NEW_LINE> <INDENT> code_bps[actual_lno] = [] <NEW_LINE> self.lineno_cache.add(actual_lno) <NEW_LINE> <DEDENT> code_bps[actual_lno].append(bp) <NEW_LINE> return firstlineno, actual_lno <NEW_LINE> <DEDENT> def delete_breakpoint(self, bp): <NEW_LINE> <INDENT> firstlineno, actual_lno = bp.actual_bp <NEW_LINE> try: <NEW_LINE> <INDENT> code_bps = self[firstlineno] <NEW_LINE> bplist = code_bps[actual_lno] <NEW_LINE> bplist.remove(bp) <NEW_LINE> <DEDENT> except (KeyError, ValueError): <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> if not bplist: <NEW_LINE> <INDENT> del code_bps[actual_lno] <NEW_LINE> self.lineno_cache.delete(actual_lno) <NEW_LINE> <DEDENT> if not code_bps: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> <DEDENT> def get_breakpoints(self, lineno): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> firstlineno, actual_lno = self.bdb_module.get_actual_bp(lineno) <NEW_LINE> <DEDENT> except BdbSourceError: <NEW_LINE> <INDENT> return [] <NEW_LINE> <DEDENT> if firstlineno not in self: <NEW_LINE> <INDENT> return [] <NEW_LINE> <DEDENT> code_bps = self[firstlineno] <NEW_LINE> if actual_lno not in code_bps: <NEW_LINE> <INDENT> return [] <NEW_LINE> <DEDENT> return [bp for bp in sorted(code_bps[actual_lno], key=attrgetter('number')) if bp.line == lineno] <NEW_LINE> <DEDENT> def all_breakpoints(self): <NEW_LINE> <INDENT> bpts = [] <NEW_LINE> for code_bps in self.values(): <NEW_LINE> <INDENT> for bplist in code_bps.values(): <NEW_LINE> <INDENT> bpts.extend(bplist) <NEW_LINE> <DEDENT> <DEDENT> return [bp for bp in sorted(bpts, key=attrgetter('number'))] | The breakpoints of a module.
A dictionary that maps a code firstlineno to a 'code_bps' dictionary that
maps each line number of the code, where one or more breakpoints are set,
to the list of corresponding Breakpoint instances.
Note:
A line in 'code_bps' is the actual line of the breakpoint (the line where the
debugger stops), this line may differ from the line attribute of the
Breakpoint instance as set by the user. | 6259908b4c3428357761bed6 |
class Entity(msrest.serialization.Model): <NEW_LINE> <INDENT> _validation = { 'text': {'required': True}, 'category': {'required': True}, 'offset': {'required': True}, 'length': {'required': True}, 'confidence_score': {'required': True}, } <NEW_LINE> _attribute_map = { 'text': {'key': 'text', 'type': 'str'}, 'category': {'key': 'category', 'type': 'str'}, 'subcategory': {'key': 'subcategory', 'type': 'str'}, 'offset': {'key': 'offset', 'type': 'int'}, 'length': {'key': 'length', 'type': 'int'}, 'confidence_score': {'key': 'confidenceScore', 'type': 'float'}, } <NEW_LINE> def __init__( self, *, text: str, category: str, offset: int, length: int, confidence_score: float, subcategory: Optional[str] = None, **kwargs ): <NEW_LINE> <INDENT> super(Entity, self).__init__(**kwargs) <NEW_LINE> self.text = text <NEW_LINE> self.category = category <NEW_LINE> self.subcategory = subcategory <NEW_LINE> self.offset = offset <NEW_LINE> self.length = length <NEW_LINE> self.confidence_score = confidence_score | Entity.
All required parameters must be populated in order to send to Azure.
:ivar text: Required. Entity text as appears in the request.
:vartype text: str
:ivar category: Required. Entity type.
:vartype category: str
:ivar subcategory: (Optional) Entity sub type.
:vartype subcategory: str
:ivar offset: Required. Start position for the entity text. Use of different 'stringIndexType'
values can affect the offset returned.
:vartype offset: int
:ivar length: Required. Length for the entity text. Use of different 'stringIndexType' values
can affect the length returned.
:vartype length: int
:ivar confidence_score: Required. Confidence score between 0 and 1 of the extracted entity.
:vartype confidence_score: float | 6259908b283ffb24f3cf54bc |
class StudioEditableModule(object): <NEW_LINE> <INDENT> def render_children(self, context, fragment, can_reorder=False, can_add=False, view_name='student_view'): <NEW_LINE> <INDENT> contents = [] <NEW_LINE> for child in self.descriptor.get_children(): <NEW_LINE> <INDENT> if can_reorder: <NEW_LINE> <INDENT> context['reorderable_items'].add(child.location) <NEW_LINE> <DEDENT> child_module = self.system.get_module(child) <NEW_LINE> rendered_child = child_module.render(view_name, context) <NEW_LINE> fragment.add_frag_resources(rendered_child) <NEW_LINE> contents.append({ 'id': child.location.to_deprecated_string(), 'content': rendered_child.content }) <NEW_LINE> <DEDENT> fragment.add_content(self.system.render_template("studio_render_children_view.html", { 'items': contents, 'xblock_context': context, 'can_add': can_add, 'can_reorder': can_reorder, })) | Helper methods for supporting Studio editing of xblocks/xmodules.
This class is only intended to be used with an XModule, as it assumes the existence of
self.descriptor and self.system. | 6259908ba8370b77170f1fe8 |
class DeviceInterface: <NEW_LINE> <INDENT> def __init__(self, shortname, allow_logout_during_operation, automatic_logout, authorization=None, in_operation=False, **kwargs): <NEW_LINE> <INDENT> self.shortname = shortname <NEW_LINE> self.allow_logout_during_operation = allow_logout_during_operation <NEW_LINE> if type(automatic_logout) is str: <NEW_LINE> <INDENT> self.automatic_logout = timedelta_from_str(automatic_logout) <NEW_LINE> <DEDENT> elif type(automatic_logout) is int: <NEW_LINE> <INDENT> self.automatic_logout = timedelta(seconds=automatic_logout) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.automatic_logout = automatic_logout <NEW_LINE> <DEDENT> self.in_operation = in_operation <NEW_LINE> self.authorization = authorization <NEW_LINE> self._logout_timer = None <NEW_LINE> self.next_timeout = None <NEW_LINE> if authorization: <NEW_LINE> <INDENT> self.login(authorization) <NEW_LINE> <DEDENT> <DEDENT> def reset_logout_timer(self, no_lock=False): <NEW_LINE> <INDENT> if self._logout_timer: <NEW_LINE> <INDENT> self._logout_timer.cancel() <NEW_LINE> <DEDENT> self._logout_timer = None <NEW_LINE> self.next_timeout = None <NEW_LINE> if no_lock and not self.automatic_logout: return <NEW_LINE> if self.authorization and (self.allow_logout_during_operation or not self.in_operation): <NEW_LINE> <INDENT> self._logout_timer = threading.Timer( self.automatic_logout.total_seconds(), self.logout, kwargs={'reason': 'timeout'}) <NEW_LINE> self._logout_timer.start() <NEW_LINE> self.next_timeout = datetime.now() + self.automatic_logout <NEW_LINE> <DEDENT> <DEDENT> def login(self, permission): <NEW_LINE> <INDENT> self.set_lock(False) <NEW_LINE> self.authorization = permission <NEW_LINE> self.reset_logout_timer(no_lock=True) <NEW_LINE> <DEDENT> def logout(self, reason=None): <NEW_LINE> <INDENT> if not self.allow_logout_during_operation and self.in_operation: <NEW_LINE> <INDENT> raise Exception('Logout may not occure during operation') <NEW_LINE> <DEDENT> self.set_lock(True) <NEW_LINE> self.authorization = None <NEW_LINE> self.reset_logout_timer() <NEW_LINE> <DEDENT> def set_operated(self, in_operation, reason=None): <NEW_LINE> <INDENT> if self.in_operation != in_operation: <NEW_LINE> <INDENT> self.in_operation = in_operation <NEW_LINE> self.reset_logout_timer() <NEW_LINE> <DEDENT> <DEDENT> def set_lock(self, state): <NEW_LINE> <INDENT> raise NotImplemented() <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return "<{} authorization={} in_operation={} next_timeout={}>".format( self.__class__.__name__, self.authorization, self.in_operation, self.next_timeout) | Prototype Device Interface | 6259908b4a966d76dd5f0b02 |
class AtsasViewer(Viewer): <NEW_LINE> <INDENT> _targets = [AtsasProtConvertPdbToSAXS] <NEW_LINE> _environments = [DESKTOP_TKINTER, WEB_DJANGO] <NEW_LINE> def __init__(self, **args): <NEW_LINE> <INDENT> Viewer.__init__(self, **args) <NEW_LINE> <DEDENT> def visualize(self, obj, **args): <NEW_LINE> <INDENT> cls = type(obj) <NEW_LINE> if issubclass(cls, AtsasProtConvertPdbToSAXS): <NEW_LINE> <INDENT> if obj.experimentalSAXS.empty(): <NEW_LINE> <INDENT> fnInt = obj._getPath("pseudoatoms00.int") <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> fnInt = obj._getPath("pseudoatoms00.fit") <NEW_LINE> <DEDENT> import numpy <NEW_LINE> x = numpy.loadtxt(fnInt, skiprows=1) <NEW_LINE> xplotter = Plotter(windowTitle="SAXS Curves") <NEW_LINE> a = xplotter.createSubPlot('SAXS curves', 'Angstroms^-1', 'log(SAXS)', yformat=False) <NEW_LINE> a.plot(x[:, 0], numpy.log(x[:, 1])) <NEW_LINE> a.plot(x[:, 0], numpy.log(x[:, 3])) <NEW_LINE> if obj.experimentalSAXS.empty(): <NEW_LINE> <INDENT> xplotter.showLegend(['SAXS in solution', 'SAXS in vacuo']) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> xplotter.showLegend(['Experimental SAXS', 'SAXS from volume']) <NEW_LINE> <DEDENT> xplotter.show() | Wrapper to visualize Pdb to SAXS. | 6259908b5fcc89381b266f6c |
class AnnoyinglyVerboseCallback(vcf.callbacks.Callback): <NEW_LINE> <INDENT> def on_experiment_begin(self, info=dict()): <NEW_LINE> <INDENT> print("Started training") <NEW_LINE> print(info.keys()) <NEW_LINE> <DEDENT> def on_experiment_end(self, info=dict()): <NEW_LINE> <INDENT> print("End of training") <NEW_LINE> print(info.keys()) <NEW_LINE> <DEDENT> def on_episode_begin(self, episode_ix, info=dict()): <NEW_LINE> <INDENT> print("Started episode: %d"%episode_ix) <NEW_LINE> print(info.keys()) <NEW_LINE> <DEDENT> def on_episode_end(self, episode_ix, info=dict()): <NEW_LINE> <INDENT> print("End of episode: %d"%episode_ix) <NEW_LINE> print(info.keys()) <NEW_LINE> <DEDENT> def on_step_begin(self, step_ix, info=dict()): <NEW_LINE> <INDENT> print("Begin step: %d"%step_ix) <NEW_LINE> print(info.keys()) <NEW_LINE> <DEDENT> def on_step_end(self, step_ix, info=dict()): <NEW_LINE> <INDENT> print("End step: %d"%step_ix) <NEW_LINE> print(info.keys()) | An example callback that pretty-prints all information it has access to
at each point when it gets called.
It will likely print a lot. | 6259908bd486a94d0ba2dbd1 |
class ServingManager(object): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.text_util = TextUtil(vocab_model=args.vocab_dir) <NEW_LINE> <DEDENT> def serving_model_load(self, model_dir): <NEW_LINE> <INDENT> original_path = os.listdir(model_dir)[0] <NEW_LINE> model_path = model_dir + original_path <NEW_LINE> serv_model = tf.saved_model.load(model_path, tags='serve') <NEW_LINE> default_serve_model = serv_model.signatures['serving_default'] <NEW_LINE> return default_serve_model <NEW_LINE> <DEDENT> def attention_test(self): <NEW_LINE> <INDENT> print("original text: ", args.test_text) <NEW_LINE> tf_tokenized_ids, tokenized_text = self.text_util.text_to_tf_ids(args.test_text) <NEW_LINE> print("original tokenized text:", ' '.join(tokenized_text)) <NEW_LINE> tf_data = self.text_util.text_to_tfdata(args.test_text) <NEW_LINE> original_text_matched_tokenized_data = self.text_util.original_text_data_matching_bpe_data(args.test_text, tf_tokenized_ids) <NEW_LINE> print("original text matched tokenized format ", original_text_matched_tokenized_data) <NEW_LINE> serve_model = self.serving_model_load(args.serve_model_dir) <NEW_LINE> id_to_original_text = {i: text for i, text in enumerate(args.test_text.split())} <NEW_LINE> self.attention_original_word(serve_model=serve_model, string_tensor=tf_data, matching_tokenize_text=original_text_matched_tokenized_data, tokenized_text=tokenized_text, id_to_original_text=id_to_original_text) <NEW_LINE> <DEDENT> def attention_original_word(self, serve_model, string_tensor, matching_tokenize_text, tokenized_text, id_to_original_text): <NEW_LINE> <INDENT> predicted_summary = serve_model(string_tensor) <NEW_LINE> seq_embedding = predicted_summary['seq-embeddings'][0] <NEW_LINE> res = seq_embedding.numpy() <NEW_LINE> res = res[:len(tokenized_text)] <NEW_LINE> res = np.average(res, axis=-1) <NEW_LINE> res_numpy = [] <NEW_LINE> for (v, idx_list) in matching_tokenize_text: <NEW_LINE> <INDENT> res_v = res[idx_list[0]:idx_list[-1] + 1] <NEW_LINE> res_numpy.append(np.average(res_v)) <NEW_LINE> <DEDENT> res = self.softmax(res_numpy, axis=-1) <NEW_LINE> index_max = {} <NEW_LINE> for i, data in enumerate(res): <NEW_LINE> <INDENT> index_max[i] = data <NEW_LINE> <DEDENT> res_sorted = sorted(index_max.items(), key=lambda item: item[1], reverse=True) <NEW_LINE> print("attention text from original text") <NEW_LINE> for i, (idx, v) in enumerate(res_sorted): <NEW_LINE> <INDENT> print('Text: ', id_to_original_text[idx], ' Rank: ', i, ' Score: ', v) <NEW_LINE> <DEDENT> <DEDENT> def softmax(self, x, axis=-1): <NEW_LINE> <INDENT> x = np.exp(x-np.max(x, axis=axis)) <NEW_LINE> return x/np.sum(x, axis=axis) | Serving model을 로드, 테스트, 관리 하는 Class | 6259908b60cbc95b06365b76 |
class AccessControlEntry(vsm_client.VSMClient): <NEW_LINE> <INDENT> def __init__(self, vsm=None): <NEW_LINE> <INDENT> super(AccessControlEntry, self).__init__() <NEW_LINE> self.schema_class = 'access_control_entry_schema.AccessControlEntrySchema' <NEW_LINE> self.set_connection(vsm.get_connection()) <NEW_LINE> conn = self.get_connection() <NEW_LINE> conn.set_api_header("api/2.0") <NEW_LINE> self.set_create_endpoint("/services/usermgmt/role/[email protected]") <NEW_LINE> self.id = None <NEW_LINE> <DEDENT> @tasks.thread_decorate <NEW_LINE> def create(self, schema_object): <NEW_LINE> <INDENT> desired_role = "" <NEW_LINE> if hasattr(schema_object, 'role'): <NEW_LINE> <INDENT> desired_role = schema_object.role <NEW_LINE> <DEDENT> access_control_entry = self.read() <NEW_LINE> if hasattr(access_control_entry, 'role'): <NEW_LINE> <INDENT> if access_control_entry.role == desired_role: <NEW_LINE> <INDENT> self.log.debug("root already has role %s" % access_control_entry.role) <NEW_LINE> result_obj = result.Result() <NEW_LINE> result_obj.set_status_code('200') <NEW_LINE> return result_obj <NEW_LINE> <DEDENT> <DEDENT> result_obj = super(AccessControlEntry, self).create(schema_object) <NEW_LINE> return result_obj[0] | Class to assign role using acess control | 6259908b099cdd3c63676208 |
class DictField(Field): <NEW_LINE> <INDENT> pass | Convenient class to make explicit that an attribute will store a dictionary | 6259908b283ffb24f3cf54bd |
class SlackNoThread(SlackError): <NEW_LINE> <INDENT> pass | Message without ts or thread_ts | 6259908b4c3428357761beda |
class Corpus(TimeStampedModel): <NEW_LINE> <INDENT> title = models.CharField(max_length=255, **nullable) <NEW_LINE> slug = AutoSlugField(populate_from='title', unique=True) <NEW_LINE> documents = models.ManyToManyField('corpus.Document', through='LabeledDocument', related_name='corpora') <NEW_LINE> user = models.ForeignKey('auth.User', related_name='corpora', **nullable) <NEW_LINE> labeled = models.BooleanField(default=True) <NEW_LINE> objects = CorpusManager() <NEW_LINE> class Meta: <NEW_LINE> <INDENT> db_table = "corpora" <NEW_LINE> get_latest_by = "created" <NEW_LINE> ordering = ["-created"] <NEW_LINE> verbose_name = "corpus" <NEW_LINE> verbose_name_plural = "corpora" <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> if self.title: <NEW_LINE> <INDENT> return self.title <NEW_LINE> <DEDENT> s = "{} document corpus created on {}".format( self.documents.count(), self.created.strftime("%Y-%m-%d") ) <NEW_LINE> if self.user: <NEW_LINE> <INDENT> s += " by {}".format(self.user) <NEW_LINE> <DEDENT> return s | A model that maintains a mapping of documents to estimators for use in
tracking the training data that is used to fit a text classifier object. | 6259908b60cbc95b06365b77 |
class TestEzsignbulksendResponseCompound(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 testEzsignbulksendResponseCompound(self): <NEW_LINE> <INDENT> pass | EzsignbulksendResponseCompound unit test stubs | 6259908b99fddb7c1ca63bec |
class RunJobMixin(UserPassesTestMixin): <NEW_LINE> <INDENT> success_url = reverse_lazy('site_status') <NEW_LINE> def test_func(self): <NEW_LINE> <INDENT> return self.request.user.is_superuser <NEW_LINE> <DEDENT> def get(self, request, *args, **kwargs): <NEW_LINE> <INDENT> self.object = self.schedule_class() <NEW_LINE> self.object.run_now() <NEW_LINE> return HttpResponseRedirect(str(self.success_url)) | View mixin to run the selected job immediately. | 6259908b7cff6e4e811b7662 |
class PrintLR(tf.keras.callbacks.Callback): <NEW_LINE> <INDENT> def on_epoch_end(self, epoch, logs=None): <NEW_LINE> <INDENT> print( "\nLearning rate for epoch {} is {}".format( epoch + 1, model.optimizer.lr.numpy() ) ) | Callback for printing the LR at the end of each epoch. | 6259908bf9cc0f698b1c60db |
class BinaryConfusionMatrix(tf.keras.metrics.Metric): <NEW_LINE> <INDENT> def __init__(self, model_type, name='binary_confusion_matrix', **kwargs): <NEW_LINE> <INDENT> super(BinaryConfusionMatrix, self).__init__(name=name, **kwargs) <NEW_LINE> self.model_type = model_type <NEW_LINE> self.binary_confusion_matrix = self.add_weight(name='binary_confusion_matrix', shape=(2, 2), initializer='zeros') <NEW_LINE> <DEDENT> def update_state(self, labels, predictions, *args, **kwargs): <NEW_LINE> <INDENT> if self.model_type == 'regression': <NEW_LINE> <INDENT> self.labels, self.predictions = metrics_prepare(labels, predictions, prediction_type='regression', five2two=True) <NEW_LINE> <DEDENT> elif self.model_type == 'binary_classification': <NEW_LINE> <INDENT> self.labels, self.predictions = metrics_prepare(labels, predictions, prediction_type='classification', five2two=False) <NEW_LINE> <DEDENT> elif self.model_type == 'multi_classification': <NEW_LINE> <INDENT> self.labels, self.predictions = metrics_prepare(labels, predictions, prediction_type='classification', five2two=True) <NEW_LINE> <DEDENT> self.binary_confusion_matrix = tf.math.confusion_matrix(tf.squeeze(self.labels), tf.squeeze(self.predictions), num_classes=2, dtype=tf.int32) <NEW_LINE> <DEDENT> def result(self): <NEW_LINE> <INDENT> return self.binary_confusion_matrix | metric: binary confusion matrix | 6259908bbe7bc26dc9252c66 |
class Log: <NEW_LINE> <INDENT> @staticmethod <NEW_LINE> def getLogger(): <NEW_LINE> <INDENT> logger = logging.getLogger('logger') <NEW_LINE> handler = logging.handlers.RotatingFileHandler('/var/log/kirinki.log', maxBytes=20, backupCount=5) <NEW_LINE> logger.addHandler(handler) <NEW_LINE> return logger <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def debug(msg): <NEW_LINE> <INDENT> logger = Log.getLogger() <NEW_LINE> logger.setLevel(logging.DEBUG) <NEW_LINE> logger.debug(msg) <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def info(msg): <NEW_LINE> <INDENT> logger = Log.getLogger() <NEW_LINE> logger.setLevel(logging.INFO) <NEW_LINE> logger.info(msg) <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def warning(msg): <NEW_LINE> <INDENT> logger = Log.getLogger() <NEW_LINE> logger.setLevel(logging.WARNING) <NEW_LINE> logger.warning(msg) <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def error(msg): <NEW_LINE> <INDENT> logger = Log.getLogger() <NEW_LINE> logger.setLevel(logging.ERROR) <NEW_LINE> logger.error(msg) <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def critical(msg): <NEW_LINE> <INDENT> logger = Log.getLogger() <NEW_LINE> logger.setLevel(logging.CRITICAL) <NEW_LINE> logger.critical(msg) | This class print a message in the application log file and, if it's needed, rotate the file. | 6259908b63b5f9789fe86d8a |
class CheckDomainAvailabilityParameter(msrest.serialization.Model): <NEW_LINE> <INDENT> _validation = { 'subdomain_name': {'required': True}, 'type': {'required': True}, } <NEW_LINE> _attribute_map = { 'subdomain_name': {'key': 'subdomainName', 'type': 'str'}, 'type': {'key': 'type', 'type': 'str'}, 'kind': {'key': 'kind', 'type': 'str'}, } <NEW_LINE> def __init__( self, **kwargs ): <NEW_LINE> <INDENT> super(CheckDomainAvailabilityParameter, self).__init__(**kwargs) <NEW_LINE> self.subdomain_name = kwargs['subdomain_name'] <NEW_LINE> self.type = kwargs['type'] <NEW_LINE> self.kind = kwargs.get('kind', None) | Check Domain availability parameter.
All required parameters must be populated in order to send to Azure.
:param subdomain_name: Required. The subdomain name to use.
:type subdomain_name: str
:param type: Required. The Type of the resource.
:type type: str
:param kind: The Kind of the resource.
:type kind: str | 6259908b50812a4eaa6219d6 |
class LinearEquation (Polynomial): <NEW_LINE> <INDENT> def __init__ (self, coeff0, coeff1): <NEW_LINE> <INDENT> self.coefficients = [coeff0, coeff1] <NEW_LINE> <DEDENT> def apply(self, value): <NEW_LINE> <INDENT> return(value * self.coefficients[1] + self.coefficients[0]) | Subclass of Polynomial for linear equations.
This implementation is three times faster, so Polynomial should be reserved for higher orders. | 6259908bec188e330fdfa4cf |
class Account(object): <NEW_LINE> <INDENT> def __init__(self, name, balance): <NEW_LINE> <INDENT> self.name = name <NEW_LINE> self.balance = balance <NEW_LINE> <DEDENT> def winner(self, x): <NEW_LINE> <INDENT> self.balance += x <NEW_LINE> <DEDENT> def loser(self, x): <NEW_LINE> <INDENT> self.balance -= x <NEW_LINE> <DEDENT> def broke(self): <NEW_LINE> <INDENT> if self.balance == 0: <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return False | blue print for account | 6259908b99fddb7c1ca63bed |
class AXError(ValueError): <NEW_LINE> <INDENT> pass | Results from data that does not meet the attribute exchange 1.0
specification | 6259908bd8ef3951e32c8c6e |
class ProjectListHandler(BaseHandler): <NEW_LINE> <INDENT> @addslash <NEW_LINE> @session <NEW_LINE> @authenticated <NEW_LINE> def get(self): <NEW_LINE> <INDENT> uid = self.SESSION['uid'] <NEW_LINE> url = self.request.uri <NEW_LINE> if url not in self.SESSION['BSTACK']: <NEW_LINE> <INDENT> bstack = self.SESSION['BSTACK'] <NEW_LINE> bstack.append(url) <NEW_LINE> self.SESSION['BSTACK'] = bstack <NEW_LINE> <DEDENT> page = int(self.get_argument('page', 1)) <NEW_LINE> p = Project() <NEW_LINE> r = p._api.query(cuid=uid) <NEW_LINE> plist = self._flt_month(r[1]) <NEW_LINE> limit = 20 <NEW_LINE> return self.render("project/list.html", pinfo= self.page_info(page, 5, len(plist), limit), plist=plist[(page-1)*limit:page*limit], back = self.SESSION['BSTACK'][0]) <NEW_LINE> <DEDENT> @session <NEW_LINE> def _flt_month(self, plist): <NEW_LINE> <INDENT> perm = self.SESSION['perm'] <NEW_LINE> l = [] <NEW_LINE> oy, om = ('', '') <NEW_LINE> for p in plist: <NEW_LINE> <INDENT> ny, nm = p['time_meta'].year, p['time_meta'].month <NEW_LINE> if (oy != ny) or (om != nm): <NEW_LINE> <INDENT> oy, om = ny, nm <NEW_LINE> l.append({'pid':'','title':'','nick':'','created':str(oy)+u'年'+str(om)+u'月'}) <NEW_LINE> <DEDENT> flag = False <NEW_LINE> for m in p['pm']: <NEW_LINE> <INDENT> if m[0] in [0x20, 0x21]: <NEW_LINE> <INDENT> flag = True <NEW_LINE> <DEDENT> <DEDENT> for m in perm: <NEW_LINE> <INDENT> if m == PERM_CLASS['MANAGER']: <NEW_LINE> <INDENT> flag = True <NEW_LINE> <DEDENT> <DEDENT> if flag:l.append({'pid':p['pid'],'title':p['title'],'nick':p['nick'],'created':p['created']}) <NEW_LINE> <DEDENT> return l | 项目列表
| 6259908b283ffb24f3cf54c2 |
class ParameterList(Module): <NEW_LINE> <INDENT> def __init__(self, parameters=None): <NEW_LINE> <INDENT> super(ParameterList, self).__init__() <NEW_LINE> if parameters is not None: <NEW_LINE> <INDENT> self += parameters <NEW_LINE> <DEDENT> <DEDENT> def __getitem__(self, idx): <NEW_LINE> <INDENT> if isinstance(idx, slice): <NEW_LINE> <INDENT> return ParameterList(list(self._parameters.values())[idx]) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> idx = operator.index(idx) <NEW_LINE> if not (-len(self) <= idx < len(self)): <NEW_LINE> <INDENT> raise IndexError('index {} is out of range'.format(idx)) <NEW_LINE> <DEDENT> if idx < 0: <NEW_LINE> <INDENT> idx += len(self) <NEW_LINE> <DEDENT> return self._parameters[str(idx)] <NEW_LINE> <DEDENT> <DEDENT> def __setitem__(self, idx, param): <NEW_LINE> <INDENT> idx = operator.index(idx) <NEW_LINE> return self.register_parameter(str(idx), param) <NEW_LINE> <DEDENT> def __len__(self): <NEW_LINE> <INDENT> return len(self._parameters) <NEW_LINE> <DEDENT> def __iter__(self): <NEW_LINE> <INDENT> return iter(self._parameters.values()) <NEW_LINE> <DEDENT> def __iadd__(self, parameters): <NEW_LINE> <INDENT> return self.extend(parameters) <NEW_LINE> <DEDENT> def __dir__(self): <NEW_LINE> <INDENT> keys = super(ParameterList, self).__dir__() <NEW_LINE> keys = [key for key in keys if not key.isdigit()] <NEW_LINE> return keys <NEW_LINE> <DEDENT> def append(self, parameter): <NEW_LINE> <INDENT> self.register_parameter(str(len(self)), parameter) <NEW_LINE> return self <NEW_LINE> <DEDENT> def extend(self, parameters): <NEW_LINE> <INDENT> if not isinstance(parameters, Iterable): <NEW_LINE> <INDENT> raise TypeError("ParameterList.extend should be called with an " "iterable, but got " + type(parameters).__name__) <NEW_LINE> <DEDENT> offset = len(self) <NEW_LINE> for i, param in enumerate(parameters): <NEW_LINE> <INDENT> self.register_parameter(str(offset + i), param) <NEW_LINE> <DEDENT> return self <NEW_LINE> <DEDENT> def extra_repr(self): <NEW_LINE> <INDENT> child_lines = [] <NEW_LINE> for k, p in self._parameters.items(): <NEW_LINE> <INDENT> size_str = 'x'.join(str(size) for size in p.size()) <NEW_LINE> device_str = '' if not p.is_cuda else ' (GPU {})'.format(p.get_device()) <NEW_LINE> parastr = 'Parameter containing: [{} of size {}{}]'.format( torch.typename(p.data), size_str, device_str) <NEW_LINE> child_lines.append(' (' + str(k) + '): ' + parastr) <NEW_LINE> <DEDENT> tmpstr = '\n'.join(child_lines) <NEW_LINE> return tmpstr | Holds parameters in a list.
ParameterList can be indexed like a regular Python list, but parameters it
contains are properly registered, and will be visible by all Module methods.
Arguments:
parameters (iterable, optional): an iterable of :class:`~torch.nn.Parameter`` to add
Example::
class MyModule(nn.Module):
def __init__(self):
super(MyModule, self).__init__()
self.params = nn.ParameterList([nn.Parameter(torch.randn(10, 10)) for i in range(10)])
def forward(self, x):
# ParameterList can act as an iterable, or be indexed using ints
for i, p in enumerate(self.params):
x = self.params[i // 2].mm(x) + p.mm(x)
return x | 6259908b5fcc89381b266f6f |
class AzureFirewallNetworkRule(msrest.serialization.Model): <NEW_LINE> <INDENT> _attribute_map = { 'name': {'key': 'name', 'type': 'str'}, 'description': {'key': 'description', 'type': 'str'}, 'protocols': {'key': 'protocols', 'type': '[str]'}, 'source_addresses': {'key': 'sourceAddresses', 'type': '[str]'}, 'destination_addresses': {'key': 'destinationAddresses', 'type': '[str]'}, 'destination_ports': {'key': 'destinationPorts', 'type': '[str]'}, 'destination_fqdns': {'key': 'destinationFqdns', 'type': '[str]'}, 'source_ip_groups': {'key': 'sourceIpGroups', 'type': '[str]'}, 'destination_ip_groups': {'key': 'destinationIpGroups', 'type': '[str]'}, } <NEW_LINE> def __init__( self, **kwargs ): <NEW_LINE> <INDENT> super(AzureFirewallNetworkRule, self).__init__(**kwargs) <NEW_LINE> self.name = kwargs.get('name', None) <NEW_LINE> self.description = kwargs.get('description', None) <NEW_LINE> self.protocols = kwargs.get('protocols', None) <NEW_LINE> self.source_addresses = kwargs.get('source_addresses', None) <NEW_LINE> self.destination_addresses = kwargs.get('destination_addresses', None) <NEW_LINE> self.destination_ports = kwargs.get('destination_ports', None) <NEW_LINE> self.destination_fqdns = kwargs.get('destination_fqdns', None) <NEW_LINE> self.source_ip_groups = kwargs.get('source_ip_groups', None) <NEW_LINE> self.destination_ip_groups = kwargs.get('destination_ip_groups', None) | Properties of the network rule.
:param name: Name of the network rule.
:type name: str
:param description: Description of the rule.
:type description: str
:param protocols: Array of AzureFirewallNetworkRuleProtocols.
:type protocols: list[str or
~azure.mgmt.network.v2019_11_01.models.AzureFirewallNetworkRuleProtocol]
:param source_addresses: List of source IP addresses for this rule.
:type source_addresses: list[str]
:param destination_addresses: List of destination IP addresses.
:type destination_addresses: list[str]
:param destination_ports: List of destination ports.
:type destination_ports: list[str]
:param destination_fqdns: List of destination FQDNs.
:type destination_fqdns: list[str]
:param source_ip_groups: List of source IpGroups for this rule.
:type source_ip_groups: list[str]
:param destination_ip_groups: List of destination IpGroups for this rule.
:type destination_ip_groups: list[str] | 6259908b4a966d76dd5f0b08 |
class getNombreUsuarioFromId_result(object): <NEW_LINE> <INDENT> def __init__(self, success=None, e=None,): <NEW_LINE> <INDENT> self.success = success <NEW_LINE> self.e = e <NEW_LINE> <DEDENT> def read(self, iprot): <NEW_LINE> <INDENT> if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: <NEW_LINE> <INDENT> iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec]) <NEW_LINE> return <NEW_LINE> <DEDENT> iprot.readStructBegin() <NEW_LINE> while True: <NEW_LINE> <INDENT> (fname, ftype, fid) = iprot.readFieldBegin() <NEW_LINE> if ftype == TType.STOP: <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> if fid == 0: <NEW_LINE> <INDENT> if ftype == TType.STRING: <NEW_LINE> <INDENT> self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString() <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> iprot.skip(ftype) <NEW_LINE> <DEDENT> <DEDENT> elif fid == 1: <NEW_LINE> <INDENT> if ftype == TType.STRUCT: <NEW_LINE> <INDENT> self.e = NoSeEncontraronResultadosException() <NEW_LINE> self.e.read(iprot) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> iprot.skip(ftype) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> iprot.skip(ftype) <NEW_LINE> <DEDENT> iprot.readFieldEnd() <NEW_LINE> <DEDENT> iprot.readStructEnd() <NEW_LINE> <DEDENT> def write(self, oprot): <NEW_LINE> <INDENT> if oprot._fast_encode is not None and self.thrift_spec is not None: <NEW_LINE> <INDENT> oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec])) <NEW_LINE> return <NEW_LINE> <DEDENT> oprot.writeStructBegin('getNombreUsuarioFromId_result') <NEW_LINE> if self.success is not None: <NEW_LINE> <INDENT> oprot.writeFieldBegin('success', TType.STRING, 0) <NEW_LINE> oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success) <NEW_LINE> oprot.writeFieldEnd() <NEW_LINE> <DEDENT> if self.e is not None: <NEW_LINE> <INDENT> oprot.writeFieldBegin('e', TType.STRUCT, 1) <NEW_LINE> self.e.write(oprot) <NEW_LINE> oprot.writeFieldEnd() <NEW_LINE> <DEDENT> oprot.writeFieldStop() <NEW_LINE> oprot.writeStructEnd() <NEW_LINE> <DEDENT> def validate(self): <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> L = ['%s=%r' % (key, value) for key, value in self.__dict__.items()] <NEW_LINE> return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) <NEW_LINE> <DEDENT> def __eq__(self, other): <NEW_LINE> <INDENT> return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ <NEW_LINE> <DEDENT> def __ne__(self, other): <NEW_LINE> <INDENT> return not (self == other) | Attributes:
- success
- e | 6259908b3617ad0b5ee07d74 |
class BacklinksOptions(object): <NEW_LINE> <INDENT> entry = "entry" <NEW_LINE> top = "top" <NEW_LINE> none = "none" | ``backlinks`` argument choices.
- ``TableOfContent.BacklinksOptions.entry``: ``"entry"``
- ``TableOfContent.BacklinksOptions.top``: ``"top"``
- ``TableOfContent.BacklinksOptions.none``: ``"none"`` | 6259908b23849d37ff852cdd |
class Query(object): <NEW_LINE> <INDENT> def __init__(self, query, query_type='and'): <NEW_LINE> <INDENT> self.query = query <NEW_LINE> self.query_type = query_type <NEW_LINE> <DEDENT> def convert(self): <NEW_LINE> <INDENT> query_dict = self.convert_and() if self.query_type == 'and' else self.convert_or() <NEW_LINE> return dict(query={'bool': query_dict}) <NEW_LINE> <DEDENT> def convert_or(self): <NEW_LINE> <INDENT> d_list = [self.__class__(q) for q in self.query] <NEW_LINE> return d_list <NEW_LINE> <DEDENT> def convert_and(self): <NEW_LINE> <INDENT> must_list = [] <NEW_LINE> for field in self.query.iterkeys(): <NEW_LINE> <INDENT> if field == 'all': <NEW_LINE> <INDENT> d = self.multi_match(field, boost=True) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> d = self.match(field) <NEW_LINE> <DEDENT> must_list.append(d) <NEW_LINE> <DEDENT> return dict(must=must_list) <NEW_LINE> <DEDENT> def _field_dict(self, field, value): <NEW_LINE> <INDENT> if isinstance(value, list): <NEW_LINE> <INDENT> field_dict = {field: dict(query=' '.join(v for v in value))} <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> field_dict = {field: dict(query=value, type='phrase')} <NEW_LINE> <DEDENT> return field_dict <NEW_LINE> <DEDENT> def match(self, field): <NEW_LINE> <INDENT> field_dict = self._field_dict(field, self.query[field]) <NEW_LINE> return dict(match=field_dict) <NEW_LINE> <DEDENT> def multi_match(self, field, boost=True): <NEW_LINE> <INDENT> assert field == 'all' and self._fields <NEW_LINE> if boost: <NEW_LINE> <INDENT> return self._boosted_multi_match(field) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return self._simple_multi_match(field) <NEW_LINE> <DEDENT> <DEDENT> def _simple_multi_match(self, field): <NEW_LINE> <INDENT> d = dict(fields=self._fields.keys()) <NEW_LINE> field_dict = self._field_dict(field, self.query[field]) <NEW_LINE> d.update(field_dict[field]) <NEW_LINE> d['type'] = 'most_fields' <NEW_LINE> return dict(multi_match=d) <NEW_LINE> <DEDENT> def _boosted_multi_match(self, field): <NEW_LINE> <INDENT> boosted_fields = [] <NEW_LINE> for f in self._fields: <NEW_LINE> <INDENT> multiplier = self._fields.get(f) <NEW_LINE> if multiplier: <NEW_LINE> <INDENT> boosted_fields.append('{}^{}'.format(f, multiplier)) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> boosted_fields.append(f) <NEW_LINE> <DEDENT> <DEDENT> d = dict(fields=boosted_fields) <NEW_LINE> field_dict = self._field_dict(field, self.query[field]) <NEW_LINE> d.update(field_dict[field]) <NEW_LINE> d['type'] = 'most_fields' <NEW_LINE> return dict(multi_match=d) <NEW_LINE> <DEDENT> def match_all(self): <NEW_LINE> <INDENT> return dict(query={'match_all': {}}) <NEW_LINE> <DEDENT> def generate(self): <NEW_LINE> <INDENT> raise NotImplementedError | Representation of an Elasticsearch DSL query. | 6259908bd486a94d0ba2dbd7 |
class SetGradesCmd(OrgCommand): <NEW_LINE> <INDENT> aliases = ('@set-grades',) <NEW_LINE> syntax = '[for <org>] to <gradelist>' <NEW_LINE> arg_parsers = { 'org': match_org, 'gradelist': mudsling.parsers.StringListStaticParser, } <NEW_LINE> org_manager = True <NEW_LINE> def run(self, actor, org, gradelist): <NEW_LINE> <INDENT> msg = ['{gSetting seniority levels for {c%s{y:' % actor.name_for(org)] <NEW_LINE> seniority = 0 <NEW_LINE> for grade_code in gradelist: <NEW_LINE> <INDENT> seniority += 1 <NEW_LINE> try: <NEW_LINE> <INDENT> grade = org.get_rank_grade(grade_code) <NEW_LINE> <DEDENT> except errors.GradeNotFound: <NEW_LINE> <INDENT> grade = org.create_rank_grade(grade_code, seniority) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> grade.seniority = seniority <NEW_LINE> <DEDENT> msg.append(' {c%s{n = {y%d' % (grade.code, grade.seniority)) <NEW_LINE> <DEDENT> actor.msg('\n'.join(msg)) | @set-grades [for <org>] to <grade1>,<grade2>,...,<gradeN>
Set all grade seniorities at once, starting at seniority 1. | 6259908b50812a4eaa6219d7 |
class Loader(object): <NEW_LINE> <INDENT> pass | Loads stuff into a state graph. | 6259908b55399d3f05628138 |
class MyCommand(object): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.methodObject = None <NEW_LINE> self.lock = object <NEW_LINE> self.priority = 0 <NEW_LINE> self.args = [] <NEW_LINE> self.kwargs = {} <NEW_LINE> self.result = None <NEW_LINE> <DEDENT> def setCommand(self, methodObject, lock, priority, args, kwargs): <NEW_LINE> <INDENT> self.methodObject = methodObject <NEW_LINE> self.lock = lock <NEW_LINE> self.priority = priority <NEW_LINE> self.args = args <NEW_LINE> self.kwargs = kwargs <NEW_LINE> <DEDENT> def setResult(self, result): <NEW_LINE> <INDENT> self.result = result <NEW_LINE> <DEDENT> def getResult(self): <NEW_LINE> <INDENT> if self.result == None: <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return self.result | This class is uesd to package all kinds of method objects, likes a data transfer object. | 6259908bdc8b845886d551dc |
class FrameSegment(object): <NEW_LINE> <INDENT> MAX_DGRAM = 2**16 <NEW_LINE> MAX_IMAGE_DGRAM = MAX_DGRAM - 64 <NEW_LINE> def __init__(self, sock, port, addr="127.0.0.1"): <NEW_LINE> <INDENT> self.s = sock <NEW_LINE> self.port = port <NEW_LINE> self.addr = addr <NEW_LINE> <DEDENT> def udp_frame(self, img): <NEW_LINE> <INDENT> compress_img = cv2.imencode('.jpg', img)[1] <NEW_LINE> dat = compress_img.tostring() <NEW_LINE> size = len(dat) <NEW_LINE> count = math.ceil(size/(self.MAX_IMAGE_DGRAM)) <NEW_LINE> array_pos_start = 0 <NEW_LINE> while count: <NEW_LINE> <INDENT> array_pos_end = min(size, array_pos_start + self.MAX_IMAGE_DGRAM) <NEW_LINE> self.s.sendto(struct.pack("B", count) + dat[array_pos_start:array_pos_end], (self.addr, self.port) ) <NEW_LINE> array_pos_start = array_pos_end <NEW_LINE> count -= 1 | Object to break down image frame segment
if the size of image exceed maximum datagram size | 6259908baad79263cf4303de |
class TekSavvySensor(Entity): <NEW_LINE> <INDENT> def __init__(self, teksavvydata, sensor_type, name): <NEW_LINE> <INDENT> self.client_name = name <NEW_LINE> self.type = sensor_type <NEW_LINE> self._name = SENSOR_TYPES[sensor_type][0] <NEW_LINE> self._unit_of_measurement = SENSOR_TYPES[sensor_type][1] <NEW_LINE> self._icon = SENSOR_TYPES[sensor_type][2] <NEW_LINE> self.teksavvydata = teksavvydata <NEW_LINE> self._state = None <NEW_LINE> <DEDENT> @property <NEW_LINE> def name(self): <NEW_LINE> <INDENT> return '{} {}'.format(self.client_name, self._name) <NEW_LINE> <DEDENT> @property <NEW_LINE> def state(self): <NEW_LINE> <INDENT> return self._state <NEW_LINE> <DEDENT> @property <NEW_LINE> def unit_of_measurement(self): <NEW_LINE> <INDENT> return self._unit_of_measurement <NEW_LINE> <DEDENT> @property <NEW_LINE> def icon(self): <NEW_LINE> <INDENT> return self._icon <NEW_LINE> <DEDENT> async def async_update(self): <NEW_LINE> <INDENT> await self.teksavvydata.async_update() <NEW_LINE> if self.type in self.teksavvydata.data: <NEW_LINE> <INDENT> self._state = round(self.teksavvydata.data[self.type], 2) | Representation of TekSavvy Bandwidth sensor. | 6259908bf9cc0f698b1c60dd |
class Meta(object): <NEW_LINE> <INDENT> app_label = 'delivery_helper_core' | Model options for Entrega. | 6259908b3346ee7daa338474 |
class HomeView(TemplateView): <NEW_LINE> <INDENT> template_name = 'mockstock/home.html' | Home page view. | 6259908b5fc7496912d4907d |
class XSredden(XSMultiplicativeModel): <NEW_LINE> <INDENT> __function__ = "xscred" <NEW_LINE> def __init__(self, name='redden'): <NEW_LINE> <INDENT> self.E_BmV = Parameter(name, 'E_BmV', 0.05, 0., 10., 0.0, hugeval, aliases=["EBV"]) <NEW_LINE> XSMultiplicativeModel.__init__(self, name, (self.E_BmV,)) | The XSPEC redden model: interstellar extinction.
The model is described at [1]_.
.. note:: Deprecated in Sherpa 4.10.0
The ``EBV`` parameter has been renamed ``E_BmV`` to match the
XSPEC definition. The name ``EBV`` can still be used to access
the parameter, but this name will be removed in a future release.
Attributes
----------
E_BmV
The value of E(B-v) for the line of sight to the source.
See Also
--------
XSzredden
References
----------
.. [1] https://heasarc.gsfc.nasa.gov/xanadu/xspec/manual/XSmodelRedden.html | 6259908b167d2b6e312b83aa |
class SVD(Op): <NEW_LINE> <INDENT> _numop = staticmethod(np.linalg.svd) <NEW_LINE> __props__ = ('full_matrices', 'compute_uv') <NEW_LINE> def __init__(self, full_matrices=True, compute_uv=True): <NEW_LINE> <INDENT> self.full_matrices = full_matrices <NEW_LINE> self.compute_uv = compute_uv <NEW_LINE> <DEDENT> def make_node(self, x): <NEW_LINE> <INDENT> x = as_tensor_variable(x) <NEW_LINE> assert x.ndim == 2, "The input of svd function should be a matrix." <NEW_LINE> w = theano.tensor.matrix(dtype=x.dtype) <NEW_LINE> u = theano.tensor.vector(dtype=x.dtype) <NEW_LINE> v = theano.tensor.matrix(dtype=x.dtype) <NEW_LINE> return Apply(self, [x], [w, u, v]) <NEW_LINE> <DEDENT> def perform(self, node, inputs, outputs): <NEW_LINE> <INDENT> (x,) = inputs <NEW_LINE> (w, u, v) = outputs <NEW_LINE> assert x.ndim == 2, "The input of svd function should be a matrix." <NEW_LINE> w[0], u[0], v[0] = self._numop(x, self.full_matrices, self.compute_uv) | Parameters
----------
full_matrices : bool, optional
If True (default), u and v have the shapes (M, M) and (N, N),
respectively.
Otherwise, the shapes are (M, K) and (K, N), respectively,
where K = min(M, N).
compute_uv : bool, optional
Whether or not to compute u and v in addition to s.
True by default. | 6259908b656771135c48ae43 |
class InsertNodeAction (BaseAction): <NEW_LINE> <INDENT> def __init__ (self, application): <NEW_LINE> <INDENT> self._application = application <NEW_LINE> global _ <NEW_LINE> _ = get_() <NEW_LINE> <DEDENT> stringId = u"Diagrammer_InsertNode" <NEW_LINE> @property <NEW_LINE> def title (self): <NEW_LINE> <INDENT> return _(u"Insert node") <NEW_LINE> <DEDENT> @property <NEW_LINE> def description (self): <NEW_LINE> <INDENT> return _(u"Diagrammer. Insert new node") <NEW_LINE> <DEDENT> def run (self, params): <NEW_LINE> <INDENT> assert self._application.mainWindow is not None <NEW_LINE> with InsertNodeDialog (self._application.mainWindow) as dlg: <NEW_LINE> <INDENT> controller = InsertNodeController (dlg) <NEW_LINE> result = controller.showDialog() <NEW_LINE> if result == wx.ID_OK: <NEW_LINE> <INDENT> codeEditor = self._application.mainWindow.pagePanel.pageView.codeEditor <NEW_LINE> codeEditor.replaceText (controller.getResult()) | Описание действия | 6259908bd8ef3951e32c8c70 |
class BasicModule(t.nn.Module): <NEW_LINE> <INDENT> def __init__(self,opt=None): <NEW_LINE> <INDENT> super(BasicModule,self).__init__() <NEW_LINE> self.model_name=str(type(self).__name__) <NEW_LINE> self.opt = opt <NEW_LINE> <DEDENT> def load(self, path,map_location=lambda storage, loc: storage): <NEW_LINE> <INDENT> checkpoint = t.load(path,map_location=map_location) <NEW_LINE> if 'opt' in checkpoint: <NEW_LINE> <INDENT> self.load_state_dict(checkpoint['d']) <NEW_LINE> print('old config：') <NEW_LINE> print(checkpoint['opt']) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.load_state_dict(checkpoint) <NEW_LINE> <DEDENT> <DEDENT> def save(self, name=''): <NEW_LINE> <INDENT> format = 'checkpoints/'+self.model_name+'_%m%d_%H%M_' <NEW_LINE> file_name = time.strftime(format) + str(name) <NEW_LINE> state_dict = self.state_dict() <NEW_LINE> opt_state_dict = dict(self.opt.state_dict()) <NEW_LINE> optimizer_state_dict = self.optimizer.state_dict() <NEW_LINE> t.save({'d':state_dict,'opt':opt_state_dict,'optimizer':optimizer_state_dict}, file_name) <NEW_LINE> return file_name <NEW_LINE> <DEDENT> def get_optimizer(self,lr1,lr2): <NEW_LINE> <INDENT> self.optimizer = t.optim.Adam( [ {'params': self.features.parameters(), 'lr': lr1}, {'params': self.classifier.parameters(), 'lr':lr2} ] ) <NEW_LINE> return self.optimizer <NEW_LINE> <DEDENT> def update_optimizer(self,lr1,lr2): <NEW_LINE> <INDENT> param_groups = self.optimizer.param_groups <NEW_LINE> param_groups[0]['lr']=lr1 <NEW_LINE> pram_groups[1]['lr']=lr2 <NEW_LINE> return self.optimizer | 封装了nn.Module | 6259908b4527f215b58eb7b2 |
class GutenbergMonitor(Monitor): <NEW_LINE> <INDENT> def __init__(self, _db, data_directory): <NEW_LINE> <INDENT> self._db = _db <NEW_LINE> path = os.path.join(data_directory, DataSource.GUTENBERG) <NEW_LINE> if not os.path.exists(path): <NEW_LINE> <INDENT> os.makedirs(path) <NEW_LINE> <DEDENT> self.source = GutenbergAPI(_db, path) <NEW_LINE> <DEDENT> def run(self, subset=None): <NEW_LINE> <INDENT> added_books = 0 <NEW_LINE> for edition, license_pool in self.source.create_missing_books(subset): <NEW_LINE> <INDENT> event = get_one_or_create( self._db, CirculationEvent, type=CirculationEvent.TITLE_ADD, license_pool=license_pool, create_method_kwargs=dict( start=license_pool.last_checked ) ) <NEW_LINE> self._db.commit() | Maintain license pool and metadata info for Gutenberg titles.
TODO: This monitor doesn't really use the normal monitor process,
but since it doesn't access an 'API' in the traditional sense it
doesn't matter much. | 6259908bf9cc0f698b1c60de |
class MemberReports(object): <NEW_LINE> <INDENT> def __init__(self, member_reports=None): <NEW_LINE> <INDENT> self.swagger_types = { 'member_reports': 'list[MemberReport]' } <NEW_LINE> self.attribute_map = { 'member_reports': 'member_reports' } <NEW_LINE> self._member_reports = member_reports <NEW_LINE> <DEDENT> @property <NEW_LINE> def member_reports(self): <NEW_LINE> <INDENT> return self._member_reports <NEW_LINE> <DEDENT> @member_reports.setter <NEW_LINE> def member_reports(self, member_reports): <NEW_LINE> <INDENT> self._member_reports = member_reports <NEW_LINE> <DEDENT> def to_dict(self): <NEW_LINE> <INDENT> result = {} <NEW_LINE> for attr, _ in 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> return result <NEW_LINE> <DEDENT> def to_str(self): <NEW_LINE> <INDENT> return 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, MemberReports): <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. | 6259908b5fcc89381b266f71 |
class Furigana(object): <NEW_LINE> <INDENT> def __init__(self, text): <NEW_LINE> <INDENT> self.text = text | Represents a furigana string sequence | 6259908ba05bb46b3848bf39 |
class IProcessEntity(Interface): <NEW_LINE> <INDENT> pass | Marker interface for OSProcessClass and OSProcessOrganizer | 6259908bd486a94d0ba2dbdb |
class FastSpeech2(nn.Module): <NEW_LINE> <INDENT> def __init__(self, use_postnet=True): <NEW_LINE> <INDENT> super(FastSpeech2, self).__init__() <NEW_LINE> self.encoder = Encoder() <NEW_LINE> self.variance_adaptor = VarianceAdaptor() <NEW_LINE> self.decoder = Decoder() <NEW_LINE> self.mel_linear = nn.Linear(hp.decoder_hidden, hp.n_mel_channels) <NEW_LINE> self.use_postnet = use_postnet <NEW_LINE> if self.use_postnet: <NEW_LINE> <INDENT> self.postnet = PostNet() <NEW_LINE> <DEDENT> <DEDENT> def forward(self, src_seq, src_len, mel_len=None, d_target=None, p_target=None, e_target=None, max_src_len=None, max_mel_len=None, d_control=1.0, p_control=1.0, e_control=1.0, speaker_emb=None): <NEW_LINE> <INDENT> src_mask = get_mask_from_lengths(src_len, max_src_len) <NEW_LINE> mel_mask = get_mask_from_lengths( mel_len, max_mel_len) if mel_len is not None else None <NEW_LINE> encoder_output = self.encoder(src_seq, src_mask) <NEW_LINE> if speaker_emb is not None: <NEW_LINE> <INDENT> speaker_emb = speaker_emb.unsqueeze( 1).repeat(1, encoder_output.size(1), 1) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> speaker_emb = torch.zeros( (encoder_output.size(0), encoder_output.size(1), hp.speaker_dim)) <NEW_LINE> <DEDENT> encoder_output = torch.cat([encoder_output, speaker_emb], 2) <NEW_LINE> if d_target is not None: <NEW_LINE> <INDENT> variance_adaptor_output, d_prediction, p_prediction, e_prediction, _, _ = self.variance_adaptor( encoder_output, src_mask, mel_mask, d_target, p_target, e_target, max_mel_len, d_control, p_control, e_control) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> variance_adaptor_output, d_prediction, p_prediction, e_prediction, mel_len, mel_mask = self.variance_adaptor( encoder_output, src_mask, mel_mask, d_target, p_target, e_target, max_mel_len, d_control, p_control, e_control) <NEW_LINE> <DEDENT> decoder_output = self.decoder(variance_adaptor_output, mel_mask) <NEW_LINE> mel_output = self.mel_linear(decoder_output) <NEW_LINE> if self.use_postnet: <NEW_LINE> <INDENT> mel_output_postnet = self.postnet(mel_output) + mel_output <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> mel_output_postnet = mel_output <NEW_LINE> <DEDENT> return mel_output, mel_output_postnet, d_prediction, p_prediction, e_prediction, src_mask, mel_mask, mel_len | FastSpeech2 | 6259908bec188e330fdfa4d5 |
class MarkInfo: <NEW_LINE> <INDENT> def __init__(self, name, args, kwargs): <NEW_LINE> <INDENT> self.name = name <NEW_LINE> self.args = args <NEW_LINE> self.kwargs = kwargs.copy() <NEW_LINE> self._arglist = [(args, kwargs.copy())] <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return "<MarkInfo %r args=%r kwargs=%r>" % ( self.name, self.args, self.kwargs ) <NEW_LINE> <DEDENT> def add(self, args, kwargs): <NEW_LINE> <INDENT> self._arglist.append((args, kwargs)) <NEW_LINE> self.args += args <NEW_LINE> self.kwargs.update(kwargs) <NEW_LINE> <DEDENT> def __iter__(self): <NEW_LINE> <INDENT> for args, kwargs in self._arglist: <NEW_LINE> <INDENT> yield MarkInfo(self.name, args, kwargs) | Marking object created by :class:`MarkDecorator` instances. | 6259908b656771135c48ae44 |
class TempViewer: <NEW_LINE> <INDENT> def update(self, subject): <NEW_LINE> <INDENT> print("Temperature Viewer: {} has Temperature {}".format(subject._name, subject._temp)) | This is an observer class | 6259908bdc8b845886d551e0 |
class MulticastSocket(object): <NEW_LINE> <INDENT> def __init__(self, hostport): <NEW_LINE> <INDENT> self.host, self.port = hostport <NEW_LINE> self.rsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) <NEW_LINE> self.rsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) <NEW_LINE> if hasattr(socket, 'SO_REUSEPORT'): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> self.rsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) <NEW_LINE> <DEDENT> except socket.error as e: <NEW_LINE> <INDENT> if e.errno == errno.ENOPROTOOPT: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> self.rsock.bind(('', self.port)) <NEW_LINE> mreq = struct.pack('4sl', socket.inet_pton(socket.AF_INET, self.host), socket.INADDR_ANY) <NEW_LINE> self.rsock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq) <NEW_LINE> self.wsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) <NEW_LINE> self.wsock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2) <NEW_LINE> self.wsock.connect((self.host, self.port)) <NEW_LINE> self.wsock.shutdown(socket.SHUT_RD) <NEW_LINE> <DEDENT> def Send(self, data): <NEW_LINE> <INDENT> return self.wsock.send(data) <NEW_LINE> <DEDENT> def Recv(self): <NEW_LINE> <INDENT> return self.rsock.recvfrom(65536) | A simple class for wrapping multicast send/receive activities. | 6259908bf9cc0f698b1c60df |
class AnnotateGenomeWorkflow(sl.WorkflowTask): <NEW_LINE> <INDENT> genome_fasta = sl.Parameter() <NEW_LINE> genome_name = sl.Parameter() <NEW_LINE> checkm_memory = sl.Parameter(default=64000) <NEW_LINE> checkm_threads = sl.Parameter(default=8) <NEW_LINE> base_s3_folder = sl.Parameter() <NEW_LINE> aws_job_role_arn = sl.Parameter() <NEW_LINE> aws_s3_scratch_loc = sl.Parameter() <NEW_LINE> aws_batch_job_queue = sl.Parameter(default="optimal") <NEW_LINE> engine = sl.Parameter(default="aws_batch") <NEW_LINE> temp_folder = "/scratch" <NEW_LINE> def workflow(self): <NEW_LINE> <INDENT> genome_fasta = self.new_task( "load_genome_fasta", LoadFile, path=self.genome_fasta ) <NEW_LINE> annotate_prokka = self.new_task( "annotate_prokka_{}".format(self.genome_name), AnnotateProkka, sample_name=self.genome_name, output_folder=os.path.join(self.base_s3_folder, "prokka"), threads=self.checkm_threads, temp_folder=self.temp_folder, containerinfo=sl.ContainerInfo( vcpu=int(self.checkm_threads), mem=int(self.checkm_memory), engine=self.engine, aws_s3_scratch_loc=self.aws_s3_scratch_loc, aws_jobRoleArn=self.aws_job_role_arn, aws_batch_job_queue=self.aws_batch_job_queue, aws_batch_job_name="annotate_prokka_{}".format(self.genome_name), mounts={ "/docker_scratch": { "bind": self.temp_folder, "mode": "rw" } } ) ) <NEW_LINE> annotate_prokka.in_fasta = genome_fasta.out_file <NEW_LINE> checkm = self.new_task( "checkm_{}".format(self.genome_name), CheckM, sample_name=self.genome_name, output_folder=os.path.join(self.base_s3_folder, "checkm"), threads=8, temp_folder=self.temp_folder, containerinfo=sl.ContainerInfo( vcpu=int(8), mem=int(64000), engine=self.engine, aws_s3_scratch_loc=self.aws_s3_scratch_loc, aws_jobRoleArn=self.aws_job_role_arn, aws_batch_job_queue=self.aws_batch_job_queue, aws_batch_job_name="checkm_{}".format(self.genome_name), mounts={ "/docker_scratch": { "bind": self.temp_folder, "mode": "rw" } } ) ) <NEW_LINE> checkm.in_faa = annotate_prokka.out_faa <NEW_LINE> return checkm | {genome sequence } -> [ prodigal / prokka ] -> {called peptides} -> [checkM] -> {completeness and taxID} | 6259908b8a349b6b43687e86 |
class BStoreClosedError(Exception): <NEW_LINE> <INDENT> def __str__(self): <NEW_LINE> <INDENT> return "Backing store not open" | exception for when a backing store hasn't been opened yet | 6259908b091ae3566870686c |
class RegistrationForm(FlaskForm): <NEW_LINE> <INDENT> email = StringField('Email', validators=[DataRequired(), Email()]) <NEW_LINE> username = StringField('Username', validators=[DataRequired()]) <NEW_LINE> first_name = StringField('First Name', validators=[DataRequired()]) <NEW_LINE> last_name = StringField('Last Name', validators=[DataRequired()]) <NEW_LINE> password = PasswordField('Password', validators=[DataRequired(), EqualTo('confirm_password')]) <NEW_LINE> confirm_password = PasswordField('Confirm Password') <NEW_LINE> submit = SubmitField('Register') <NEW_LINE> def validate_email(self, field): <NEW_LINE> <INDENT> if Employee.query.filter_by(email=field.data).first(): <NEW_LINE> <INDENT> raise ValidationError('Email is already in use.') <NEW_LINE> <DEDENT> <DEDENT> def validate_username(self, field): <NEW_LINE> <INDENT> if Employee.query.filter_by(username=field.data).first(): <NEW_LINE> <INDENT> raise ValidationError('Username is already in use.') | Form for user to create new account | 6259908bfff4ab517ebcf43f |
class Layer: <NEW_LINE> <INDENT> def __init__(self, number_of_nodes: int, bias: float, weights: np.array, activation_function: ActivationFunction) -> None: <NEW_LINE> <INDENT> self.number_of_nodes = number_of_nodes <NEW_LINE> self.bias = bias <NEW_LINE> self.activation_function = activation_function <NEW_LINE> self.weights = weights <NEW_LINE> self.node_values = None <NEW_LINE> self.output = None | Represents neural network's layer | 6259908b3617ad0b5ee07d7a |
class Developer(Employee): <NEW_LINE> <INDENT> raise_amount = 1.20 <NEW_LINE> def __init__(self, first_name, last_name, pay, programming_language): <NEW_LINE> <INDENT> super().__init__(first_name, last_name, pay) <NEW_LINE> self.programming_language = programming_language | customize parent class inherited variables | 6259908b23849d37ff852ce3 |
class NeatoSensor(Entity): <NEW_LINE> <INDENT> def __init__(self, neato, robot): <NEW_LINE> <INDENT> self.robot = robot <NEW_LINE> self._available = neato.logged_in if neato is not None else False <NEW_LINE> self._robot_name = f"{self.robot.name} {BATTERY}" <NEW_LINE> self._robot_serial = self.robot.serial <NEW_LINE> self._state = None <NEW_LINE> <DEDENT> def update(self): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> self._state = self.robot.state <NEW_LINE> <DEDENT> except NeatoRobotException as ex: <NEW_LINE> <INDENT> if self._available: <NEW_LINE> <INDENT> _LOGGER.error("Neato sensor connection error: %s", ex) <NEW_LINE> <DEDENT> self._state = None <NEW_LINE> self._available = False <NEW_LINE> return <NEW_LINE> <DEDENT> self._available = True <NEW_LINE> _LOGGER.debug("self._state=%s", self._state) <NEW_LINE> <DEDENT> @property <NEW_LINE> def name(self): <NEW_LINE> <INDENT> return self._robot_name <NEW_LINE> <DEDENT> @property <NEW_LINE> def unique_id(self): <NEW_LINE> <INDENT> return self._robot_serial <NEW_LINE> <DEDENT> @property <NEW_LINE> def device_class(self): <NEW_LINE> <INDENT> return DEVICE_CLASS_BATTERY <NEW_LINE> <DEDENT> @property <NEW_LINE> def available(self): <NEW_LINE> <INDENT> return self._available <NEW_LINE> <DEDENT> @property <NEW_LINE> def state(self): <NEW_LINE> <INDENT> return self._state["details"]["charge"] <NEW_LINE> <DEDENT> @property <NEW_LINE> def unit_of_measurement(self): <NEW_LINE> <INDENT> return UNIT_PERCENTAGE <NEW_LINE> <DEDENT> @property <NEW_LINE> def device_info(self): <NEW_LINE> <INDENT> return {"identifiers": {(NEATO_DOMAIN, self._robot_serial)}} | Neato sensor. | 6259908badb09d7d5dc0c183 |
class AzureStackHCIClientConfiguration(Configuration): <NEW_LINE> <INDENT> def __init__( self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any ) -> None: <NEW_LINE> <INDENT> if credential is None: <NEW_LINE> <INDENT> raise ValueError("Parameter 'credential' must not be None.") <NEW_LINE> <DEDENT> if subscription_id is None: <NEW_LINE> <INDENT> raise ValueError("Parameter 'subscription_id' must not be None.") <NEW_LINE> <DEDENT> super(AzureStackHCIClientConfiguration, self).__init__(**kwargs) <NEW_LINE> self.credential = credential <NEW_LINE> self.subscription_id = subscription_id <NEW_LINE> self.api_version = "2021-01-01-preview" <NEW_LINE> self.credential_scopes = kwargs.pop('credential_scopes', ['https://management.azure.com/.default']) <NEW_LINE> kwargs.setdefault('sdk_moniker', 'mgmt-azurestackhci/{}'.format(VERSION)) <NEW_LINE> self._configure(**kwargs) <NEW_LINE> <DEDENT> def _configure( self, **kwargs: Any ) -> None: <NEW_LINE> <INDENT> self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) <NEW_LINE> self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) <NEW_LINE> self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) <NEW_LINE> self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) <NEW_LINE> self.http_logging_policy = kwargs.get('http_logging_policy') or ARMHttpLoggingPolicy(**kwargs) <NEW_LINE> self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) <NEW_LINE> self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) <NEW_LINE> self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) <NEW_LINE> self.authentication_policy = kwargs.get('authentication_policy') <NEW_LINE> if self.credential and not self.authentication_policy: <NEW_LINE> <INDENT> self.authentication_policy = policies.AsyncBearerTokenCredentialPolicy(self.credential, *self.credential_scopes, **kwargs) | Configuration for AzureStackHCIClient.
Note that all parameters used to create this instance are saved as instance
attributes.
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials_async.AsyncTokenCredential
:param subscription_id: The ID of the target subscription.
:type subscription_id: str | 6259908b656771135c48ae45 |
class Event(DictionaryBase, ConvertEvent, ExportEvent): <NEW_LINE> <INDENT> pass | Default Event class for conversion | 6259908b5fcc89381b266f73 |
class Meta: <NEW_LINE> <INDENT> model = Entry <NEW_LINE> exclude = ('internal_notes', 'published_by',) | Meta class. Because | 6259908baad79263cf4303e3 |
class ShowCryptoPkiCertificates(ShowCryptoPkiCertificates_iosxe): <NEW_LINE> <INDENT> pass | Parser for show crypto pki certificates <WORD> | 6259908badb09d7d5dc0c185 |
class RuleGroup(ModelSQL, ModelView): <NEW_LINE> <INDENT> _name = 'ir.rule.group' <NEW_LINE> _description = __doc__ <NEW_LINE> name = fields.Char('Name', select=True) <NEW_LINE> model = fields.Many2One('ir.model', 'Model', select=True, required=True) <NEW_LINE> global_p = fields.Boolean('Global', select=True, help="Make the rule global \n" "so every users must follow this rule") <NEW_LINE> default_p = fields.Boolean('Default', select=True, help="Add this rule to all users by default") <NEW_LINE> rules = fields.One2Many('ir.rule', 'rule_group', 'Tests', help="The rule is satisfied if at least one test is True") <NEW_LINE> groups = fields.Many2Many('ir.rule.group-res.group', 'rule_group', 'group', 'Groups') <NEW_LINE> users = fields.Many2Many('ir.rule.group-res.user', 'rule_group', 'user', 'Users') <NEW_LINE> perm_read = fields.Boolean('Read Access') <NEW_LINE> perm_write = fields.Boolean('Write Access') <NEW_LINE> perm_create = fields.Boolean('Create Access') <NEW_LINE> perm_delete = fields.Boolean('Delete Access') <NEW_LINE> def __init__(self): <NEW_LINE> <INDENT> super(RuleGroup, self).__init__() <NEW_LINE> self._order.insert(0, ('model', 'ASC')) <NEW_LINE> self._order.insert(1, ('global_p', 'ASC')) <NEW_LINE> self._order.insert(2, ('default_p', 'ASC')) <NEW_LINE> self._sql_constraints += [ ('global_default_exclusive', 'CHECK(NOT(global_p AND default_p))', 'Global and Default are mutually exclusive!'), ] <NEW_LINE> <DEDENT> def default_global_p(self): <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> def default_default_p(self): <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> def default_perm_read(self): <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> def default_perm_write(self): <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> def default_perm_create(self): <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> def default_perm_delete(self): <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> def delete(self, ids): <NEW_LINE> <INDENT> res = super(RuleGroup, self).delete(ids) <NEW_LINE> Pool().get('ir.rule').domain_get.reset() <NEW_LINE> return res <NEW_LINE> <DEDENT> def create(self, vals): <NEW_LINE> <INDENT> res = super(RuleGroup, self).create(vals) <NEW_LINE> Pool().get('ir.rule').domain_get.reset() <NEW_LINE> return res <NEW_LINE> <DEDENT> def write(self, ids, vals): <NEW_LINE> <INDENT> res = super(RuleGroup, self).write(ids, vals) <NEW_LINE> Pool().get('ir.rule').domain_get.reset() <NEW_LINE> return res | Rule group | 6259908b26068e7796d4e56d |
class MessageDelay(ChatAction): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> super().__init__() <NEW_LINE> <DEDENT> def exec(self): <NEW_LINE> <INDENT> time.sleep(5) | Represents a message delay | 6259908b99fddb7c1ca63bf2 |
class Config: <NEW_LINE> <INDENT> def __init__(self, buffer_size, buffer_timeout): <NEW_LINE> <INDENT> self.buffer_size = buffer_size <NEW_LINE> self.buffer_timeout = buffer_timeout <NEW_LINE> self.kafka_topic = "test" <NEW_LINE> self.influxdb_dbname = "mydb" <NEW_LINE> self.statistics = False | Dummy config with minimum settings to pass the tests | 6259908b55399d3f05628140 |
class BanditUCBRequest(base_schemas.StrictMappingSchema): <NEW_LINE> <INDENT> subtype = colander.SchemaNode( colander.String(), validator=colander.OneOf(UCB_SUBTYPES), missing=DEFAULT_UCB_SUBTYPE, ) <NEW_LINE> historical_info = BanditHistoricalInfo() | A :mod:`moe.views.rest.bandit_ucb` request colander schema.
**Required fields**
:ivar historical_info: (:class:`moe.views.schemas.bandit_pretty_view.BanditHistoricalInfo`) object of historical data describing arm performance
**Optional fields**
:ivar subtype: (*str*) subtype of the UCB bandit algorithm (default: UCB1)
**Example Minimal Request**
.. sourcecode:: http
Content-Type: text/javascript
{
"historical_info": {
"arms_sampled": {
"arm1": {"win": 20, "loss": 5, "total": 25},
"arm2": {"win": 20, "loss": 10, "total": 30},
"arm3": {"win": 0, "loss": 0, "total": 0},
},
},
}
**Example Full Request**
.. sourcecode:: http
Content-Type: text/javascript
{
"subtype": "UCB1-tuned",
"historical_info": {
"arms_sampled": {
"arm1": {"win": 20, "loss": 5, "total": 25, "variance": 0.1},
"arm2": {"win": 20, "loss": 10, "total": 30, "variance": 0.2},
"arm3": {"win": 0, "loss": 0, "total": 0},
},
},
} | 6259908b71ff763f4b5e93d9 |
class NoJobError(ClientRequestError): <NEW_LINE> <INDENT> pass | The request could not return any job. | 6259908b283ffb24f3cf54cc |
class ItemForm(FlaskForm): <NEW_LINE> <INDENT> name = StringField("name", validators=[InputRequired()]) <NEW_LINE> description = TextAreaField( "description", validators=[optional(), length(max=777)] ) <NEW_LINE> url = StringField("url", validators=[MaybeURL()]) <NEW_LINE> price = IntegerField( "price", validators=[ InputRequired(), NumberRange( min=0, max=777, message="Zadej číslo v intervalu 0 až 777" ), ], ) <NEW_LINE> necessary = BooleanField("necessary", default=False) <NEW_LINE> recommended = BooleanField("recommended", default=False) <NEW_LINE> groups = MultiCheckboxField( validators=[DataRequired("Musí být vybrána alespoň jedna skupina")] ) <NEW_LINE> imgdata = FileField( "Obrázek", validators=[ FileRequired(), FilenameRegexp(r"\.(jpe?g|png|gif|svg|webp)$"), ], ) <NEW_LINE> submit = SubmitField("additem") <NEW_LINE> @db_session <NEW_LINE> def __init__(self, *args, **kwargs): <NEW_LINE> <INDENT> super().__init__(*args, **kwargs) <NEW_LINE> self.groups.choices = [] <NEW_LINE> self.enablegroups = [] <NEW_LINE> for i, g in enumerate(Group.select().order_by(Group.name)): <NEW_LINE> <INDENT> self.groups.choices.append((str(g.id), g.name)) <NEW_LINE> if g.enable: <NEW_LINE> <INDENT> self.enablegroups.append(i) | Přidání položky | 6259908b23849d37ff852ce7 |
class EnumSetting(SettingValue): <NEW_LINE> <INDENT> _DYNAMICALLY_ADDED_OPTIONS = {'defaultTimezone': str} <NEW_LINE> def __init__(self, config: dict): <NEW_LINE> <INDENT> super().__init__(config) <NEW_LINE> config_name = config.get('name') <NEW_LINE> if config_name in self._DYNAMICALLY_ADDED_OPTIONS: <NEW_LINE> <INDENT> self.type = self._DYNAMICALLY_ADDED_OPTIONS[config_name] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.type = list if self.multi_select else type(self.options[0]['value']) <NEW_LINE> <DEDENT> <DEDENT> def _validate_value(self, value, exception=True): <NEW_LINE> <INDENT> options = helper.extract_all_dict_values(self.options) <NEW_LINE> if self.type == list: <NEW_LINE> <INDENT> options.append('') <NEW_LINE> <DEDENT> return helper.validate_param_value(self.name, value, self.type, special_values=options, exception=exception) <NEW_LINE> <DEDENT> def _get_value(self): <NEW_LINE> <INDENT> option_name = [ option['name'] for option in helper.filter_list_of_dicts(self.options, value=self.value) ] <NEW_LINE> if len(option_name) == 1: <NEW_LINE> <INDENT> return option_name[0] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return option_name | Representation of an Enum setting type. | 6259908b3617ad0b5ee07d7e |
class Garmin(object): <NEW_LINE> <INDENT> @staticmethod <NEW_LINE> def get_firmware(device="VIRB", version=4.00): <NEW_LINE> <INDENT> return requests.get("https://download.garmin.com/software/%s_%d.gcd" % ( device, int(version*100))) | Class to namespace any Garmin specific funtions and methods that have no
direct use for any specific device information | 6259908bfff4ab517ebcf443 |
class TheBuildOptions(BaseModel): <NEW_LINE> <INDENT> solvationOptions : TheSystemSolvationOptions = None <NEW_LINE> geometryOptions : TheGeometryOptions = None <NEW_LINE> mdMinimize : bool = Field( True, title = 'Minimize structure using MD', ) <NEW_LINE> numberStructuresHardLimit : int = None <NEW_LINE> def __init__(self, **data : Any): <NEW_LINE> <INDENT> super().__init__(**data) <NEW_LINE> <DEDENT> def setGeometryOptions(self, validatedSequence : str): <NEW_LINE> <INDENT> log.info("Setting geometryOptions in BuildOptions") <NEW_LINE> log.debug("validatedSequence: " + validatedSequence) <NEW_LINE> self.geometryOptions = TheGeometryOptions() <NEW_LINE> self.geometryOptions.setLinkageRotamerInfo(validatedSequence) <NEW_LINE> <DEDENT> def getRotamerData(self) : <NEW_LINE> <INDENT> log.info("buildOptions.getRotamerDataOut was called") <NEW_LINE> if self.geometryOptions is None : <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> else : <NEW_LINE> <INDENT> return self.geometryOptions.getRotamerData() <NEW_LINE> <DEDENT> <DEDENT> def createRotamerData(self) : <NEW_LINE> <INDENT> log.info("Build Options.createRotamerDataOut was called") <NEW_LINE> if self.geometryOptions is None : <NEW_LINE> <INDENT> self.geometryOptions = TheGeometryOptions() <NEW_LINE> <DEDENT> self.geometryOptions.createRotamerData() | Options for building 3D models | 6259908b99fddb7c1ca63bf3 |
class TestBranches(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 testBranches(self): <NEW_LINE> <INDENT> pass | Branches unit test stubs | 6259908bd8ef3951e32c8c74 |
class SuperRubricAdmin(admin.ModelAdmin): <NEW_LINE> <INDENT> exclude = ('super_rubric',) <NEW_LINE> inlines = (SubRubricInline,) | Редактор надрубрик. | 6259908b7cff6e4e811b7670 |
class WordfastHeader(object): <NEW_LINE> <INDENT> def __init__(self, header=None): <NEW_LINE> <INDENT> self._header_dict = [] <NEW_LINE> if not header: <NEW_LINE> <INDENT> self.header = self._create_default_header() <NEW_LINE> <DEDENT> elif isinstance(header, dict): <NEW_LINE> <INDENT> self.header = header <NEW_LINE> <DEDENT> <DEDENT> def _create_default_header(self): <NEW_LINE> <INDENT> defaultheader = WF_FIELDNAMES_HEADER_DEFAULTS <NEW_LINE> defaultheader['date'] = '%%%s' % WordfastTime(time.localtime()).timestring <NEW_LINE> return defaultheader <NEW_LINE> <DEDENT> def getheader(self): <NEW_LINE> <INDENT> return self._header_dict <NEW_LINE> <DEDENT> def setheader(self, newheader): <NEW_LINE> <INDENT> self._header_dict = newheader <NEW_LINE> <DEDENT> header = property(getheader, setheader) <NEW_LINE> def settargetlang(self, newlang): <NEW_LINE> <INDENT> self._header_dict['target-lang'] = '%%%s' % newlang <NEW_LINE> <DEDENT> targetlang = property(None, settargetlang) <NEW_LINE> def settucount(self, count): <NEW_LINE> <INDENT> self._header_dict['tucount'] = '%%TU=%08d' % count <NEW_LINE> <DEDENT> tucount = property(None, settucount) | A wordfast translation memory header | 6259908b656771135c48ae48 |
class LocalDownloader(BaseDownloader): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def download(self, package_dict, **kwargs): <NEW_LINE> <INDENT> if not package_dict: <NEW_LINE> <INDENT> raise ValueError('package_dict is required.') <NEW_LINE> <DEDENT> if 'source_directory' not in kwargs or not kwargs['source_directory']: <NEW_LINE> <INDENT> raise ValueError('source directory is required.') <NEW_LINE> <DEDENT> src_dir = kwargs['source_directory'] <NEW_LINE> package = package_dict['name'] <NEW_LINE> src_package_dir = os.path.join(src_dir, package) <NEW_LINE> dst_package_dir = os.path.join(os.getcwd(), package) <NEW_LINE> LOG.debug('Copying %s to %s .', src_package_dir, dst_package_dir) <NEW_LINE> def ignore_symlinks(directory, files): <NEW_LINE> <INDENT> ignored_files = [] <NEW_LINE> for f in files: <NEW_LINE> <INDENT> full_path = os.path.join(directory, f) <NEW_LINE> if os.path.islink(full_path): <NEW_LINE> <INDENT> ignored_files.append(f) <NEW_LINE> <DEDENT> <DEDENT> return ignored_files <NEW_LINE> <DEDENT> shutil.copytree( src_package_dir, dst_package_dir, ignore=ignore_symlinks, symlinks=True ) | A downloader class to copy a pacakge from source directory. | 6259908b26068e7796d4e571 |
class ResistorForm(AddPartBase): <NEW_LINE> <INDENT> Value = forms.FloatField(label='Value', help_text='Resistor value') <NEW_LINE> Unit = forms.ChoiceField(label="Unit", choices=UnitManager.ResistorChoices) <NEW_LINE> ResistorToler = forms.ChoiceField(label='Tolerance', choices=( (0.05, "0.05%"), (0.1, "0.1%"), (0.25, "0.25%"), (0.5, "0.5%"), (1.0, "1%"), (2.0, "2%"), (5.0, "5%"), (10.0, "10%"), )) <NEW_LINE> field_order = ['Value', 'Unit', 'PartQuantity',] | Form for adding a resistor | 6259908b99fddb7c1ca63bf4 |
@injectable() <NEW_LINE> @dataclass <NEW_LINE> class Greeter: <NEW_LINE> <INDENT> punctuation: str = get(SiteConfig, attr="punctuation") <NEW_LINE> greeting: str = "Hello" <NEW_LINE> def greet(self) -> str: <NEW_LINE> <INDENT> return f"{self.greeting}{self.punctuation}" | A simple greeter. | 6259908b63b5f9789fe86d98 |
class ShortDescription(Model): <NEW_LINE> <INDENT> _attribute_map = { 'problem': {'key': 'problem', 'type': 'str'}, 'solution': {'key': 'solution', 'type': 'str'}, } <NEW_LINE> def __init__(self, problem=None, solution=None): <NEW_LINE> <INDENT> super(ShortDescription, self).__init__() <NEW_LINE> self.problem = problem <NEW_LINE> self.solution = solution | A summary of the recommendation.
:param problem: The issue or opportunity identified by the recommendation.
:type problem: str
:param solution: The remediation action suggested by the recommendation.
:type solution: str | 6259908bbf627c535bcb3101 |
class GameScrapyItem(scrapy.Item): <NEW_LINE> <INDENT> name = scrapy.Field() <NEW_LINE> foreign_name = scrapy.Field() <NEW_LINE> language = scrapy.Field() <NEW_LINE> tags = scrapy.Field() <NEW_LINE> company = scrapy.Field() <NEW_LINE> type = scrapy.Field() <NEW_LINE> desc = scrapy.Field() | 游戏信息爬虫 | 6259908b283ffb24f3cf54d0 |
class MetisView(object): <NEW_LINE> <INDENT> def __init__(self, control): <NEW_LINE> <INDENT> self._control = control <NEW_LINE> <DEDENT> @property <NEW_LINE> def rect(self): <NEW_LINE> <INDENT> x = 0 <NEW_LINE> y = 0 <NEW_LINE> w = abs(self._control.BoundingRect.Right - self._control.BoundingRect.Left) <NEW_LINE> h = abs(self._control.BoundingRect.Top - self._control.BoundingRect.Bottom) <NEW_LINE> return x, y, w, h <NEW_LINE> <DEDENT> @property <NEW_LINE> def os_type(self): <NEW_LINE> <INDENT> return 'pc' <NEW_LINE> <DEDENT> def screenshot(self): <NEW_LINE> <INDENT> bbox =(self._control.BoundingRect.Left,self._control.BoundingRect.Top, self._control.BoundingRect.Right,self._control.BoundingRect.Bottom) <NEW_LINE> im = ImageGrab.grab(bbox) <NEW_LINE> return im <NEW_LINE> <DEDENT> def click(self, offset_x=None, offset_y=None): <NEW_LINE> <INDENT> if offset_x != None: <NEW_LINE> <INDENT> offset_x = int(offset_x*abs(self._control.BoundingRect.Right - self._control.BoundingRect.Left)) <NEW_LINE> <DEDENT> if offset_y != None: <NEW_LINE> <INDENT> offset_y = int(offset_y*abs(self._control.BoundingRect.Top - self._control.BoundingRect.Bottom)) <NEW_LINE> <DEDENT> self._control.click(xOffset=offset_x, yOffset=offset_y) <NEW_LINE> <DEDENT> def send_keys(self, text): <NEW_LINE> <INDENT> Keyboard.inputKeys(text) <NEW_LINE> <DEDENT> def double_click(self, offset_x=None, offset_y=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def long_click(self, offset_x=None, offset_y=None): <NEW_LINE> <INDENT> pass | 各端实现的MetisView
| 6259908ba8370b77170f1ffc |
class IOpenIdPrincipal(interface.Interface): <NEW_LINE> <INDENT> title = schema.TextLine( title = _('Title'), required = True) <NEW_LINE> identifier = interface.Attribute('OpenID Identifier') | openid principal | 6259908c3617ad0b5ee07d82 |
class StorageStyle(object): <NEW_LINE> <INDENT> def __init__(self, key, list_elem = True, as_type = unicode, packing = None, pack_pos = 0, id3_desc = None): <NEW_LINE> <INDENT> self.key = key <NEW_LINE> self.list_elem = list_elem <NEW_LINE> self.as_type = as_type <NEW_LINE> self.packing = packing <NEW_LINE> self.pack_pos = pack_pos <NEW_LINE> self.id3_desc = id3_desc | Parameterizes the storage behavior of a single field for a
certain tag format.
- key: The Mutagen key used to access the field's data.
- list_elem: Store item as a single object or as first element
of a list.
- as_type: Which type the value is stored as (unicode, int,
bool, or str).
- packing: If this value is packed in a multiple-value storage
unit, which type of packing (in the packing enum). Otherwise,
None. (Makes as_type irrelevant).
- pack_pos: If the value is packed, in which position it is
stored.
- ID3 storage only: match against this 'desc' field as well
as the key. | 6259908c4a966d76dd5f0b16 |
class ConditionalPredicateValueDefnumberArraynullExprRef(VegaLiteSchema): <NEW_LINE> <INDENT> _schema = {'$ref': '#/definitions/ConditionalPredicate<(ValueDef<(number[]|null)>|ExprRef)>'} <NEW_LINE> def __init__(self, *args, **kwds): <NEW_LINE> <INDENT> super(ConditionalPredicateValueDefnumberArraynullExprRef, self).__init__(*args, **kwds) | ConditionalPredicateValueDefnumberArraynullExprRef schema wrapper
anyOf(Mapping(required=[test, value]), Mapping(required=[expr, test])) | 6259908c656771135c48ae49 |
class JobHandle(_M_omero.api.StatefulServiceInterface): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> if __builtin__.type(self) == _M_omero.api.JobHandle: <NEW_LINE> <INDENT> raise RuntimeError('omero.api.JobHandle is an abstract class') <NEW_LINE> <DEDENT> <DEDENT> def ice_ids(self, current=None): <NEW_LINE> <INDENT> return ('::Ice::Object', '::omero::api::JobHandle', '::omero::api::ServiceInterface', '::omero::api::StatefulServiceInterface') <NEW_LINE> <DEDENT> def ice_id(self, current=None): <NEW_LINE> <INDENT> return '::omero::api::JobHandle' <NEW_LINE> <DEDENT> def ice_staticId(): <NEW_LINE> <INDENT> return '::omero::api::JobHandle' <NEW_LINE> <DEDENT> ice_staticId = staticmethod(ice_staticId) <NEW_LINE> def submit_async(self, _cb, j, current=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def attach_async(self, _cb, jobId, current=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def getJob_async(self, _cb, current=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def jobStatus_async(self, _cb, current=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def jobFinished_async(self, _cb, current=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def jobMessage_async(self, _cb, current=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def jobRunning_async(self, _cb, current=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def jobError_async(self, _cb, current=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def cancelJob_async(self, _cb, current=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def setStatus_async(self, _cb, status, current=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def setMessage_async(self, _cb, message, current=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def setStatusAndMessage_async(self, _cb, status, message, current=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return IcePy.stringify(self, _M_omero.api._t_JobHandle) <NEW_LINE> <DEDENT> __repr__ = __str__ | See JobHandle.html | 6259908c4527f215b58eb7b8 |
class IndexedTableUsage(ScalarTableMixin, BaseTableUsageTestCase): <NEW_LINE> <INDENT> nrows = 50 <NEW_LINE> indexed = True <NEW_LINE> def setUp(self): <NEW_LINE> <INDENT> super(IndexedTableUsage, self).setUp() <NEW_LINE> self.table.cols.c_bool.create_index(_blocksizes=small_blocksizes) <NEW_LINE> self.table.cols.c_int32.create_index(_blocksizes=small_blocksizes) <NEW_LINE> self.will_query_use_indexing = self.table.will_query_use_indexing <NEW_LINE> self.compileCondition = self.table._compile_condition <NEW_LINE> self.requiredExprVars = self.table._required_expr_vars <NEW_LINE> usable_idxs = set() <NEW_LINE> for expr in self.idx_expr: <NEW_LINE> <INDENT> idxvar = expr[0] <NEW_LINE> if idxvar not in usable_idxs: <NEW_LINE> <INDENT> usable_idxs.add(idxvar) <NEW_LINE> <DEDENT> <DEDENT> self.usable_idxs = frozenset(usable_idxs) <NEW_LINE> <DEDENT> def test(self): <NEW_LINE> <INDENT> for condition in self.conditions: <NEW_LINE> <INDENT> c_usable_idxs = self.will_query_use_indexing(condition, {}) <NEW_LINE> self.assertEqual(c_usable_idxs, self.usable_idxs, "\nQuery with condition: ``%s``\n" "Computed usable indexes are: ``%s``\n" "and should be: ``%s``" % (condition, c_usable_idxs, self.usable_idxs)) <NEW_LINE> condvars = self.requiredExprVars(condition, None) <NEW_LINE> compiled = self.compileCondition(condition, condvars) <NEW_LINE> c_idx_expr = compiled.index_expressions <NEW_LINE> self.assertEqual(c_idx_expr, self.idx_expr, "\nWrong index expression in condition:\n``%s``\n" "Compiled index expression is:\n``%s``\n" "and should be:\n``%s``" % (condition, c_idx_expr, self.idx_expr)) <NEW_LINE> c_str_expr = compiled.string_expression <NEW_LINE> self.assertEqual(c_str_expr, self.str_expr, "\nWrong index operations in condition:\n``%s``\n" "Computed index operations are:\n``%s``\n" "and should be:\n``%s``" % (condition, c_str_expr, self.str_expr)) <NEW_LINE> vprint("* Query with condition ``%s`` will use " "variables ``%s`` for indexing." % (condition, compiled.index_variables)) | Test case for query usage on indexed tables.
Indexing could be used in more cases, but it is expected to kick in
at least in the cases tested here. | 6259908c5fdd1c0f98e5fba8 |
class metaextract(Command): <NEW_LINE> <INDENT> description = "extract package metadata" <NEW_LINE> user_options = [ ("output=", "o", "output for metadata json") ] <NEW_LINE> def initialize_options(self): <NEW_LINE> <INDENT> self.output = None <NEW_LINE> <DEDENT> def finalize_options(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def run(self): <NEW_LINE> <INDENT> data = dict() <NEW_LINE> for key in ['data_files', 'entry_points', 'extras_require', 'install_requires', 'python_requires', 'setup_requires', 'scripts', 'tests_require', 'tests_suite']: <NEW_LINE> <INDENT> if hasattr(self.distribution, key): <NEW_LINE> <INDENT> data[key] = getattr(self.distribution, key) <NEW_LINE> if data[key].__class__.__name__ == 'dict_items': <NEW_LINE> <INDENT> data[key] = list(data[key]) <NEW_LINE> <DEDENT> if key == 'entry_points' and isinstance(data[key], dict): <NEW_LINE> <INDENT> for k, v in data[key].items(): <NEW_LINE> <INDENT> if isinstance(v, set): <NEW_LINE> <INDENT> data[key][k] = list(v) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> <DEDENT> <DEDENT> for func in ['get_author', 'get_author_email', 'get_classifiers', 'get_contact', 'get_contact_email', 'get_description', 'get_download_url', 'get_fullname', 'get_keywords', 'get_license', 'get_long_description', 'get_mainainer', 'get_maintainer_email', 'get_name', 'get_url', 'get_version', 'get_download_url', 'get_fullname', 'get_author', 'get_author_email', 'has_ext_modules']: <NEW_LINE> <INDENT> if hasattr(self.distribution, func): <NEW_LINE> <INDENT> data['{}'.format(func.replace('get_', ''))] = getattr( self.distribution, func)() <NEW_LINE> <DEDENT> <DEDENT> data_with_version = { 'version': DATA_VERSION, 'data': data } <NEW_LINE> if self.output: <NEW_LINE> <INDENT> with open(self.output, "w+") as f: <NEW_LINE> <INDENT> f.write(json.dumps(data_with_version, indent=2, sort_keys=True, default=str)) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> print(json.dumps(data_with_version, indent=2, sort_keys=True, default=str)) | a distutils command to extract metadata | 6259908c99fddb7c1ca63bf5 |
class StartDoingRandomActionsWrapper(gym.Wrapper): <NEW_LINE> <INDENT> def __init__(self, env, max_random_steps, on_startup=True, every_episode=False): <NEW_LINE> <INDENT> gym.Wrapper.__init__(self, env) <NEW_LINE> self.on_startup = on_startup <NEW_LINE> self.every_episode = every_episode <NEW_LINE> self.random_steps = max_random_steps <NEW_LINE> self.last_obs = None <NEW_LINE> if on_startup: <NEW_LINE> <INDENT> self.some_random_steps() <NEW_LINE> <DEDENT> <DEDENT> def some_random_steps(self): <NEW_LINE> <INDENT> self.last_obs = self.env.reset() <NEW_LINE> n = np.random.randint(self.random_steps) <NEW_LINE> for _ in range(n): <NEW_LINE> <INDENT> self.last_obs, _, done, _ = self.env.step(self.env.action_space.sample()) <NEW_LINE> if done: self.last_obs = self.env.reset() <NEW_LINE> <DEDENT> <DEDENT> def reset(self): <NEW_LINE> <INDENT> return self.last_obs <NEW_LINE> <DEDENT> def step(self, a): <NEW_LINE> <INDENT> self.last_obs, rew, done, info = self.env.step(a) <NEW_LINE> if done: <NEW_LINE> <INDENT> self.last_obs = self.env.reset() <NEW_LINE> if self.every_episode: <NEW_LINE> <INDENT> self.some_random_steps() <NEW_LINE> <DEDENT> <DEDENT> return self.last_obs, rew, done, info | Warning: can eat info dicts, not good if you depend on them | 6259908cd486a94d0ba2dbe6 |
class Num(Widget): <NEW_LINE> <INDENT> class SpecialDigit(enum.Enum): <NEW_LINE> <INDENT> COLON = 10 <NEW_LINE> <DEDENT> def __init__(self, name: str, x: int, digit: typing.Union[int, SpecialDigit]): <NEW_LINE> <INDENT> super().__init__(WidgetType.BIGNUM, name) <NEW_LINE> self._validate_params(x, digit) <NEW_LINE> self._x = x <NEW_LINE> self._digit = digit <NEW_LINE> <DEDENT> def __repr__(self) -> str: <NEW_LINE> <INDENT> return (f'{self.__class__.__name__}({self.name!r}, {self.x!r}, ' f'{self.digit!r})') <NEW_LINE> <DEDENT> def _validate_params(self, x: int, digit: typing.Union[int, SpecialDigit]): <NEW_LINE> <INDENT> if x < 1: <NEW_LINE> <INDENT> raise ValueError(f'invalid bignum placement position: x: {x}') <NEW_LINE> <DEDENT> if isinstance(digit, int): <NEW_LINE> <INDENT> if digit not in range(10): <NEW_LINE> <INDENT> raise ValueError(f'invalid decimal digit to display: {digit}') <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> @property <NEW_LINE> def x(self) -> int: <NEW_LINE> <INDENT> return self._x <NEW_LINE> <DEDENT> @x.setter <NEW_LINE> def x(self, new_x: int): <NEW_LINE> <INDENT> self._validate_params(new_x, self.digit) <NEW_LINE> self._x = new_x <NEW_LINE> <DEDENT> @property <NEW_LINE> def digit(self) -> typing.Union[int, SpecialDigit]: <NEW_LINE> <INDENT> return self._digit <NEW_LINE> <DEDENT> @digit.setter <NEW_LINE> def digit(self, new_digit: typing.Union[int, SpecialDigit]): <NEW_LINE> <INDENT> self._validate_params(self.x, new_digit) <NEW_LINE> self._digit = new_digit <NEW_LINE> <DEDENT> def state_update_requests(self, screen_id: int, widget_ids: typing.Sequence[int]) -> typing.Sequence[bytes]: <NEW_LINE> <INDENT> reqs = list() <NEW_LINE> reqs.append(commands.CommandGenerator.generate_set_widget_parms_command( screen_id, widget_ids[0], self.x, self.digit if isinstance(self.digit, int) else self.digit.value )) <NEW_LINE> return reqs | Widget representing a big decimal digit | 6259908c63b5f9789fe86d9a |
class IndexEntriesVerifier: <NEW_LINE> <INDENT> def __init__(self, specificindexentries=None, testindexentries=None): <NEW_LINE> <INDENT> self._specificIndexEntries = specificindexentries <NEW_LINE> self._testIndexEntries = testindexentries <NEW_LINE> self._buildLogs = { "ProjectLogs": [ ] } <NEW_LINE> return <NEW_LINE> <DEDENT> def _addToFinalLog(self, tid, appid, jobid, resultset): <NEW_LINE> <INDENT> self._buildLogs["ProjectLogs"].append( { "id": tid, "app-id": appid, "job-id": jobid, "results": resultset } ) <NEW_LINE> return <NEW_LINE> <DEDENT> def _writeFinalLog(self): <NEW_LINE> <INDENT> with open(Globals.buildinfo, "w+") as buildinfofile: <NEW_LINE> <INDENT> yaml.dump(self._buildLogs, buildinfofile) <NEW_LINE> <DEDENT> return <NEW_LINE> <DEDENT> def run(self): <NEW_LINE> <INDENT> success = True <NEW_LINE> successlist = [] <NEW_LINE> indexdata = None <NEW_LINE> with open(Globals.indexFile) as indexfile: <NEW_LINE> <INDENT> indexdata = yaml.load(indexfile) <NEW_LINE> <DEDENT> if self._specificIndexEntries is None and self._testIndexEntries is None: <NEW_LINE> <INDENT> for project in indexdata["Projects"]: <NEW_LINE> <INDENT> tid = project["id"] <NEW_LINE> appid = project["app-id"] <NEW_LINE> jobid = project["job-id"] <NEW_LINE> giturl = project["git-url"] <NEW_LINE> gitbranch = project["git-branch"] <NEW_LINE> gitpath = project["git-path"] <NEW_LINE> notifyemail = project["notify-email"] <NEW_LINE> if tid != "default": <NEW_LINE> <INDENT> testresults = ValidateEntry(tid, appid, jobid, giturl, gitpath, gitbranch, notifyemail).run() <NEW_LINE> successlist.append(testresults["tests"]["allpass"]) <NEW_LINE> self._addToFinalLog(tid, appid, jobid, testresults) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> if self._specificIndexEntries is not None: <NEW_LINE> <INDENT> for project in indexdata["Projects"]: <NEW_LINE> <INDENT> tid = project["id"] <NEW_LINE> if tid in self._specificIndexEntries: <NEW_LINE> <INDENT> appid = project["app-id"] <NEW_LINE> jobid = project["job-id"] <NEW_LINE> giturl = project["git-url"] <NEW_LINE> gitbranch = project["git-branch"] <NEW_LINE> gitpath = project["git-path"] <NEW_LINE> notifyemail = project["notify-email"] <NEW_LINE> if tid != "default": <NEW_LINE> <INDENT> testresults = ValidateEntry(tid, appid, jobid, giturl, gitpath, gitbranch, notifyemail).run() <NEW_LINE> successlist.append(testresults["tests"]["allpass"]) <NEW_LINE> self._addToFinalLog(tid, appid, jobid, testresults) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> <DEDENT> if self._testIndexEntries is not None: <NEW_LINE> <INDENT> for item in self._testIndexEntries: <NEW_LINE> <INDENT> tid = item[0] <NEW_LINE> appid = item[1] <NEW_LINE> jobid = item[2] <NEW_LINE> giturl = item[3] <NEW_LINE> gitpath = item[4] <NEW_LINE> gitbranch = item[5] <NEW_LINE> notifyemail = item[6] <NEW_LINE> testresults = ValidateEntry(tid, appid, jobid, giturl, gitpath, gitbranch, notifyemail).run() <NEW_LINE> successlist.append(testresults["tests"]["allpass"]) <NEW_LINE> self._addToFinalLog(tid, appid, jobid, testresults) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> self._writeFinalLog() <NEW_LINE> if False in successlist: <NEW_LINE> <INDENT> success = False <NEW_LINE> <DEDENT> return success | Handles the verification of individual index entries, w.r.t index.yml and cccp.yml,
based on Engines instructions | 6259908cad47b63b2c5a9482 |
class TestOperation(Component): <NEW_LINE> <INDENT> implements(api.ITicketActionController) <NEW_LINE> def get_ticket_actions(self, req, ticket): <NEW_LINE> <INDENT> return [(0, 'test')] <NEW_LINE> <DEDENT> def get_all_status(self): <NEW_LINE> <INDENT> return [] <NEW_LINE> <DEDENT> def render_ticket_action_control(self, req, ticket, action): <NEW_LINE> <INDENT> return "test", '', "This is a null action." <NEW_LINE> <DEDENT> def get_ticket_changes(self, req, ticket, action): <NEW_LINE> <INDENT> return {} <NEW_LINE> <DEDENT> def apply_action_side_effects(self, req, ticket, action): <NEW_LINE> <INDENT> pass | TicketActionController that directly provides an action. | 6259908cf9cc0f698b1c60e4 |
class Particle(object): <NEW_LINE> <INDENT> scene = None <NEW_LINE> scaleX = 1000.0 <NEW_LINE> scaleY = 1000.0 <NEW_LINE> brush = QBrush(Qt.darkGreen) <NEW_LINE> pen = QPen(Qt.NoPen) <NEW_LINE> def __init__(self, p, r): <NEW_LINE> <INDENT> self._p = p <NEW_LINE> self._r = r <NEW_LINE> self.item = Particle.scene.addEllipse(0.0, 0.0, 10.0, 10.0, Particle.pen, Particle.brush) <NEW_LINE> self.update(0) <NEW_LINE> <DEDENT> def update(self, step): <NEW_LINE> <INDENT> self.item.setRect(self._p[step,0]*Particle.scaleX-self._r*Particle.scaleX, self._p[step,1]*Particle.scaleY-self._r*Particle.scaleY, self._r*Particle.scaleX*2.0, self._r*Particle.scaleY*2.0) | Particle class - Visual particle representation | 6259908c656771135c48ae4a |
class GrpParser(object): <NEW_LINE> <INDENT> def readLoc(self, locfiles, speciesNames = None): <NEW_LINE> <INDENT> firstLine=True <NEW_LINE> res = {} <NEW_LINE> for lf in locfiles: <NEW_LINE> <INDENT> tmpfile = open(lf,'r') <NEW_LINE> for ln in tmpfile: <NEW_LINE> <INDENT> if firstLine: <NEW_LINE> <INDENT> firstLine = False <NEW_LINE> <DEDENT> ln = ln.rstrip() <NEW_LINE> tmp = ln.split("\t") <NEW_LINE> k,v = str(tmp[0]),tmp[1:] <NEW_LINE> res[k]=v <NEW_LINE> <DEDENT> tmpfile.close() <NEW_LINE> <DEDENT> return(res) <NEW_LINE> <DEDENT> def readGroups(self, grpf, locf, speciesNames = None): <NEW_LINE> <INDENT> grp = open(grpf, 'r') <NEW_LINE> locDct = self.readLoc(locfiles =locf) <NEW_LINE> traDct ={} <NEW_LINE> for l in grp: <NEW_LINE> <INDENT> tmp = l.strip().split("\t") <NEW_LINE> grpID = tmp[0] <NEW_LINE> tmpLoci=tmp[1:] <NEW_LINE> try: <NEW_LINE> <INDENT> tr = [locDct[x] for x in tmpLoci] <NEW_LINE> <DEDENT> except KeyError as ke: <NEW_LINE> <INDENT> print("key error",ke," @readGroups. Locus does not appear to have transcripts.") <NEW_LINE> <DEDENT> traDct[grpID] = tr <NEW_LINE> yield int(grpID), traDct[grpID] <NEW_LINE> <DEDENT> grp.close() <NEW_LINE> <DEDENT> def groupDct(self, grpf, locf,speciesNames = None): <NEW_LINE> <INDENT> res = {} <NEW_LINE> for sth in self.readGroups(grpf, locf,speciesNames): <NEW_LINE> <INDENT> res[sth[0]]=sth[1:][0] <NEW_LINE> <DEDENT> return res | read .loc files. Return dictionary with locus ID as key and transcript list as value | 6259908c26068e7796d4e575 |
class TestDeviceInnerDeviceInfo(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 testDeviceInnerDeviceInfo(self): <NEW_LINE> <INDENT> pass | DeviceInnerDeviceInfo unit test stubs | 6259908c99fddb7c1ca63bf6 |
class Registry: <NEW_LINE> <INDENT> def __init__(self, name=None, types=None, enums=None, commands=None, features=None, extensions=None): <NEW_LINE> <INDENT> self.name = name <NEW_LINE> self.types = collections.OrderedDict(types or ()) <NEW_LINE> self.enums = collections.OrderedDict(enums or ()) <NEW_LINE> self.commands = collections.OrderedDict(commands or ()) <NEW_LINE> self.features = collections.OrderedDict(features or ()) <NEW_LINE> self.extensions = collections.OrderedDict(extensions or ()) <NEW_LINE> <DEDENT> @property <NEW_LINE> def text(self): <NEW_LINE> <INDENT> out = [] <NEW_LINE> out.extend(x.text for x in self.types.values()) <NEW_LINE> out.extend(x.text for x in self.enums.values()) <NEW_LINE> out.extend('extern {0};'.format(x.text) for x in self.commands.values()) <NEW_LINE> return '\n'.join(out) <NEW_LINE> <DEDENT> def get_type(self, name, api=None): <NEW_LINE> <INDENT> k = (name, api) <NEW_LINE> if k in self.types: <NEW_LINE> <INDENT> return self.types[k] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return self.types[(name, None)] <NEW_LINE> <DEDENT> <DEDENT> def get_features(self, api=None): <NEW_LINE> <INDENT> return [x for x in self.features.values() if api and x.api == api or not api] <NEW_LINE> <DEDENT> def get_extensions(self, support=None): <NEW_LINE> <INDENT> return [x for x in self.extensions.values() if support and support in x.supported or not support] <NEW_LINE> <DEDENT> def get_requires(self, api=None, profile=None, support=None): <NEW_LINE> <INDENT> out = [] <NEW_LINE> for ft in self.get_features(api): <NEW_LINE> <INDENT> out.extend(ft.get_requires(profile)) <NEW_LINE> <DEDENT> for ext in self.extensions.values(): <NEW_LINE> <INDENT> if support and support not in ext.supported: <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> out.extend(ext.get_requires(api, profile)) <NEW_LINE> <DEDENT> return out <NEW_LINE> <DEDENT> def get_removes(self, api=None, profile=None): <NEW_LINE> <INDENT> out = [] <NEW_LINE> for ft in self.get_features(api): <NEW_LINE> <INDENT> out.extend(ft.get_removes(profile)) <NEW_LINE> <DEDENT> return out <NEW_LINE> <DEDENT> def get_apis(self): <NEW_LINE> <INDENT> out = set(x.api for x in self.types.values() if x.api) <NEW_LINE> for ft in self.features.values(): <NEW_LINE> <INDENT> out.update(ft.get_apis()) <NEW_LINE> <DEDENT> for ext in self.extensions.values(): <NEW_LINE> <INDENT> out.update(ext.get_apis()) <NEW_LINE> <DEDENT> return out <NEW_LINE> <DEDENT> def get_profiles(self): <NEW_LINE> <INDENT> out = set() <NEW_LINE> for ft in self.features.values(): <NEW_LINE> <INDENT> out.update(ft.get_profiles()) <NEW_LINE> <DEDENT> for ext in self.extensions.values(): <NEW_LINE> <INDENT> out.update(ext.get_profiles()) <NEW_LINE> <DEDENT> return out <NEW_LINE> <DEDENT> def get_supports(self): <NEW_LINE> <INDENT> out = set() <NEW_LINE> for ext in self.extensions.values(): <NEW_LINE> <INDENT> out.update(ext.get_supports()) <NEW_LINE> <DEDENT> return out <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return _repr(self, (self.name,), (self.types, self.enums, self.commands, self.features, self.extensions)) | API Registry
| 6259908c50812a4eaa6219df |
class InvalidSpaceParameterError(Exception): <NEW_LINE> <INDENT> def __init__(self, space_type, param): <NEW_LINE> <INDENT> self.message = 'Invalid parameter for space type {}: {}.'.format( space_type, param) | An error raised if the specified experimental space parameters are missing or invalid. | 6259908c71ff763f4b5e93e1 |
Subsets and Splits