code
stringlengths 4
4.48k
| docstring
stringlengths 1
6.45k
| _id
stringlengths 24
24
|
|---|---|---|
class CalcK6C(CalcRecip): <NEW_LINE> <INDENT> def __init__(self, **kwargs): <NEW_LINE> <INDENT> super().__init__("K6C", **kwargs) | Geometry: K6C | 62599095be7bc26dc9252d11 |
class PaymentRequired(CanonicalHTTPError): <NEW_LINE> <INDENT> def __init__(self, **kwargs): <NEW_LINE> <INDENT> super().__init__(402, 'Payment Required', kwargs) | When the user hasn't coughed it up. | 62599095283ffb24f3cf5612 |
class QgisLogHandler(logging.StreamHandler): <NEW_LINE> <INDENT> def __init__(self, topic): <NEW_LINE> <INDENT> logging.StreamHandler.__init__(self) <NEW_LINE> self.topic = topic <NEW_LINE> <DEDENT> def emit(self, record): <NEW_LINE> <INDENT> msg = self.format(record) <NEW_LINE> from qgis.core import QgsMessageLog <NEW_LINE> QgsMessageLog.logMessage('{}'.format(msg), self.topic, Qgis.Info) | Some magic to make it possible to use code like:
import logging
from . import LOGGER_NAME
log = logging.getLogger(LOGGER_NAME)
in all this plugin code, and it will show up in the QgsMessageLog | 62599096283ffb24f3cf5614 |
class MinimaxPlayer(IsolationPlayer): <NEW_LINE> <INDENT> def get_move(self, game, time_left): <NEW_LINE> <INDENT> self.time_left = time_left <NEW_LINE> try: <NEW_LINE> <INDENT> return self.minimax(game, self.search_depth) <NEW_LINE> <DEDENT> except SearchTimeout: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> return [-1, -1] <NEW_LINE> <DEDENT> def minimax(self, game, depth): <NEW_LINE> <INDENT> def max_value(self, game, depth): <NEW_LINE> <INDENT> if self.time_left() < self.TIMER_THRESHOLD: raise SearchTimeout() <NEW_LINE> if depth == 0: return self.score(game, self) <NEW_LINE> best_val = float("-inf") <NEW_LINE> for i in game.get_legal_moves(): <NEW_LINE> <INDENT> v = min_value(self, game.forecast_move(i), depth - 1) <NEW_LINE> best_val = max(v, best_val) <NEW_LINE> <DEDENT> return best_val <NEW_LINE> <DEDENT> def min_value(self, game, depth): <NEW_LINE> <INDENT> if self.time_left() < self.TIMER_THRESHOLD: raise SearchTimeout() <NEW_LINE> if depth == 0: return self.score(game, self) <NEW_LINE> best_val = float("inf") <NEW_LINE> for i in game.get_legal_moves(): <NEW_LINE> <INDENT> v = max_value(self, game.forecast_move(i), depth - 1) <NEW_LINE> best_val = min(v, best_val) <NEW_LINE> <DEDENT> return best_val <NEW_LINE> <DEDENT> best_score = float('-inf') <NEW_LINE> best_move = (-1, -1) <NEW_LINE> for i in game.get_legal_moves(): <NEW_LINE> <INDENT> score = min_value(self, game.forecast_move(i), depth-1) <NEW_LINE> if score >= best_score: <NEW_LINE> <INDENT> best_score = score <NEW_LINE> best_move = i <NEW_LINE> <DEDENT> <DEDENT> return best_move | Game-playing agent that chooses a move using depth-limited minimax
search. You must finish and test this player to make sure it properly uses
minimax to return a good move before the search time limit expires. | 625990965fdd1c0f98e5fcef |
class RestrictedCommandHandler(CommandHandler): <NEW_LINE> <INDENT> def parse_body(self, body): <NEW_LINE> <INDENT> response = None <NEW_LINE> if body: <NEW_LINE> <INDENT> for (command, args, hlp) in configuration.commands.restricted_set(): <NEW_LINE> <INDENT> if re.match("^help((\s+" + command + "\s*)|(\s*))$", body): <NEW_LINE> <INDENT> if response: <NEW_LINE> <INDENT> response = "%s\n%s - %s" % (response, command, hlp) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> response = "%s - %s" % (command, hlp) <NEW_LINE> <DEDENT> <DEDENT> if command == body: <NEW_LINE> <INDENT> response = self.do_command(command, args) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> return response <NEW_LINE> <DEDENT> def do_command(self, command, args = None): <NEW_LINE> <INDENT> if "bye" == command: <NEW_LINE> <INDENT> client = Client() <NEW_LINE> client.change_status(u"terminating session", False) <NEW_LINE> client.disconnect() <NEW_LINE> return u"terminating" <NEW_LINE> <DEDENT> cmd = [command] <NEW_LINE> if args: <NEW_LINE> <INDENT> cmd.extend(args) <NEW_LINE> <DEDENT> try: <NEW_LINE> <INDENT> body = self.make_syscall(cmd) <NEW_LINE> <DEDENT> except OSError as ex: <NEW_LINE> <INDENT> body = "%s: %s (%d)" % (type(ex), ex.strerror, ex.errno) <NEW_LINE> <DEDENT> return body <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def make_syscall(command): <NEW_LINE> <INDENT> subp = subprocess.Popen(command, stdout=subprocess.PIPE) <NEW_LINE> stdoutdata = subp.communicate()[0] <NEW_LINE> return "%s (%d):\n%s" % (command, subp.returncode, stdoutdata) | This type implements a restricted command feature.
Any command parsed by this type is tested for existence in the
list returned by the restricted_set function in the commands module,
and if the command exists within that set, it is executed as a
system command. | 62599096ad47b63b2c5a95a1 |
class Node(object): <NEW_LINE> <INDENT> def __init__(self, name=None, labels=None, props=None): <NEW_LINE> <INDENT> self.name = name or '' <NEW_LINE> self.labels = labels or [] <NEW_LINE> self.props = props or {} <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return '({})'.format(self.name) | An object to represent a single graph node. | 62599096be7bc26dc9252d13 |
class SonosEntity(Entity): <NEW_LINE> <INDENT> def __init__(self, speaker: SonosSpeaker) -> None: <NEW_LINE> <INDENT> self.speaker = speaker <NEW_LINE> <DEDENT> async def async_added_to_hass(self) -> None: <NEW_LINE> <INDENT> await self.speaker.async_seen() <NEW_LINE> self.async_on_remove( async_dispatcher_connect( self.hass, f"{SONOS_POLL_UPDATE}-{self.soco.uid}", self.async_poll, ) ) <NEW_LINE> self.async_on_remove( async_dispatcher_connect( self.hass, f"{SONOS_STATE_UPDATED}-{self.soco.uid}", self.async_write_ha_state, ) ) <NEW_LINE> self.async_on_remove( async_dispatcher_connect( self.hass, f"{SONOS_HOUSEHOLD_UPDATED}-{self.soco.household_id}", self.async_write_ha_state, ) ) <NEW_LINE> async_dispatcher_send( self.hass, f"{SONOS_ENTITY_CREATED}-{self.soco.uid}", self.platform.domain ) <NEW_LINE> <DEDENT> async def async_poll(self, now: datetime.datetime) -> None: <NEW_LINE> <INDENT> if self.speaker.is_first_poll: <NEW_LINE> <INDENT> _LOGGER.warning( "%s cannot reach [%s], falling back to polling, functionality may be limited", self.speaker.zone_name, self.speaker.subscription_address, ) <NEW_LINE> self.speaker.is_first_poll = False <NEW_LINE> <DEDENT> await self.async_update() <NEW_LINE> <DEDENT> @property <NEW_LINE> def soco(self) -> SoCo: <NEW_LINE> <INDENT> return self.speaker.soco <NEW_LINE> <DEDENT> @property <NEW_LINE> def device_info(self) -> DeviceInfo: <NEW_LINE> <INDENT> return { "identifiers": {(DOMAIN, self.soco.uid)}, "name": self.speaker.zone_name, "model": self.speaker.model_name.replace("Sonos ", ""), "sw_version": self.speaker.version, "connections": {(dr.CONNECTION_NETWORK_MAC, self.speaker.mac_address)}, "manufacturer": "Sonos", "suggested_area": self.speaker.zone_name, } <NEW_LINE> <DEDENT> @property <NEW_LINE> def available(self) -> bool: <NEW_LINE> <INDENT> return self.speaker.available <NEW_LINE> <DEDENT> @property <NEW_LINE> def should_poll(self) -> bool: <NEW_LINE> <INDENT> return False | Representation of a Sonos entity. | 625990968a349b6b43687fdc |
class OpenldapAccount(BaseAccount): <NEW_LINE> <INDENT> @classmethod <NEW_LINE> def get_fields(cls) -> Dict[str, tldap.fields.Field]: <NEW_LINE> <INDENT> fields = { **BaseAccount.get_fields(), **helpers.get_fields_pwdpolicy(), } <NEW_LINE> return fields <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def on_load(cls, python_data: LdapObject, database: Database) -> LdapObject: <NEW_LINE> <INDENT> python_data = BaseAccount.on_load(python_data, database) <NEW_LINE> python_data = helpers.load_pwdpolicy(python_data) <NEW_LINE> return python_data <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def on_save(cls, changes: Changeset, database: Database) -> Changeset: <NEW_LINE> <INDENT> changes = BaseAccount.on_save(changes, database) <NEW_LINE> changes = dhelpers.save_account(changes, OpenldapAccount, database) <NEW_LINE> changes = helpers.save_pwdpolicy(changes) <NEW_LINE> changes = helpers.set_object_class(changes, ['top', 'person', 'inetOrgPerson', 'organizationalPerson', 'shadowAccount', 'posixAccount', 'pwdPolicy']) <NEW_LINE> return changes | An OpenLDAP specific account with the pwdpolicy schema. | 62599096f9cc0f698b1c618a |
class DeploymentmanagerDeploymentsDeleteRequest(messages.Message): <NEW_LINE> <INDENT> deployment = messages.StringField(1, required=True) <NEW_LINE> project = messages.StringField(2, required=True) | A DeploymentmanagerDeploymentsDeleteRequest object.
Fields:
deployment: ! The name of the deployment for this request.
project: ! The project ID for this request. | 62599096d8ef3951e32c8d1b |
class OrderGoods(models.Model): <NEW_LINE> <INDENT> order = models.ForeignKey(OrderInfo, verbose_name='订单信息',on_delete=models.CASCADE) <NEW_LINE> goods = models.ForeignKey(Goods, verbose_name='商品',on_delete=models.CASCADE) <NEW_LINE> goods_num = models.IntegerField(default=0, verbose_name='商品数量') <NEW_LINE> add_time = models.DateTimeField(default=datetime.datetime.now(), verbose_name='添加时间') <NEW_LINE> class Meta: <NEW_LINE> <INDENT> verbose_name = u'订单商品详情' <NEW_LINE> verbose_name_plural = verbose_name <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return str(self.order.order_sn) | 订单商品详情 | 625990967cff6e4e811b77c0 |
class Action(object): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.rules = [] <NEW_LINE> self.headers = [] <NEW_LINE> self.response_code = None <NEW_LINE> self.response_body = "" <NEW_LINE> <DEDENT> def add_rule(self, rule): <NEW_LINE> <INDENT> self.rules.append(rule) <NEW_LINE> <DEDENT> def add_header(self, header): <NEW_LINE> <INDENT> self.headers.append(header) <NEW_LINE> <DEDENT> def __call__(self, req): <NEW_LINE> <INDENT> return all([r(req) for r in self.rules]) <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return "<Action response_code=%s, response_body='%s', " "rules=[%s], headers=[%s]" % (self.response_code, self.response_body, ",".join([str(r) for r in self.rules]), self.headers) | Represent a whole action block | 62599096f9cc0f698b1c618b |
class Rectangle: <NEW_LINE> <INDENT> number_of_instances = 0 <NEW_LINE> print_symbol = '#' <NEW_LINE> def __init__(self, width=0, height=0): <NEW_LINE> <INDENT> self.__check_width(width) <NEW_LINE> self.__check_height(height) <NEW_LINE> self.__width = width <NEW_LINE> self.__height = height <NEW_LINE> Rectangle.number_of_instances += 1 <NEW_LINE> <DEDENT> @property <NEW_LINE> def width(self): <NEW_LINE> <INDENT> return self.__width <NEW_LINE> <DEDENT> @width.setter <NEW_LINE> def width(self, value): <NEW_LINE> <INDENT> self.__check_width(value) <NEW_LINE> self.__width = value <NEW_LINE> <DEDENT> @property <NEW_LINE> def height(self): <NEW_LINE> <INDENT> return self.__height <NEW_LINE> <DEDENT> @height.setter <NEW_LINE> def height(self, value): <NEW_LINE> <INDENT> self.__check_height(value) <NEW_LINE> self.__height = value <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def __check_width(width): <NEW_LINE> <INDENT> if type(width) != int: <NEW_LINE> <INDENT> raise TypeError("width must be an integer") <NEW_LINE> <DEDENT> if width < 0: <NEW_LINE> <INDENT> raise ValueError("width must be >= 0") <NEW_LINE> <DEDENT> <DEDENT> @staticmethod <NEW_LINE> def __check_height(height): <NEW_LINE> <INDENT> if type(height) != int: <NEW_LINE> <INDENT> raise TypeError("height must be an integer") <NEW_LINE> <DEDENT> if height < 0: <NEW_LINE> <INDENT> raise ValueError("height must be >= 0") <NEW_LINE> <DEDENT> <DEDENT> def area(self): <NEW_LINE> <INDENT> return self.__width * self.__height <NEW_LINE> <DEDENT> def perimeter(self): <NEW_LINE> <INDENT> if self.__width == 0 or self.__height == 0: <NEW_LINE> <INDENT> return 0 <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return (self.__width * 2) + (self.__height * 2) <NEW_LINE> <DEDENT> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> if self.area() == 0: <NEW_LINE> <INDENT> return "" <NEW_LINE> <DEDENT> return "\n".join([str(self.print_symbol) * self.width] * self.height) <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return "Rectangle({:d}, {:d})".format(self.__width, self.__height) <NEW_LINE> <DEDENT> def __del__(self): <NEW_LINE> <INDENT> print("Bye rectangle...") <NEW_LINE> Rectangle.number_of_instances -= 1 | a `Rectangle` class | 62599096be7bc26dc9252d15 |
class ViewOne(ViewBase): <NEW_LINE> <INDENT> http_method_names = ["get", "put", "delete"] <NEW_LINE> def get(self, request, *args, **kwargs): <NEW_LINE> <INDENT> self.set_view_kwargs(**kwargs) <NEW_LINE> object = self.get_object(kwargs["pk"]) <NEW_LINE> response_data = self.serialized_data(object, self.get_template) <NEW_LINE> response = HttpResponse(response_data, status=200, content_type="application/json") <NEW_LINE> return response <NEW_LINE> <DEDENT> def put(self, request, *args, **kwargs): <NEW_LINE> <INDENT> self.set_view_kwargs(**kwargs) <NEW_LINE> object = self.get_object(kwargs["pk"]) <NEW_LINE> request_data = self.update_prep(request) <NEW_LINE> save_result = self.update_model(object, request_data) <NEW_LINE> response = self.update_response(save_result, 200, 400) <NEW_LINE> return response <NEW_LINE> <DEDENT> def delete(self, request, *args, **kwargs): <NEW_LINE> <INDENT> self.set_view_kwargs(**kwargs) <NEW_LINE> object = self.get_object(kwargs["pk"]) <NEW_LINE> object.delete() <NEW_LINE> response = HttpResponse(status=204) <NEW_LINE> return response | Base View for single object
| 62599096091ae356687069b2 |
class DataplaneLatency(base_tests.SimpleDataPlane): <NEW_LINE> <INDENT> def runTest(self): <NEW_LINE> <INDENT> in_port, out_port = openflow_ports(2) <NEW_LINE> delete_all_flows(self.controller) <NEW_LINE> pkt = str(simple_tcp_packet()) <NEW_LINE> request = ofp.message.flow_add( match=ofp.match(wildcards=ofp.OFPFW_ALL), buffer_id=0xffffffff, actions=[ofp.action.output(out_port)]) <NEW_LINE> self.controller.message_send(request) <NEW_LINE> do_barrier(self.controller) <NEW_LINE> latencies = [] <NEW_LINE> for i in xrange(0, 1000): <NEW_LINE> <INDENT> start_time = time.time() <NEW_LINE> self.dataplane.send(in_port, pkt) <NEW_LINE> verify_packet(self, pkt, out_port) <NEW_LINE> end_time = time.time() <NEW_LINE> latencies.append(end_time - start_time) <NEW_LINE> <DEDENT> latencies.sort() <NEW_LINE> latency_min = latencies[0] <NEW_LINE> latency_90 = latencies[int(len(latencies)*0.9)] <NEW_LINE> latency_max = latencies[-1] <NEW_LINE> logging.debug("Minimum latency: %f ms", latency_min * 1000.0) <NEW_LINE> logging.debug("90%% latency: %f ms", latency_90 * 1000.0) <NEW_LINE> logging.debug("Maximum latency: %f ms", latency_max * 1000.0) <NEW_LINE> self.assertGreater(config["default_timeout"], latency_max) <NEW_LINE> self.assertGreater(config["default_negative_timeout"], latency_90) | Measure and assert dataplane latency
All packets must arrive within the default timeout, and 90% must
arrive within the default negative timeout. | 6259909650812a4eaa621a87 |
class StringResponse(MockResponse): <NEW_LINE> <INDENT> def __init__(self, headers, content): <NEW_LINE> <INDENT> super(StringResponse, self).__init__(headers, unicode(content)) | A response with stringified content.
>>> from restorm.clients.mockclient import StringResponse
>>> response = StringResponse({'Status': 200}, '{}')
>>> response.content
'{}' | 62599096dc8b845886d5533a |
class CtrlSpace(Object3D): <NEW_LINE> <INDENT> def __init__(self, name, parent=None): <NEW_LINE> <INDENT> super(CtrlSpace, self).__init__(name, parent=parent) <NEW_LINE> self.setShapeVisibility(False) | CtrlSpace object. | 62599096dc8b845886d5533c |
class AddError(Exception): <NEW_LINE> <INDENT> pass | Add Error | 625990968a349b6b43687fe4 |
class CustomIndexDashboard(Dashboard): <NEW_LINE> <INDENT> def init_with_context(self, context): <NEW_LINE> <INDENT> site_name = get_admin_site_name(context) <NEW_LINE> self.children.append(modules.ModelList( _('Metadata Configuration & Registration'), column=1, collapsible=False, models=('geosk.mdtools.*','geosk.skregistration.*'), )) <NEW_LINE> self.children.append(modules.Group( _('Administration & Applications'), column=1, collapsible=True, children = [ modules.AppList( _('Administration'), column=1, collapsible=False, models=('django.contrib.*',), ), modules.AppList( _('Applications'), column=1, css_classes=('collapse closed',), exclude=('django.contrib.*',), ) ] )) <NEW_LINE> self.children.append(modules.AppList( _('AppList: Applications'), collapsible=True, column=1, css_classes=('collapse closed',), exclude=('django.contrib.*',), )) <NEW_LINE> self.children.append(modules.LinkList( _('SK Registration'), column=2, children=[ { 'title': _('Register or check registration'), 'url': reverse('skregistration_registration'), 'external': False, }, ] )) <NEW_LINE> self.children.append(modules.LinkList( _('Translations'), column=2, children=[ { 'title': _('Update translations'), 'url': reverse('rosetta-home'), 'external': False, 'description': _('Update the translations for your languages'), }, { 'title': _('Rosetta Documentation'), 'url': 'https://github.com/mbi/django-rosetta', 'external': True, }, ] )) <NEW_LINE> self.children.append(modules.RecentActions( _('Recent Actions'), limit=5, collapsible=False, column=2, )) <NEW_LINE> self.children.append(modules.LinkList( _('SK Front end'), column=3, children=[ { 'title': _('Home'), 'url': reverse('home'), 'external': False, }, { 'title': _('Layers'), 'url': reverse('layer_browse'), 'external': False, }, { 'title': _('Maps'), 'url': reverse('layer_browse'), 'external': False, }, { 'title': _('Documents'), 'url': reverse('maps_browse'), 'external': False, }, { 'title': _('People'), 'url': reverse('profile_browse'), 'external': False, }, { 'title': _('Search'), 'url': reverse('search'), 'external': False, }, { 'title': _('Services'), 'url': reverse('about_services'), 'external': False, }, { 'title': _('Sos'), 'url': reverse('osk_browse'), 'external': False, }, ] )) | Custom index dashboard for www. | 62599096adb09d7d5dc0c2de |
class Movie(): <NEW_LINE> <INDENT> VALID_RATINGS = ["G", "PG", "PG-13","R"] <NEW_LINE> def __init__(self, title, storyline, img, trailer): <NEW_LINE> <INDENT> self.title = title <NEW_LINE> self.storyline = storyline <NEW_LINE> self.poster_image_url = img <NEW_LINE> self.trailer_youtube_url = trailer <NEW_LINE> <DEDENT> def show_trailer(self): <NEW_LINE> <INDENT> print("The show_trailer method is called") <NEW_LINE> webbrowser.open(self.trailer_url) | This is the file media.py it's the Movie class | 62599096dc8b845886d5533e |
class WordText: <NEW_LINE> <INDENT> def __init__(self, font='', size=0, color=(0, 0, 0)): <NEW_LINE> <INDENT> self._font = font <NEW_LINE> self._size = size <NEW_LINE> self._color = color <NEW_LINE> self._setting = pygame.font.Font(self._font, self._size) <NEW_LINE> <DEDENT> def setWord(self, word=''): <NEW_LINE> <INDENT> self._word = word <NEW_LINE> self._render = self._setting.render(self._word, True, self._color) <NEW_LINE> self._rect = self._render.get_rect() <NEW_LINE> <DEDENT> def setLoaction(self, centery=0): <NEW_LINE> <INDENT> self._centery = centery <NEW_LINE> self._rect.midleft = (30, self._centery) <NEW_LINE> <DEDENT> def getLoaction(self): <NEW_LINE> <INDENT> if self._rect.right >= 380: <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> <DEDENT> def wordShow(self): <NEW_LINE> <INDENT> screen.blit(self._render, self._rect.midleft) <NEW_LINE> pygame.display.update() | 用于在Pygame中进行文字生成 | 625990965fdd1c0f98e5fcfb |
class FiveZlotyPriceHandler(PricingHandler): <NEW_LINE> <INDENT> def get_variant_price(self, *args, **kwargs): <NEW_LINE> <INDENT> return Price(net=5, gross=5, currency=u'PLN') <NEW_LINE> <DEDENT> def get_product_price_range(self, *args, **kwargs): <NEW_LINE> <INDENT> return PriceRange(min_price=Price(net=5, gross=5, currency=u'PLN'), max_price=Price(net=5, gross=5, currency=u'PLN')) | Dummy base price handler - everything has 5PLN price | 6259909650812a4eaa621a8a |
class BidsUserSetting(models.Model): <NEW_LINE> <INDENT> mid = models.ForeignKey(CustomerInformation,null=True, on_delete=models.CASCADE, verbose_name="用户") <NEW_LINE> areas_id = models.CharField(max_length=60, verbose_name="关注省范围") <NEW_LINE> keywords_array = models.CharField(max_length=60,null=True,blank=True, verbose_name="关注关键字") <NEW_LINE> remind_long_time = models.SmallIntegerField(default=7, verbose_name="推送时常") <NEW_LINE> is_remind = models.BooleanField(default=True, verbose_name="是否推送") <NEW_LINE> create_time = models.DateField(auto_now_add=True, verbose_name="创建时间") <NEW_LINE> update_time = models.DateTimeField(auto_now=True, verbose_name='更新时间') <NEW_LINE> class Meta: <NEW_LINE> <INDENT> db_table = "Subscribe_status" <NEW_LINE> verbose_name = "推送用户记录表" <NEW_LINE> verbose_name_plural = verbose_name | 用户订阅表 | 62599096091ae356687069ba |
class ParseError(Exception): <NEW_LINE> <INDENT> pass | Used to indicate a XML parsing error. | 62599096ad47b63b2c5a95a8 |
class Vehicle(object): <NEW_LINE> <INDENT> def __init__(self, ID=0, direct_flag = 1, lane_ID = 0, position = np.array([0.0,0.0]), speed = np.array([0.0,0.0]), acceleration = np.array([0.0,0.0])): <NEW_LINE> <INDENT> self.ID = ID <NEW_LINE> self.direct_flag = direct_flag <NEW_LINE> self.lane_ID = lane_ID <NEW_LINE> self.position = position <NEW_LINE> self.speed = speed <NEW_LINE> self.acceleration = acceleration <NEW_LINE> <DEDENT> def setup_communication_terminal(self, issource = False): <NEW_LINE> <INDENT> self.communication_terminal = Communication_ternimal(self.ID, issource) <NEW_LINE> <DEDENT> def update_acceleration(self, mobility, front_vehicle = None): <NEW_LINE> <INDENT> mobility.car_following_IDM(front_vehicle, self) <NEW_LINE> <DEDENT> def update_speed(self, dt): <NEW_LINE> <INDENT> self.speed = self.speed + dt*self.acceleration <NEW_LINE> <DEDENT> def update_position(self, dt): <NEW_LINE> <INDENT> self.position = self.position + self.speed*dt | Vehicle class:
the attributes consists of ID, direct_flag, lane_ID,
position array([x, y]), and some kinematics parameters
including speed array([vx, vy]) and acceleration array([ax, ay]). | 6259909660cbc95b06365c2c |
class UpdateData(QThread): <NEW_LINE> <INDENT> update_date = pyqtSignal(str) <NEW_LINE> def run(self): <NEW_LINE> <INDENT> cnt = 0 <NEW_LINE> while True: <NEW_LINE> <INDENT> cnt += 1 <NEW_LINE> self.update_date.emit(str(cnt)) <NEW_LINE> time.sleep(1) | 更新数据类 | 625990965fdd1c0f98e5fcff |
class StrictQueryFilter(DjangoFilterBackend): <NEW_LINE> <INDENT> def get_filter_class(self, view, queryset=None): <NEW_LINE> <INDENT> klass = (super(StrictQueryFilter, self) .get_filter_class(view, queryset=queryset)) <NEW_LINE> try: <NEW_LINE> <INDENT> klass._meta.order_by = klass.Meta.model.Meta.ordering <NEW_LINE> <DEDENT> except AttributeError: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> return klass <NEW_LINE> <DEDENT> def filter_queryset(self, request, queryset, view): <NEW_LINE> <INDENT> requested = set(request.QUERY_PARAMS.keys()) <NEW_LINE> allowed = set(getattr(view, 'filter_fields', [])) <NEW_LINE> difference = requested.difference(allowed) <NEW_LINE> if difference: <NEW_LINE> <INDENT> raise InvalidQueryParams( detail='Incorrect query parameters: ' + ','.join(difference)) <NEW_LINE> <DEDENT> return (super(StrictQueryFilter, self) .filter_queryset(request, queryset, view)) | Don't allow people to typo request params and return all the objects.
Instead limit it down to the parameters allowed in filter_fields. | 62599096091ae356687069be |
class TelldusLiveClient(object): <NEW_LINE> <INDENT> def __init__(self, hass, config): <NEW_LINE> <INDENT> from tellduslive import Client <NEW_LINE> public_key = config[DOMAIN].get(CONF_PUBLIC_KEY) <NEW_LINE> private_key = config[DOMAIN].get(CONF_PRIVATE_KEY) <NEW_LINE> token = config[DOMAIN].get(CONF_TOKEN) <NEW_LINE> token_secret = config[DOMAIN].get(CONF_TOKEN_SECRET) <NEW_LINE> self.entities = [] <NEW_LINE> self._hass = hass <NEW_LINE> self._config = config <NEW_LINE> self._interval = config[DOMAIN].get(CONF_UPDATE_INTERVAL) <NEW_LINE> _LOGGER.debug('Update interval %s', self._interval) <NEW_LINE> self._client = Client(public_key, private_key, token, token_secret) <NEW_LINE> <DEDENT> def validate_session(self): <NEW_LINE> <INDENT> response = self._client.request_user() <NEW_LINE> return response and 'email' in response <NEW_LINE> <DEDENT> def update(self, now): <NEW_LINE> <INDENT> _LOGGER.debug('Updating') <NEW_LINE> try: <NEW_LINE> <INDENT> self._sync() <NEW_LINE> <DEDENT> finally: <NEW_LINE> <INDENT> track_point_in_utc_time(self._hass, self.update, now + self._interval) <NEW_LINE> <DEDENT> <DEDENT> def _sync(self): <NEW_LINE> <INDENT> self._client.update() <NEW_LINE> def identify_device(device): <NEW_LINE> <INDENT> from tellduslive import (DIM, UP, TURNON) <NEW_LINE> if device.methods & DIM: <NEW_LINE> <INDENT> return 'light' <NEW_LINE> <DEDENT> elif device.methods & UP: <NEW_LINE> <INDENT> return 'cover' <NEW_LINE> <DEDENT> elif device.methods & TURNON: <NEW_LINE> <INDENT> return 'switch' <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> _LOGGER.warning('Unidentified device type (methods: %d)', device.methods) <NEW_LINE> return 'switch' <NEW_LINE> <DEDENT> <DEDENT> def discover(device_id, component): <NEW_LINE> <INDENT> discovery.load_platform(self._hass, component, DOMAIN, [device_id], self._config) <NEW_LINE> <DEDENT> known_ids = set([entity.device_id for entity in self.entities]) <NEW_LINE> for device in self._client.devices: <NEW_LINE> <INDENT> if device.device_id in known_ids: <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> if device.is_sensor: <NEW_LINE> <INDENT> for item_id in device.items: <NEW_LINE> <INDENT> discover((device.device_id,) + item_id, 'sensor') <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> discover(device.device_id, identify_device(device)) <NEW_LINE> <DEDENT> <DEDENT> for entity in self.entities: <NEW_LINE> <INDENT> entity.changed() <NEW_LINE> <DEDENT> <DEDENT> def device(self, device_id): <NEW_LINE> <INDENT> import tellduslive <NEW_LINE> return tellduslive.Device(self._client, device_id) <NEW_LINE> <DEDENT> def is_available(self, device_id): <NEW_LINE> <INDENT> return device_id in self._client.device_ids | Get the latest data and update the states. | 6259909650812a4eaa621a8d |
class JdbcSchema(BaseSchema): <NEW_LINE> <INDENT> def __init__(self, jdbc_resource, json_object=None, url=None): <NEW_LINE> <INDENT> super().__init__(jdbc_resource, json_object, url) <NEW_LINE> self.jdbc_resource = jdbc_resource <NEW_LINE> <DEDENT> def resource(self): <NEW_LINE> <INDENT> return self.jdbc_resource <NEW_LINE> <DEDENT> def catalog_name(self): <NEW_LINE> <INDENT> if (self.json_object!=None): <NEW_LINE> <INDENT> return self.json_object.get("fullname","") <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> <DEDENT> def select_tables(self): <NEW_LINE> <INDENT> table_list = [] <NEW_LINE> json_list = self.get_json(self.json_object.get("tables","")) <NEW_LINE> for column in json_list: <NEW_LINE> <INDENT> table_list.append(jdbc.JdbcTable(json_object=column, jdbc_schema=self)) <NEW_LINE> <DEDENT> return table_list <NEW_LINE> <DEDENT> def select_table_by_ident(self, ident): <NEW_LINE> <INDENT> return jdbc.JdbcTable(jdbc_schema=self, url=ident) <NEW_LINE> <DEDENT> def select_table_by_name(self, table_name): <NEW_LINE> <INDENT> response_json = {} <NEW_LINE> try : <NEW_LINE> <INDENT> response_json = self.get_json(self.url + "/tables/select", { "jdbc.table.name": table_name }) <NEW_LINE> <DEDENT> except Exception as e: <NEW_LINE> <INDENT> logging.exception(e) <NEW_LINE> <DEDENT> return jdbc.JdbcTable(json_object = response_json, jdbc_schema=self) <NEW_LINE> <DEDENT> def create_table(self, table_name): <NEW_LINE> <INDENT> return | classdocs | 62599096656771135c48aef7 |
class Calculator(commands.Cog): <NEW_LINE> <INDENT> def __init__(self, bot): <NEW_LINE> <INDENT> self.bot = bot <NEW_LINE> self.transformations = standard_transformations + (implicit_multiplication, implicit_application, function_exponentiation, convert_xor) <NEW_LINE> <DEDENT> @commands.command() <NEW_LINE> @checks.has_permissions(PermissionLevel.OWNER) <NEW_LINE> async def calc(self, ctx, *, exp): <NEW_LINE> <INDENT> exp = cleanup_code(exp).splitlines() <NEW_LINE> variables = {} <NEW_LINE> output = '' <NEW_LINE> for line in exp: <NEW_LINE> <INDENT> line = line.strip() <NEW_LINE> var = re.match(r'^let ([a-zA-Z]+)\s*=\s*(.+)$', line) <NEW_LINE> if var is not None: <NEW_LINE> <INDENT> v, e = var.groups() <NEW_LINE> variables[v] = parse_expr(e, transformations=self.transformations).subs(variables).evalf().doit() <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> output += str(parse_expr(line, transformations=self.transformations).subs(variables).evalf().doit()) + '\n' <NEW_LINE> <DEDENT> <DEDENT> await ctx.send(f'```\n{output}\n```') | It's not working btw!! | 625990963617ad0b5ee07edf |
class LogLikelihood(ModelQuantity): <NEW_LINE> <INDENT> def __init__(self, identifier: sp.Symbol, name: str, value: sp.Expr): <NEW_LINE> <INDENT> super(LogLikelihood, self).__init__(identifier, name, value) | A LogLikelihood defines the distance between measurements and
experiments for a particular observable. The final LogLikelihood value
in the simulation will be the sum of all specified LogLikelihood
instances evaluated at all timepoints, abbreviated by ``Jy``. | 625990967cff6e4e811b77d1 |
class NestedFormat(VisFormat): <NEW_LINE> <INDENT> def __init__(self, imap): <NEW_LINE> <INDENT> self._imap = imap <NEW_LINE> <DEDENT> def interval_blocks(self): <NEW_LINE> <INDENT> return [ IntervalBlock( video_id=video_key, interval_sets=[ NamedIntervalSet(name='default', interval_set=interval.payload) ]) for video_key in self._imap for interval in self._imap[video_key].get_intervals() ] | Format where each interval block contains the interval set in the payload of
each top-level interval. | 625990965fdd1c0f98e5fd03 |
class CircRestriThreeBodyProb(body_prob_dyn.RestriThreeBodyProb): <NEW_LINE> <INDENT> def __init__(self, mu, period, sma, Li): <NEW_LINE> <INDENT> body_prob_dyn.RestriThreeBodyProb.__init__(self, mu, 0., period, sma, Li) <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def Earth_Moon(cls, Li): <NEW_LINE> <INDENT> sma = conf.const_dist["dist_Earth_Moon"] <NEW_LINE> return cls(conf.const_mass["mu_EM"], orbital_mechanics.sma_to_period(sma, conf.const_grav["EM_constant"]), sma, Li) <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def Sun_Earth(cls, Li): <NEW_LINE> <INDENT> period = 3600.0 * 24.0 * 365.25 <NEW_LINE> return cls(conf.const_mass["mu_SE"], period, orbital_mechanics.period_to_sma(period, conf.const_grav["Sun_constant"]), Li) | Class implementing the restricted three body problem with a circular reference orbit.
| 62599096dc8b845886d55348 |
class StatusConversationProvider(object): <NEW_LINE> <INDENT> implements(IStatusConversationProvider) <NEW_LINE> adapts(IStatusUpdate, IPlonesocialActivitystreamLayer, Interface) <NEW_LINE> index = ViewPageTemplateFile("templates/statusconversation_provider.pt") <NEW_LINE> def __init__(self, context, request, view): <NEW_LINE> <INDENT> self.context = context <NEW_LINE> self.request = request <NEW_LINE> self.view = self.__parent__ = view <NEW_LINE> self.thread_id = context.thread_id or context.id <NEW_LINE> <DEDENT> def update(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def render(self): <NEW_LINE> <INDENT> return self.index() <NEW_LINE> <DEDENT> __call__ = render <NEW_LINE> def activities(self): <NEW_LINE> <INDENT> container = PLONESOCIAL.microblog <NEW_LINE> if not container: <NEW_LINE> <INDENT> return [] <NEW_LINE> <DEDENT> return [IStatusActivity(item) for item in container.thread_values(self.thread_id)] <NEW_LINE> <DEDENT> def activity_providers(self): <NEW_LINE> <INDENT> for activity in self.activities(): <NEW_LINE> <INDENT> yield getMultiAdapter( (activity, self.request, self.view), IActivityProvider) <NEW_LINE> <DEDENT> <DEDENT> def can_view(self, activity): <NEW_LINE> <INDENT> sm = getSecurityManager() <NEW_LINE> permission = "Plone Social: View Microblog Status Update" <NEW_LINE> return sm.checkPermission(permission, self.context) <NEW_LINE> <DEDENT> def is_anonymous(self): <NEW_LINE> <INDENT> portal_membership = getToolByName(getSite(), 'portal_membership', None) <NEW_LINE> return portal_membership.isAnonymousUser() | Render a thread of IStatusUpdates
| 6259909650812a4eaa621a8f |
class Prior(Link): <NEW_LINE> <INDENT> inputs = ('parameters',) <NEW_LINE> outputs = ('logprior',) <NEW_LINE> def calculate(self, parameters): <NEW_LINE> <INDENT> for p,v in parameters.items(): <NEW_LINE> <INDENT> if np.isnan(v): <NEW_LINE> <INDENT> return INVALID <NEW_LINE> <DEDENT> <DEDENT> try: <NEW_LINE> <INDENT> o = parameters['model.abundances.o'] <NEW_LINE> <DEDENT> except KeyError: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> if o <= 0.: <NEW_LINE> <INDENT> return INVALID <NEW_LINE> <DEDENT> <DEDENT> try: <NEW_LINE> <INDENT> s = parameters['model.abundances.s'] <NEW_LINE> si = parameters['model.abundances.si'] <NEW_LINE> <DEDENT> except KeyError: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> if s > si: <NEW_LINE> <INDENT> return INVALID <NEW_LINE> <DEDENT> <DEDENT> return DEFAULT | A very basic prior with the ability to break execution of a subchain. | 62599096d8ef3951e32c8d25 |
class Button(WidgetFactory): <NEW_LINE> <INDENT> def __init__(self, text): <NEW_LINE> <INDENT> super().__init__(ttk.Button) <NEW_LINE> self.kwargs['text'] = text | Wrapper for the tkinter.ttk.Button class. | 62599096be7bc26dc9252d1e |
class LogListHandler(logging.Handler): <NEW_LINE> <INDENT> def emit(self, record): <NEW_LINE> <INDENT> message = self.format(record) <NEW_LINE> message = message.replace("\n", "<br />") <NEW_LINE> mylar.LOG_LIST.insert(0, (helpers.now(), message, record.levelname, record.threadName)) | Log handler for Web UI. | 62599096283ffb24f3cf562c |
class BuyableItemBase(BaseModel): <NEW_LINE> <INDENT> price_max: Optional[float] <NEW_LINE> price_min: Optional[float] <NEW_LINE> reviewable: Optional[bool] <NEW_LINE> reviews_count: Optional[int] <NEW_LINE> reviewscore: Optional[float] <NEW_LINE> shop_count: Optional[int] | Item Buy base model.
Attributes:
price_min:
price_max:
shop_count:
reviewscore:
reviews_count:
reviewable: | 62599096ad47b63b2c5a95ad |
class OktaSignOnPolicyConditions( PolicyRuleConditions ): <NEW_LINE> <INDENT> def __init__(self, config=None): <NEW_LINE> <INDENT> super().__init__(config) <NEW_LINE> if config: <NEW_LINE> <INDENT> if "people" in config: <NEW_LINE> <INDENT> if isinstance(config["people"], policy_people_condition.PolicyPeopleCondition): <NEW_LINE> <INDENT> self.people = config["people"] <NEW_LINE> <DEDENT> elif config["people"] is not None: <NEW_LINE> <INDENT> self.people = policy_people_condition.PolicyPeopleCondition( config["people"] ) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.people = None <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> self.people = None <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> self.people = None <NEW_LINE> <DEDENT> <DEDENT> def request_format(self): <NEW_LINE> <INDENT> parent_req_format = super().request_format() <NEW_LINE> current_obj_format = { "people": self.people } <NEW_LINE> parent_req_format.update(current_obj_format) <NEW_LINE> return parent_req_format | A class for OktaSignOnPolicyConditions objects. | 62599096d8ef3951e32c8d26 |
@jitclass([]) <NEW_LINE> class NumbaHeatIndexCalculator(object): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def calculate_heat_index(self, temp: np.ndarray, rh: np.ndarray) -> np.ndarray: <NEW_LINE> <INDENT> hi = np.zeros_like(temp) <NEW_LINE> for i in range(temp.shape[0]): <NEW_LINE> <INDENT> for j in range(temp.shape[1]): <NEW_LINE> <INDENT> for k in range(temp.shape[2]): <NEW_LINE> <INDENT> hi[i, j, k] = self._calculate_heat_index(temp[i, j, k], rh[i, j, k]) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> return hi <NEW_LINE> <DEDENT> def _calculate_heat_index(self, temp: float, rh: float) -> float: <NEW_LINE> <INDENT> heat_index = self._calculate_simple_heat_index(temp, rh) <NEW_LINE> if heat_index > 80.0: <NEW_LINE> <INDENT> heat_index = self._calculate_full_regression(temp, rh) <NEW_LINE> if rh < 0.13 and (80.0 < temp < 112.0): <NEW_LINE> <INDENT> heat_index = heat_index - self._calculate_dry_adjustment(temp, rh) <NEW_LINE> <DEDENT> if rh > 0.85 and (80.0 < temp < 87.0): <NEW_LINE> <INDENT> heat_index = heat_index + self._calculate_humid_adjustment(temp, rh) <NEW_LINE> <DEDENT> <DEDENT> return heat_index <NEW_LINE> <DEDENT> def _calculate_simple_heat_index(self, temp: float, rh: float) -> float: <NEW_LINE> <INDENT> return 0.5 * (temp + 61.0 + ((temp - 68.0) * 1.2) + (rh * 0.094)) <NEW_LINE> <DEDENT> def _calculate_full_regression(self, temp: float, rh: float) -> float: <NEW_LINE> <INDENT> return -42.379 + (2.04901523 * temp) + (10.14333127 * rh) - (.22475541 * temp * rh) - (.00683783 * temp * temp) - (.05481717 * rh * rh) + (.00122874 * temp * temp * rh) + (.00085282 * temp * rh * rh) - (.00000199 * temp * temp * rh * rh) <NEW_LINE> <DEDENT> def _calculate_dry_adjustment(self, temp: float, rh: float) -> float: <NEW_LINE> <INDENT> return ((13 - rh) / 4.0) * math.sqrt((17 - math.fabs(temp - 95.0)) / 17) <NEW_LINE> <DEDENT> def _calculate_humid_adjustment(self, temp: float, rh: float) -> float: <NEW_LINE> <INDENT> return ((rh - 85) / 10.0) * ((87 - temp) / 5.0) | This class uses the jitclass operator to automatically jit all of the functions inside. Otherwise it's identical
to the base implementation | 62599096be7bc26dc9252d1f |
class MQTTRPCResponseManager(object): <NEW_LINE> <INDENT> @classmethod <NEW_LINE> def handle(cls, request_str, service_id, method_id, dispatcher): <NEW_LINE> <INDENT> if isinstance(request_str, bytes): <NEW_LINE> <INDENT> request_str = request_str.decode("utf-8") <NEW_LINE> <DEDENT> try: <NEW_LINE> <INDENT> json.loads(request_str) <NEW_LINE> <DEDENT> except (TypeError, ValueError): <NEW_LINE> <INDENT> return MQTTRPC10Response(error=JSONRPCParseError()._data) <NEW_LINE> <DEDENT> try: <NEW_LINE> <INDENT> request = MQTTRPC10Request.from_json(request_str) <NEW_LINE> <DEDENT> except JSONRPCInvalidRequestException: <NEW_LINE> <INDENT> return MQTTRPC10Response(error=JSONRPCInvalidRequest()._data) <NEW_LINE> <DEDENT> return cls.handle_request(request, service_id, method_id, dispatcher) <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def handle_request(cls, request, service_id, method_id, dispatcher): <NEW_LINE> <INDENT> def response(**kwargs): <NEW_LINE> <INDENT> return MQTTRPC10Response( _id=request._id, **kwargs) <NEW_LINE> <DEDENT> try: <NEW_LINE> <INDENT> method = dispatcher[(service_id, method_id)] <NEW_LINE> <DEDENT> except KeyError: <NEW_LINE> <INDENT> output = response(error=JSONRPCMethodNotFound()._data) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> result = method(*request.args, **request.kwargs) <NEW_LINE> <DEDENT> except JSONRPCDispatchException as e: <NEW_LINE> <INDENT> output = response(error=e.error._data) <NEW_LINE> <DEDENT> except Exception as e: <NEW_LINE> <INDENT> data = { "type": e.__class__.__name__, "args": e.args, "message": str(e), } <NEW_LINE> if isinstance(e, TypeError) and is_invalid_params( method, *request.args, **request.kwargs): <NEW_LINE> <INDENT> output = response( error=JSONRPCInvalidParams(data=data)._data) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> logger.exception("API Exception: {0}".format(data)) <NEW_LINE> output = response( error=JSONRPCServerError(data=data)._data) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> output = response(result=result) <NEW_LINE> <DEDENT> <DEDENT> finally: <NEW_LINE> <INDENT> if not request.is_notification: <NEW_LINE> <INDENT> return output <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return [] | MQTT-RPC response manager.
Method brings syntactic sugar into library. Given dispatcher it handles
request (both single and batch) and handles errors.
Request could be handled in parallel, it is server responsibility.
:param str request_str: json string. Will be converted into
MQTTRPC10Request
:param dict dispather: dict<function_name:function>. | 62599096ad47b63b2c5a95ae |
class Card(metaclass=ObjectSameForGivenParameters): <NEW_LINE> <INDENT> def __init__(self, r, s): <NEW_LINE> <INDENT> if r in ranks and s in suits: <NEW_LINE> <INDENT> self.__rank = r <NEW_LINE> self.__suit = s <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise LookupError('Rank {} or suit {} does not exist.'.format(r, s)) <NEW_LINE> <DEDENT> <DEDENT> @property <NEW_LINE> def rank(self): <NEW_LINE> <INDENT> return self.__rank <NEW_LINE> <DEDENT> @property <NEW_LINE> def suit(self): <NEW_LINE> <INDENT> return self.__suit <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return "Card({}, {})".format(self.rank, self.suit) <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return self.rank + suitSyms[self.suit] | Card(rank, suite) is a single card | 625990968a349b6b43687ff6 |
class PublicTagsApiTests(TestCase): <NEW_LINE> <INDENT> def setUp(self): <NEW_LINE> <INDENT> self.client = APIClient() <NEW_LINE> <DEDENT> def test_login_required(self): <NEW_LINE> <INDENT> res = self.client.get(TAGS_URL) <NEW_LINE> self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED) | Test the publicly available tags api | 625990967cff6e4e811b77d9 |
class DistributionMirrorBreadcrumb(TitleBreadcrumb): <NEW_LINE> <INDENT> pass | Breadcrumb for distribution mirrors. | 62599096adb09d7d5dc0c2f0 |
class VIEW3D_PT_catt_export(View3DCattPanel, Panel): <NEW_LINE> <INDENT> bl_label = "Export" <NEW_LINE> def draw(self, context): <NEW_LINE> <INDENT> layout = self.layout <NEW_LINE> catt_export = context.scene.catt_export <NEW_LINE> col = layout.column(align=True) <NEW_LINE> rowsub = col.row(align=True) <NEW_LINE> rowsub.label(text="Export Path") <NEW_LINE> rowsub = col.row() <NEW_LINE> rowsub.prop(catt_export, "export_path", text="") <NEW_LINE> rowsub = col.row() <NEW_LINE> rowsub.prop(catt_export, "master_file_name", text="") <NEW_LINE> rowsub = col.row() <NEW_LINE> rowsub.label(text="") <NEW_LINE> rowsub = col.row(align=True) <NEW_LINE> rowsub.label(text="Import Comments From Text") <NEW_LINE> rowsub = col.row() <NEW_LINE> rowsub.prop(catt_export, "editor_scripts", text="") <NEW_LINE> rowsub = col.row() <NEW_LINE> rowsub.label(text="") <NEW_LINE> rowsub = col.row(align=True) <NEW_LINE> rowsub.prop(catt_export, "triangulate_faces") <NEW_LINE> rowsub = col.row(align=True) <NEW_LINE> rowsub.prop(catt_export, "apply_modifiers") <NEW_LINE> rowsub = col.row() <NEW_LINE> rowsub.label(text="") <NEW_LINE> rowsub = col.row(align=True) <NEW_LINE> rowsub.prop(catt_export, "merge_objects") <NEW_LINE> rowsub = col.row(align=True) <NEW_LINE> rowsub.enabled = catt_export.merge_objects <NEW_LINE> rowsub.prop(catt_export, "rm_duplicates_dist") <NEW_LINE> rowsub = col.row() <NEW_LINE> rowsub.label(text="") <NEW_LINE> rowsub = col.row(align=True) <NEW_LINE> rowsub.operator("catt.export", text="Export", icon='EXPORT') <NEW_LINE> rowsub = col.row(align=True) <NEW_LINE> rowsub.prop(catt_export, "debug") | panel export | 625990963617ad0b5ee07eea |
class Laser: <NEW_LINE> <INDENT> def __init__(self, x, y, img): <NEW_LINE> <INDENT> self.x = x <NEW_LINE> self.y = y <NEW_LINE> self.img = img <NEW_LINE> self.mask = pygame.mask.from_surface(self.img) <NEW_LINE> <DEDENT> def draw(self, window): <NEW_LINE> <INDENT> window.blit(self.img, (self.x, self.y)) <NEW_LINE> <DEDENT> def move(self, vel): <NEW_LINE> <INDENT> self.y += vel <NEW_LINE> <DEDENT> def off_screen(self, height): <NEW_LINE> <INDENT> return not(self.y <= height and self.y >= 0) <NEW_LINE> <DEDENT> def collision(self, obj): <NEW_LINE> <INDENT> return collide(self, obj) | A class for laser | 62599096283ffb24f3cf5632 |
class MsgObsDepC(SBP): <NEW_LINE> <INDENT> _parser = construct.Struct( 'header' / ObservationHeaderDep._parser, 'obs' / construct.GreedyRange(PackedObsContentDepC._parser),) <NEW_LINE> __slots__ = [ 'header', 'obs', ] <NEW_LINE> def __init__(self, sbp=None, **kwargs): <NEW_LINE> <INDENT> if sbp: <NEW_LINE> <INDENT> super( MsgObsDepC, self).__init__(sbp.msg_type, sbp.sender, sbp.length, sbp.payload, sbp.crc) <NEW_LINE> self.from_binary(sbp.payload) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> super( MsgObsDepC, self).__init__() <NEW_LINE> self.msg_type = SBP_MSG_OBS_DEP_C <NEW_LINE> self.sender = kwargs.pop('sender', SENDER_ID) <NEW_LINE> self.header = kwargs.pop('header') <NEW_LINE> self.obs = kwargs.pop('obs') <NEW_LINE> <DEDENT> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return fmt_repr(self) <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def from_json(s): <NEW_LINE> <INDENT> d = json.loads(s) <NEW_LINE> return MsgObsDepC.from_json_dict(d) <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def from_json_dict(d): <NEW_LINE> <INDENT> sbp = SBP.from_json_dict(d) <NEW_LINE> return MsgObsDepC(sbp, **d) <NEW_LINE> <DEDENT> def from_binary(self, d): <NEW_LINE> <INDENT> p = MsgObsDepC._parser.parse(d) <NEW_LINE> for n in self.__class__.__slots__: <NEW_LINE> <INDENT> setattr(self, n, getattr(p, n)) <NEW_LINE> <DEDENT> <DEDENT> def to_binary(self): <NEW_LINE> <INDENT> c = containerize(exclude_fields(self)) <NEW_LINE> self.payload = MsgObsDepC._parser.build(c) <NEW_LINE> return self.pack() <NEW_LINE> <DEDENT> def into_buffer(self, buf, offset): <NEW_LINE> <INDENT> self.payload = containerize(exclude_fields(self)) <NEW_LINE> self.parser = MsgObsDepC._parser <NEW_LINE> self.stream_payload.reset(buf, offset) <NEW_LINE> return self.pack_into(buf, offset, self._build_payload) <NEW_LINE> <DEDENT> def to_json_dict(self): <NEW_LINE> <INDENT> self.to_binary() <NEW_LINE> d = super( MsgObsDepC, self).to_json_dict() <NEW_LINE> j = walk_json_dict(exclude_fields(self)) <NEW_LINE> d.update(j) <NEW_LINE> return d | SBP class for message MSG_OBS_DEP_C (0x0049).
You can have MSG_OBS_DEP_C inherit its fields directly
from an inherited SBP object, or construct it inline using a dict
of its fields.
The GPS observations message reports all the raw pseudorange and carrier
phase observations for the satellites being tracked by the device. Carrier
phase observation here is represented as a 40-bit fixed point number with
Q32.8 layout (i.e. 32-bits of whole cycles and 8-bits of fractional cycles).
The observations are interoperable with 3rd party receivers and conform with
typical RTCMv3 GNSS observations.
Parameters
----------
sbp : SBP
SBP parent object to inherit from.
header : ObservationHeaderDep
Header of a GPS observation message
obs : array
Pseudorange and carrier phase observation for a satellite being tracked.
sender : int
Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). | 62599096adb09d7d5dc0c2f4 |
class Square(Rectangle): <NEW_LINE> <INDENT> def __init__(self, size=None, x=0, y=0, id=None): <NEW_LINE> <INDENT> super().__init__(size, size, x, y, id) <NEW_LINE> <DEDENT> @property <NEW_LINE> def size(self): <NEW_LINE> <INDENT> return self.width <NEW_LINE> <DEDENT> @size.setter <NEW_LINE> def size(self, size): <NEW_LINE> <INDENT> self.width = size <NEW_LINE> self.height = size <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> string = "[Square] ({}) {}/{} - {}" <NEW_LINE> return string.format(self.id, self.x, self.y, self.width) <NEW_LINE> <DEDENT> def update(self, *args, **kwargs): <NEW_LINE> <INDENT> attributes = ["id", "size", "x", "y"] <NEW_LINE> if len(args) == 0: <NEW_LINE> <INDENT> for key, value in kwargs.items(): <NEW_LINE> <INDENT> setattr(self, key, value) <NEW_LINE> <DEDENT> return <NEW_LINE> <DEDENT> for index in range(len(args)): <NEW_LINE> <INDENT> setattr(self, attributes[index], args[index]) <NEW_LINE> <DEDENT> <DEDENT> def to_dictionary(self): <NEW_LINE> <INDENT> return {'x': self.x, 'y': self.y, 'id': self.id, 'size': self.size} | square class that inherits from rectangle | 62599096091ae356687069cc |
class SimpleTictactoe(QDialog): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> super().__init__() <NEW_LINE> self.title = "Simple Tictactoe" <NEW_LINE> self.left , self.top , self.width , self.height = 10, 10, -1, -1 <NEW_LINE> self.initGUI() <NEW_LINE> <DEDENT> def initGUI(self): <NEW_LINE> <INDENT> self.setWindowTitle(self.title) <NEW_LINE> self.setGeometry(self.left, self.top, self.width, self.height) <NEW_LINE> self.setWindowModality(Qt.ApplicationModal) <NEW_LINE> self.addComponents() <NEW_LINE> self.registerEvents() <NEW_LINE> <DEDENT> def addComponents(self): <NEW_LINE> <INDENT> self.mainLayout = QVBoxLayout() <NEW_LINE> self.widgetChooser = QWidget() <NEW_LINE> self.layoutChooser = QHBoxLayout() <NEW_LINE> self.widgetChooser.setLayout(self.layoutChooser) <NEW_LINE> self.mainLayout.addWidget(self.widgetChooser) <NEW_LINE> self.lblChooser = QLabel("Choose the tictactoe row x column: ") <NEW_LINE> self.comboChooser = QComboBox() <NEW_LINE> self.comboChooser.addItems([ "Tictactoe 3x3", "Tictactoe 5x5", "Tictactoe 7x7" ]) <NEW_LINE> self.layoutChooser.addWidget(self.lblChooser) <NEW_LINE> self.layoutChooser.addWidget(self.comboChooser) <NEW_LINE> self.setLayout(self.mainLayout) <NEW_LINE> self.tictactoe3 = TictactoeWidget() <NEW_LINE> self.tictactoe5 = TictactoeWidget( 5, 5) <NEW_LINE> self.tictactoe7 = TictactoeWidget(7,7) <NEW_LINE> self.stackedWidget = QStackedWidget() <NEW_LINE> self.mainLayout.addWidget(self.stackedWidget) <NEW_LINE> self.stackedWidget.addWidget(self.tictactoe3) <NEW_LINE> self.stackedWidget.addWidget(self.tictactoe5) <NEW_LINE> self.stackedWidget.addWidget(self.tictactoe7) <NEW_LINE> <DEDENT> def registerEvents(self): <NEW_LINE> <INDENT> self.comboChooser.currentIndexChanged.connect(self.onCurrentIndexChanged) <NEW_LINE> <DEDENT> @pyqtSlot() <NEW_LINE> def onCurrentIndexChanged(self): <NEW_LINE> <INDENT> currentIndex = self.sender().currentIndex() <NEW_LINE> self.stackedWidget.setCurrentIndex(currentIndex) | With this class simple tictactoe game-app is created. | 62599096283ffb24f3cf5634 |
class tomcat(sos.plugintools.PluginBase): <NEW_LINE> <INDENT> def checkenabled(self): <NEW_LINE> <INDENT> return self.isInstalled("tomcat5") <NEW_LINE> <DEDENT> def setup(self): <NEW_LINE> <INDENT> self.addCopySpecs(["/etc/tomcat5", "/var/log/tomcat5"]) | Tomcat related information
| 62599097656771135c48aefe |
class TopicAndPartition(object): <NEW_LINE> <INDENT> def __init__(self, topic, partition): <NEW_LINE> <INDENT> self._topic = topic <NEW_LINE> self._partition = partition <NEW_LINE> <DEDENT> def _jTopicAndPartition(self, helper): <NEW_LINE> <INDENT> return helper.createTopicAndPartition(self._topic, self._partition) <NEW_LINE> <DEDENT> def __eq__(self, other): <NEW_LINE> <INDENT> if isinstance(other, self.__class__): <NEW_LINE> <INDENT> return (self._topic == other._topic and self._partition == other._partition) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> <DEDENT> def __ne__(self, other): <NEW_LINE> <INDENT> return not self.__eq__(other) | Represents a specific top and partition for Kafka. | 62599097dc8b845886d55354 |
class Fam(FileMonitor): <NEW_LINE> <INDENT> __priority__ = 10 <NEW_LINE> def __init__(self, ignore=None, debug=False): <NEW_LINE> <INDENT> FileMonitor.__init__(self, ignore=ignore, debug=debug) <NEW_LINE> self.filemonitor = _fam.open() <NEW_LINE> self.users = {} <NEW_LINE> LOGGER.warning("The Fam file monitor backend is deprecated. Please " "switch to a supported file monitor.") <NEW_LINE> <DEDENT> __init__.__doc__ = FileMonitor.__init__.__doc__ <NEW_LINE> def fileno(self): <NEW_LINE> <INDENT> return self.filemonitor.fileno() <NEW_LINE> <DEDENT> fileno.__doc__ = FileMonitor.fileno.__doc__ <NEW_LINE> def handle_event_set(self, _=None): <NEW_LINE> <INDENT> self.Service() <NEW_LINE> <DEDENT> handle_event_set.__doc__ = FileMonitor.handle_event_set.__doc__ <NEW_LINE> def handle_events_in_interval(self, interval): <NEW_LINE> <INDENT> now = time() <NEW_LINE> while (time() - now) < interval: <NEW_LINE> <INDENT> if self.Service(): <NEW_LINE> <INDENT> now = time() <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> handle_events_in_interval.__doc__ = FileMonitor.handle_events_in_interval.__doc__ <NEW_LINE> def AddMonitor(self, path, obj, _=None): <NEW_LINE> <INDENT> mode = os.stat(path)[stat.ST_MODE] <NEW_LINE> if stat.S_ISDIR(mode): <NEW_LINE> <INDENT> handle = self.filemonitor.monitorDirectory(path, None) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> handle = self.filemonitor.monitorFile(path, None) <NEW_LINE> <DEDENT> self.handles[handle.requestID()] = handle <NEW_LINE> if obj is not None: <NEW_LINE> <INDENT> self.users[handle.requestID()] = obj <NEW_LINE> <DEDENT> return handle.requestID() <NEW_LINE> <DEDENT> AddMonitor.__doc__ = FileMonitor.AddMonitor.__doc__ <NEW_LINE> def Service(self, interval=0.50): <NEW_LINE> <INDENT> count = 0 <NEW_LINE> collapsed = 0 <NEW_LINE> rawevents = [] <NEW_LINE> start = time() <NEW_LINE> now = time() <NEW_LINE> while (time() - now) < interval: <NEW_LINE> <INDENT> if self.filemonitor.pending(): <NEW_LINE> <INDENT> while self.filemonitor.pending(): <NEW_LINE> <INDENT> count += 1 <NEW_LINE> rawevents.append(self.filemonitor.nextEvent()) <NEW_LINE> <DEDENT> now = time() <NEW_LINE> <DEDENT> <DEDENT> unique = [] <NEW_LINE> bookkeeping = [] <NEW_LINE> for event in rawevents: <NEW_LINE> <INDENT> if self.should_ignore(event): <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> if event.code2str() != 'changed': <NEW_LINE> <INDENT> unique.append(event) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> if (event.filename, event.requestID) not in bookkeeping: <NEW_LINE> <INDENT> bookkeeping.append((event.filename, event.requestID)) <NEW_LINE> unique.append(event) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> collapsed += 1 <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> for event in unique: <NEW_LINE> <INDENT> if event.requestID in self.users: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> self.users[event.requestID].HandleEvent(event) <NEW_LINE> <DEDENT> except: <NEW_LINE> <INDENT> LOGGER.error("Handling event for file %s" % event.filename, exc_info=1) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> end = time() <NEW_LINE> LOGGER.info("Processed %s fam events in %03.03f seconds. " "%s coalesced" % (count, (end - start), collapsed)) <NEW_LINE> return count | **Deprecated** file monitor backend with support for the `File
Alteration Monitor <http://oss.sgi.com/projects/fam/>`_ (also
abbreviated "FAM"). | 62599097283ffb24f3cf5636 |
class MaskFracBinner(FieldBinner): <NEW_LINE> <INDENT> def __init__(self, xmin, xmax, nbin, other_selection, field_base='mask_frac', **kw): <NEW_LINE> <INDENT> super(MaskFracBinner,self).__init__( field_base, xmin, xmax, nbin, selection=other_selection, **kw ) <NEW_LINE> <DEDENT> def doplot(self, d, **kw): <NEW_LINE> <INDENT> kw['xlabel']='masked fraction' <NEW_LINE> kw['fitlines']=False <NEW_LINE> super(MaskFracBinner,self).doplot(d, **kw) | Bin by psf shape. We use the psf shape without metacal,
since we often symmetrize the metacal psf | 62599097656771135c48aeff |
class DecisionTreeParams(Params): <NEW_LINE> <INDENT> maxDepth = Param(Params._dummy(), "maxDepth", "Maximum depth of the tree. (>= 0) E.g., depth 0 means 1 leaf node; depth 1 means 1 internal node + 2 leaf nodes.", typeConverter=TypeConverters.toInt) <NEW_LINE> maxBins = Param(Params._dummy(), "maxBins", "Max number of bins for discretizing continuous features. Must be >=2 and >= number of categories for any categorical feature.", typeConverter=TypeConverters.toInt) <NEW_LINE> minInstancesPerNode = Param(Params._dummy(), "minInstancesPerNode", "Minimum number of instances each child must have after split. If a split causes the left or right child to have fewer than minInstancesPerNode, the split will be discarded as invalid. Should be >= 1.", typeConverter=TypeConverters.toInt) <NEW_LINE> minInfoGain = Param(Params._dummy(), "minInfoGain", "Minimum information gain for a split to be considered at a tree node.", typeConverter=TypeConverters.toFloat) <NEW_LINE> maxMemoryInMB = Param(Params._dummy(), "maxMemoryInMB", "Maximum memory in MB allocated to histogram aggregation. If too small, then 1 node will be split per iteration, and its aggregates may exceed this size.", typeConverter=TypeConverters.toInt) <NEW_LINE> cacheNodeIds = Param(Params._dummy(), "cacheNodeIds", "If false, the algorithm will pass trees to executors to match instances with nodes. If true, the algorithm will cache node IDs for each instance. Caching can speed up training of deeper trees. Users can set how often should the cache be checkpointed or disable it by setting checkpointInterval.", typeConverter=TypeConverters.toBoolean) <NEW_LINE> def __init__(self): <NEW_LINE> <INDENT> super(DecisionTreeParams, self).__init__() <NEW_LINE> <DEDENT> def setMaxDepth(self, value): <NEW_LINE> <INDENT> self._set(maxDepth=value) <NEW_LINE> return self <NEW_LINE> <DEDENT> def getMaxDepth(self): <NEW_LINE> <INDENT> return self.getOrDefault(self.maxDepth) <NEW_LINE> <DEDENT> def setMaxBins(self, value): <NEW_LINE> <INDENT> self._set(maxBins=value) <NEW_LINE> return self <NEW_LINE> <DEDENT> def getMaxBins(self): <NEW_LINE> <INDENT> return self.getOrDefault(self.maxBins) <NEW_LINE> <DEDENT> def setMinInstancesPerNode(self, value): <NEW_LINE> <INDENT> self._set(minInstancesPerNode=value) <NEW_LINE> return self <NEW_LINE> <DEDENT> def getMinInstancesPerNode(self): <NEW_LINE> <INDENT> return self.getOrDefault(self.minInstancesPerNode) <NEW_LINE> <DEDENT> def setMinInfoGain(self, value): <NEW_LINE> <INDENT> self._set(minInfoGain=value) <NEW_LINE> return self <NEW_LINE> <DEDENT> def getMinInfoGain(self): <NEW_LINE> <INDENT> return self.getOrDefault(self.minInfoGain) <NEW_LINE> <DEDENT> def setMaxMemoryInMB(self, value): <NEW_LINE> <INDENT> self._set(maxMemoryInMB=value) <NEW_LINE> return self <NEW_LINE> <DEDENT> def getMaxMemoryInMB(self): <NEW_LINE> <INDENT> return self.getOrDefault(self.maxMemoryInMB) <NEW_LINE> <DEDENT> def setCacheNodeIds(self, value): <NEW_LINE> <INDENT> self._set(cacheNodeIds=value) <NEW_LINE> return self <NEW_LINE> <DEDENT> def getCacheNodeIds(self): <NEW_LINE> <INDENT> return self.getOrDefault(self.cacheNodeIds) | Mixin for Decision Tree parameters. | 62599097d8ef3951e32c8d2b |
class AppleseedOSLOutSocket(NodeSocket, AppleseedSocket): <NEW_LINE> <INDENT> bl_idname = "AppleseedOSLOutSocket" <NEW_LINE> bl_label = "OSL Socket" <NEW_LINE> socket_osl_id = '' <NEW_LINE> def draw(self, context, layout, node, text): <NEW_LINE> <INDENT> layout.label(text) <NEW_LINE> <DEDENT> def draw_color(self, context, node): <NEW_LINE> <INDENT> return 1.0, 1.0, 1.0, 1.0 | appleseed OSL base socket | 625990978a349b6b43687ffe |
class SimpleMarkdown(Generator): <NEW_LINE> <INDENT> extensions = ['.md'] <NEW_LINE> def process(self, src_dir, dest_dir, filename, processor): <NEW_LINE> <INDENT> basename, ext = os.path.splitext(filename) <NEW_LINE> processor.context.push( **get_yaml(os.path.join(src_dir, basename + '.yml')) ) <NEW_LINE> content = md.reset().convert(self.read_file(src_dir, filename)) <NEW_LINE> content = Template(content).render(processor.context) <NEW_LINE> processor.context['content'] = md.reset().convert(content) <NEW_LINE> tmpl = processor.templates[processor.context['template']] <NEW_LINE> self.write_file(dest_dir, basename + '.html', tmpl.render(processor.context)) <NEW_LINE> processor.context.pop() <NEW_LINE> return True | Generator for processing plain Markdown files
Will try to read {filename}.yml for additional context.
Processes content as a Template first, allowing variables, etc.
Will use context['template'] for the template name. | 62599097c4546d3d9def816a |
class ProjectPage(ConfigurationPageBase, Ui_ProjectPage): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> super(ProjectPage, self).__init__() <NEW_LINE> self.setupUi(self) <NEW_LINE> self.setObjectName("ProjectPage") <NEW_LINE> self.projectSearchNewFilesRecursiveCheckBox.setChecked( Preferences.getProject("SearchNewFilesRecursively")) <NEW_LINE> self.projectSearchNewFilesCheckBox.setChecked( Preferences.getProject("SearchNewFiles")) <NEW_LINE> self.projectAutoIncludeNewFilesCheckBox.setChecked( Preferences.getProject("AutoIncludeNewFiles")) <NEW_LINE> self.projectLoadSessionCheckBox.setChecked( Preferences.getProject("AutoLoadSession")) <NEW_LINE> self.projectSaveSessionCheckBox.setChecked( Preferences.getProject("AutoSaveSession")) <NEW_LINE> self.projectSessionAllBpCheckBox.setChecked( Preferences.getProject("SessionAllBreakpoints")) <NEW_LINE> self.projectLoadDebugPropertiesCheckBox.setChecked( Preferences.getProject("AutoLoadDbgProperties")) <NEW_LINE> self.projectSaveDebugPropertiesCheckBox.setChecked( Preferences.getProject("AutoSaveDbgProperties")) <NEW_LINE> self.projectAutoCompileFormsCheckBox.setChecked( Preferences.getProject("AutoCompileForms")) <NEW_LINE> self.projectAutoCompileResourcesCheckBox.setChecked( Preferences.getProject("AutoCompileResources")) <NEW_LINE> self.projectTimestampCheckBox.setChecked( Preferences.getProject("XMLTimestamp")) <NEW_LINE> self.projectRecentSpinBox.setValue( Preferences.getProject("RecentNumber")) <NEW_LINE> self.pythonVariantCheckBox.setChecked( Preferences.getProject("DeterminePyFromProject")) <NEW_LINE> self.autosaveTasksCheckBox.setChecked( Preferences.getTasks("TasksProjectAutoSave")) <NEW_LINE> <DEDENT> def save(self): <NEW_LINE> <INDENT> Preferences.setProject( "SearchNewFilesRecursively", self.projectSearchNewFilesRecursiveCheckBox.isChecked()) <NEW_LINE> Preferences.setProject( "SearchNewFiles", self.projectSearchNewFilesCheckBox.isChecked()) <NEW_LINE> Preferences.setProject( "AutoIncludeNewFiles", self.projectAutoIncludeNewFilesCheckBox.isChecked()) <NEW_LINE> Preferences.setProject( "AutoLoadSession", self.projectLoadSessionCheckBox.isChecked()) <NEW_LINE> Preferences.setProject( "AutoSaveSession", self.projectSaveSessionCheckBox.isChecked()) <NEW_LINE> Preferences.setProject( "SessionAllBreakpoints", self.projectSessionAllBpCheckBox.isChecked()) <NEW_LINE> Preferences.setProject( "AutoLoadDbgProperties", self.projectLoadDebugPropertiesCheckBox.isChecked()) <NEW_LINE> Preferences.setProject( "AutoSaveDbgProperties", self.projectSaveDebugPropertiesCheckBox.isChecked()) <NEW_LINE> Preferences.setProject( "AutoCompileForms", self.projectAutoCompileFormsCheckBox.isChecked()) <NEW_LINE> Preferences.setProject( "AutoCompileResources", self.projectAutoCompileResourcesCheckBox.isChecked()) <NEW_LINE> Preferences.setProject( "XMLTimestamp", self.projectTimestampCheckBox.isChecked()) <NEW_LINE> Preferences.setProject( "RecentNumber", self.projectRecentSpinBox.value()) <NEW_LINE> Preferences.setProject( "DeterminePyFromProject", self.pythonVariantCheckBox.isChecked()) <NEW_LINE> Preferences.setTasks( "TasksProjectAutoSave", self.autosaveTasksCheckBox.isChecked()) | Class implementing the Project configuration page. | 62599097be7bc26dc9252d25 |
class WeakGreedySurrogate(BasicObject): <NEW_LINE> <INDENT> @abstractmethod <NEW_LINE> def evaluate(self, mus, return_all_values=False): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def extend(self, mu): <NEW_LINE> <INDENT> pass | Surrogate for the approximation error in :func:`weak_greedy`. | 62599097091ae356687069d2 |
class NewsAgent: <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.sources = [] <NEW_LINE> self.destinations = [] <NEW_LINE> <DEDENT> def add_source(self, source): <NEW_LINE> <INDENT> self.sources.append(source) <NEW_LINE> <DEDENT> def addDestination(self, dest): <NEW_LINE> <INDENT> self.destinations.append(dest) <NEW_LINE> <DEDENT> def distribute(self): <NEW_LINE> <INDENT> items = [] <NEW_LINE> for source in self.sources: <NEW_LINE> <INDENT> items.extend(source.get_items()) <NEW_LINE> <DEDENT> for dest in self.destinations: <NEW_LINE> <INDENT> dest.receive_items(items) | 可将新闻源中的新闻分发到新闻目的地的对象 | 62599097656771135c48af01 |
class Movie(db.Model): <NEW_LINE> <INDENT> __tablename__ = 'movies' <NEW_LINE> id = db.Column(db.Integer, primary_key=True) <NEW_LINE> title = db.Column(db.String(500), nullable=False) <NEW_LINE> release_date = db.Column(db.Date, nullable=False) <NEW_LINE> actors = db.relationship("Actor", secondary=ActorMovie, backref=db.backref("movies")) <NEW_LINE> def __init__(self, title, release_date): <NEW_LINE> <INDENT> self.title = title <NEW_LINE> self.release_date = release_date <NEW_LINE> <DEDENT> def insert(self): <NEW_LINE> <INDENT> db.session.add(self) <NEW_LINE> db.session.commit() <NEW_LINE> <DEDENT> def update(self): <NEW_LINE> <INDENT> db.session.commit() <NEW_LINE> <DEDENT> def delete(self): <NEW_LINE> <INDENT> db.session.delete(self) <NEW_LINE> db.session.commit() <NEW_LINE> <DEDENT> def format(self): <NEW_LINE> <INDENT> return { 'id': self.id, 'title': self.title, 'release_date': self.release_date } <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return f'<Movie ID: {self.id}, Movie Title: {self.title}>' | Model that defines a movie and its attributes | 625990978a349b6b43688002 |
class PrefixSet(_abc.MutableSet): <NEW_LINE> <INDENT> def __init__(self, iterable=None, factory=Trie, **kwargs): <NEW_LINE> <INDENT> trie = factory(**kwargs) <NEW_LINE> if iterable: <NEW_LINE> <INDENT> trie.update((key, True) for key in iterable) <NEW_LINE> <DEDENT> self._trie = trie <NEW_LINE> <DEDENT> def copy(self): <NEW_LINE> <INDENT> return self.__class__(self._trie, factory=self._trie.__class__) <NEW_LINE> <DEDENT> def clear(self): <NEW_LINE> <INDENT> self._trie.clear() <NEW_LINE> <DEDENT> def __contains__(self, key): <NEW_LINE> <INDENT> return bool(self._trie.shortest_prefix(key)[1]) <NEW_LINE> <DEDENT> def __iter__(self): <NEW_LINE> <INDENT> return self._trie.iterkeys() <NEW_LINE> <DEDENT> def iter(self, prefix=_SENTINEL): <NEW_LINE> <INDENT> if prefix is _SENTINEL: <NEW_LINE> <INDENT> return iter(self) <NEW_LINE> <DEDENT> elif self._trie.has_node(prefix): <NEW_LINE> <INDENT> return self._trie.iterkeys(prefix=prefix) <NEW_LINE> <DEDENT> elif prefix in self: <NEW_LINE> <INDENT> return self._trie._key_from_path(self._trie._path_from_key(prefix)), <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return () <NEW_LINE> <DEDENT> <DEDENT> def __len__(self): <NEW_LINE> <INDENT> return len(self._trie) <NEW_LINE> <DEDENT> def add(self, value): <NEW_LINE> <INDENT> if value not in self: <NEW_LINE> <INDENT> self._trie[value:] = True <NEW_LINE> <DEDENT> <DEDENT> def discard(self, value): <NEW_LINE> <INDENT> raise NotImplementedError( 'Removing values from PrefixSet is not implemented.') <NEW_LINE> <DEDENT> def remove(self, value): <NEW_LINE> <INDENT> raise NotImplementedError( 'Removing values from PrefixSet is not implemented.') <NEW_LINE> <DEDENT> def pop(self): <NEW_LINE> <INDENT> raise NotImplementedError( 'Removing values from PrefixSet is not implemented.') | A set of prefixes.
:class:`pygtrie.PrefixSet` works similar to a normal set except it is said
to contain a key if the key or it's prefix is stored in the set. For
instance, if "foo" is added to the set, the set contains "foo" as well as
"foobar".
The set supports addition of elements but does *not* support removal of
elements. This is because there's no obvious consistent and intuitive
behaviour for element deletion. | 62599097c4546d3d9def816d |
class Food(object): <NEW_LINE> <INDENT> def __init__(self, name, cost, kkal): <NEW_LINE> <INDENT> self.name = name <NEW_LINE> self.cost = cost <NEW_LINE> self.kkal = kkal <NEW_LINE> year = 2019 <NEW_LINE> month = randint(2, 6) <NEW_LINE> day = randint(1, 28) <NEW_LINE> self.time = datetime(year, month, day) <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> rep = self.name + " цена: " + str(self.cost) + "." <NEW_LINE> rep += " Ккал - " + str(self.kkal) + ". Годно до:" + self.time.strftime("%d.%m.%Y") <NEW_LINE> return rep <NEW_LINE> <DEDENT> __repr__ = __str__ | Еда в столовой | 62599097099cdd3c636762cc |
class ConnectionError(RequestException): <NEW_LINE> <INDENT> pass | A Connection error occured. | 6259909750812a4eaa621a9a |
class FilesAPI(GoogleDrive, SheetsService, DocsService): <NEW_LINE> <INDENT> def create_sheet(self, folder_parent, folder, filename: str): <NEW_LINE> <INDENT> spreadsheet = super().create_spreadsheet(filename) <NEW_LINE> spreadsheet_id = spreadsheet.get('spreadsheetId') <NEW_LINE> super().update_file_parent( file_id=spreadsheet_id, current_parent=folder_parent, new_parent=folder.id ) <NEW_LINE> return spreadsheet_id <NEW_LINE> <DEDENT> def get_file_rows_from_folder(self, foldername: str, filename: str, rows_range: str): <NEW_LINE> <INDENT> file_path = f"/{foldername}/{filename}" <NEW_LINE> google_file = super().googledrive_get_file(file_path) <NEW_LINE> if google_file is None: <NEW_LINE> <INDENT> raise MissingGoogleDriveFileException('Missing file: {}'.format(filename)) <NEW_LINE> <DEDENT> values = super().get_file_values( google_file.id, rows_range) <NEW_LINE> return values <NEW_LINE> <DEDENT> def empty_document(self, document_id, insert_index, end_index): <NEW_LINE> <INDENT> document = super().get_document(document_id) <NEW_LINE> content = document.get('body').get('content') <NEW_LINE> if end_index in range(0, 2) or insert_index >= end_index: <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> requests = [ { 'deleteContentRange':{ 'range': { 'segmentId': '', 'startIndex': insert_index, 'endIndex': end_index } } } ] <NEW_LINE> super().batch_update(document_id=document_id, requests=requests) | Composition of google APIs | 625990973617ad0b5ee07efa |
class HelpTextAccumulator(DiffAccumulator): <NEW_LINE> <INDENT> def __init__(self, restrict=None): <NEW_LINE> <INDENT> super(HelpTextAccumulator, self).__init__() <NEW_LINE> self._changes = [] <NEW_LINE> self._invalid_abbreviations = re.compile( r'\b({0})\b'.format('|'.join(INVALID_BRAND_ABBREVIATIONS))) <NEW_LINE> self._invalid_file_count = 0 <NEW_LINE> self._restrict = ({os.sep.join(r.split('.')[1:]) for r in restrict} if restrict else {}) <NEW_LINE> <DEDENT> @property <NEW_LINE> def invalid_file_count(self): <NEW_LINE> <INDENT> return self._invalid_file_count <NEW_LINE> <DEDENT> def Ignore(self, relative_file): <NEW_LINE> <INDENT> if Whitelisted(relative_file): <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> if not self._restrict: <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> for item in self._restrict: <NEW_LINE> <INDENT> if relative_file == item or relative_file.startswith(item + os.sep): <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> <DEDENT> return True <NEW_LINE> <DEDENT> def Validate(self, relative_file, contents): <NEW_LINE> <INDENT> if self._invalid_abbreviations.search(contents): <NEW_LINE> <INDENT> log.error('[{0}] Help text cannot contain any of these abbreviations: ' '[{1}].'.format(relative_file, ','.join(INVALID_BRAND_ABBREVIATIONS))) <NEW_LINE> self._invalid_file_count += 1 <NEW_LINE> <DEDENT> <DEDENT> def AddChange(self, op, relative_file, old_contents=None, new_contents=None): <NEW_LINE> <INDENT> self._changes.append((op, relative_file)) <NEW_LINE> return None | Accumulates help text directory differences.
Attributes:
_changes: The list of DirDiff() (op, path) difference tuples.
_invalid_file_count: The number of files that have invalid content.
_restrict: The set of file path prefixes that the accumulator should be
restricted to. | 62599097d8ef3951e32c8d30 |
class Subscriber(metaclass=ABCMeta): <NEW_LINE> <INDENT> @abstractclassmethod <NEW_LINE> def update(self): <NEW_LINE> <INDENT> pass | 观察者的抽象基类，具体观察者，用来实现观察者接口以保持其状态与主题中的变化一致 | 625990978a349b6b4368800b |
class PasswordResetCompleteView(PasswordResetCompleteView): <NEW_LINE> <INDENT> template_name = 'authentication/password_reset_complete.html' <NEW_LINE> title = 'Password reset complete' | after succeesfully change of password
| 62599097dc8b845886d55362 |
class Positive(calculation.Calculation): <NEW_LINE> <INDENT> def __init__(self, subcalc): <NEW_LINE> <INDENT> super(Positive, self).__init__([subcalc.unitses[0]] + subcalc.unitses) <NEW_LINE> self.subcalc = subcalc <NEW_LINE> <DEDENT> def latex(self, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> def apply(self, region, *args, **kwargs): <NEW_LINE> <INDENT> def generate(year, result): <NEW_LINE> <INDENT> return result if result > 0 else 0 <NEW_LINE> <DEDENT> subapp = self.subcalc.apply(region, *args, **kwargs) <NEW_LINE> return calculation.ApplicationPassCall(region, subapp, generate, unshift=True) <NEW_LINE> <DEDENT> def column_info(self): <NEW_LINE> <INDENT> infos = self.subcalc.column_info() <NEW_LINE> title = 'Positive-only form of ' + infos[0]['title'] <NEW_LINE> description = 'The value of ' + infos[0]['title'] + ', if positive and otherwise 0.' <NEW_LINE> return [dict(name='positive', title=title, description=description)] + infos | Return 0 if subcalc is less than 0 | 62599097adb09d7d5dc0c306 |
class ChebyshevPolynomial(): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def basis_generation_with_eigenvalue_shifting_and_scaling_single_vec(self, mat, vec, step_val, max_eigenval, min_eigenval): <NEW_LINE> <INDENT> assert step_val>=1, "Need a larger step_val" <NEW_LINE> chebyshev_basis = np.zeros((mat.shape[0], step_val)) <NEW_LINE> matvec = linalg.aslinearoperator(mat) <NEW_LINE> s_alpha = 2.0 / (max_eigenval - min_eigenval) <NEW_LINE> s_beta = - (max_eigenval + min_eigenval) / (max_eigenval - min_eigenval) <NEW_LINE> for sIdx in range(1,step_val+1): <NEW_LINE> <INDENT> degree = sIdx-1 <NEW_LINE> if degree == 0: <NEW_LINE> <INDENT> chebyshev_basis[:,degree] = vec[:,0] <NEW_LINE> <DEDENT> elif degree == 1: <NEW_LINE> <INDENT> chebyshev_basis[:,degree] = (s_alpha * matvec(vec) + s_beta * vec)[:,0] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> chebyshev_basis[:,degree] = 2 * s_alpha * matvec(chebyshev_basis[:, degree-1]) + 2 * s_beta * chebyshev_basis[:,degree-1] - chebyshev_basis[:,degree-2] <NEW_LINE> <DEDENT> <DEDENT> return chebyshev_basis <NEW_LINE> <DEDENT> def basis_generation_with_eigenvalue_shifting_and_scaling_block_vecs(self, mat, blockvec, step_val, max_eigenval, min_eigenval): <NEW_LINE> <INDENT> assert step_val>=1, "Need a larger step_val" <NEW_LINE> block_size = blockvec.shape[1] <NEW_LINE> chebyshev_basis = np.zeros((mat.shape[0], block_size*step_val)) <NEW_LINE> op_linalg_A = linalg.aslinearoperator(mat) <NEW_LINE> s_alpha = 2.0 / (max_eigenval - min_eigenval) <NEW_LINE> s_beta = - (max_eigenval + min_eigenval) / (max_eigenval - min_eigenval) <NEW_LINE> for sIdx in range(1,step_val+1): <NEW_LINE> <INDENT> degree = sIdx-1 <NEW_LINE> if degree == 0: <NEW_LINE> <INDENT> chebyshev_basis[:,0:block_size] = blockvec[:,0:block_size] <NEW_LINE> <DEDENT> elif degree == 1: <NEW_LINE> <INDENT> chebyshev_basis[:,block_size:2*block_size] = (s_alpha * op_linalg_A.matmat(blockvec) + s_beta * blockvec)[:,0:block_size] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> chebyshev_basis[:,degree*block_size:(degree+1)*block_size] = 2 * s_alpha * op_linalg_A.matmat(chebyshev_basis[:, (degree-1)*block_size:degree*block_size]) + 2 * s_beta * chebyshev_basis[:,(degree-1)*block_size:degree*block_size] - chebyshev_basis[:,(degree-2)*block_size:(degree-1)*block_size] <NEW_LINE> <DEDENT> <DEDENT> return chebyshev_basis | Chebyshev Polynomial class | 62599097d8ef3951e32c8d33 |
class RandDur(PyoObject): <NEW_LINE> <INDENT> def __init__(self, min=0.0, max=1.0, mul=1, add=0): <NEW_LINE> <INDENT> pyoArgsAssert(self, "OOOO", min, max, mul, add) <NEW_LINE> PyoObject.__init__(self, mul, add) <NEW_LINE> self._min = min <NEW_LINE> self._max = max <NEW_LINE> min, max, mul, add, lmax = convertArgsToLists(min, max, mul, add) <NEW_LINE> self._base_objs = [RandDur_base(wrap(min, i), wrap(max, i), wrap(mul, i), wrap(add, i)) for i in range(lmax)] <NEW_LINE> self._init_play() <NEW_LINE> <DEDENT> def setMin(self, x): <NEW_LINE> <INDENT> pyoArgsAssert(self, "O", x) <NEW_LINE> self._min = x <NEW_LINE> x, lmax = convertArgsToLists(x) <NEW_LINE> [obj.setMin(wrap(x, i)) for i, obj in enumerate(self._base_objs)] <NEW_LINE> <DEDENT> def setMax(self, x): <NEW_LINE> <INDENT> pyoArgsAssert(self, "O", x) <NEW_LINE> self._max = x <NEW_LINE> x, lmax = convertArgsToLists(x) <NEW_LINE> [obj.setMax(wrap(x, i)) for i, obj in enumerate(self._base_objs)] <NEW_LINE> <DEDENT> def ctrl(self, map_list=None, title=None, wxnoserver=False): <NEW_LINE> <INDENT> self._map_list = [ SLMap(0.0, 1.0, "lin", "min", self._min), SLMap(1.0, 2.0, "lin", "max", self._max), SLMapMul(self._mul), ] <NEW_LINE> PyoObject.ctrl(self, map_list, title, wxnoserver) <NEW_LINE> <DEDENT> @property <NEW_LINE> def min(self): <NEW_LINE> <INDENT> return self._min <NEW_LINE> <DEDENT> @min.setter <NEW_LINE> def min(self, x): <NEW_LINE> <INDENT> self.setMin(x) <NEW_LINE> <DEDENT> @property <NEW_LINE> def max(self): <NEW_LINE> <INDENT> return self._max <NEW_LINE> <DEDENT> @max.setter <NEW_LINE> def max(self, x): <NEW_LINE> <INDENT> self.setMax(x) | Recursive time varying pseudo-random generator.
RandDur generates a pseudo-random number between `min` and `max`
arguments and uses that number to set the delay time before the next
generation. RandDur will hold the generated value until next generation.
:Parent: :py:class:`PyoObject`
:Args:
min: float or PyoObject, optional
Minimum value for the random generation. Defaults to 0.
max: float or PyoObject, optional
Maximum value for the random generation. Defaults to 1.
>>> s = Server().boot()
>>> s.start()
>>> dur = RandDur(min=[.05,0.1], max=[.4,.5])
>>> trig = Change(dur)
>>> amp = TrigEnv(trig, table=HannTable(), dur=dur, mul=.2)
>>> freqs = midiToHz([60,63,67,70,72])
>>> freq = TrigChoice(trig, choice=freqs)
>>> a = LFO(freq=freq, type=2, mul=amp).out() | 625990977cff6e4e811b77f4 |
class MonitoringProcessor(object): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.logger = logging.getLogger('monitor.processor.%s' % self.__class__.__name__) <NEW_LINE> <DEDENT> def report_exception(self, msg="Processor has failed with exception:"): <NEW_LINE> <INDENT> if msg: <NEW_LINE> <INDENT> self.logger.error(msg) <NEW_LINE> <DEDENT> self.logger.error(traceback.format_exc()) | Interface for a monitoring processor. | 62599097656771135c48af09 |
class Gauge(pygame.sprite.Sprite): <NEW_LINE> <INDENT> def __init__(self, maxValue, parentPlayer, color=(0,255,0)): <NEW_LINE> <INDENT> super().__init__() <NEW_LINE> self.maxValue = maxValue <NEW_LINE> self.fillColor = color <NEW_LINE> self.parent = parentPlayer <NEW_LINE> self.image = pygame.Surface([maxValue, 10]) <NEW_LINE> self.image.fill(self.fillColor) <NEW_LINE> self.rect = self.image.get_rect() <NEW_LINE> <DEDENT> def update(self, deltaTime): <NEW_LINE> <INDENT> self.rect = self.image.get_rect(center=self.parent.position + (0, 60)) <NEW_LINE> self.image = pygame.transform.scale(self.image, (int(self.parent.fuel), 10)) | Class for UI gauges such as fuel | 6259909750812a4eaa621a9f |
class StatusCommand(command.ShowOne): <NEW_LINE> <INDENT> hidden_status_items = {'links'} <NEW_LINE> @classmethod <NEW_LINE> def status_attributes(cls, client_item): <NEW_LINE> <INDENT> return [item for item in client_item.items() if item[0] not in cls.hidden_status_items] <NEW_LINE> <DEDENT> def get_parser(self, prog_name): <NEW_LINE> <INDENT> parser = super(StatusCommand, self).get_parser(prog_name) <NEW_LINE> parser.add_argument('node', help='baremetal node UUID or name') <NEW_LINE> return parser <NEW_LINE> <DEDENT> def take_action(self, parsed_args): <NEW_LINE> <INDENT> client = self.app.client_manager.baremetal_introspection <NEW_LINE> status = client.get_status(parsed_args.node) <NEW_LINE> return zip(*sorted(self.status_attributes(status))) | Get introspection status. | 62599097d8ef3951e32c8d35 |
class ModelId(Enum): <NEW_LINE> <INDENT> AR_AR_BROADBANDMODEL = 'ar-AR_BroadbandModel' <NEW_LINE> DE_DE_BROADBANDMODEL = 'de-DE_BroadbandModel' <NEW_LINE> DE_DE_NARROWBANDMODEL = 'de-DE_NarrowbandModel' <NEW_LINE> EN_GB_BROADBANDMODEL = 'en-GB_BroadbandModel' <NEW_LINE> EN_GB_NARROWBANDMODEL = 'en-GB_NarrowbandModel' <NEW_LINE> EN_US_BROADBANDMODEL = 'en-US_BroadbandModel' <NEW_LINE> EN_US_NARROWBANDMODEL = 'en-US_NarrowbandModel' <NEW_LINE> EN_US_SHORTFORM_NARROWBANDMODEL = 'en-US_ShortForm_NarrowbandModel' <NEW_LINE> ES_AR_BROADBANDMODEL = 'es-AR_BroadbandModel' <NEW_LINE> ES_AR_NARROWBANDMODEL = 'es-AR_NarrowbandModel' <NEW_LINE> ES_CL_BROADBANDMODEL = 'es-CL_BroadbandModel' <NEW_LINE> ES_CL_NARROWBANDMODEL = 'es-CL_NarrowbandModel' <NEW_LINE> ES_CO_BROADBANDMODEL = 'es-CO_BroadbandModel' <NEW_LINE> ES_CO_NARROWBANDMODEL = 'es-CO_NarrowbandModel' <NEW_LINE> ES_ES_BROADBANDMODEL = 'es-ES_BroadbandModel' <NEW_LINE> ES_ES_NARROWBANDMODEL = 'es-ES_NarrowbandModel' <NEW_LINE> ES_MX_BROADBANDMODEL = 'es-MX_BroadbandModel' <NEW_LINE> ES_MX_NARROWBANDMODEL = 'es-MX_NarrowbandModel' <NEW_LINE> ES_PE_BROADBANDMODEL = 'es-PE_BroadbandModel' <NEW_LINE> ES_PE_NARROWBANDMODEL = 'es-PE_NarrowbandModel' <NEW_LINE> FR_FR_BROADBANDMODEL = 'fr-FR_BroadbandModel' <NEW_LINE> FR_FR_NARROWBANDMODEL = 'fr-FR_NarrowbandModel' <NEW_LINE> JA_JP_BROADBANDMODEL = 'ja-JP_BroadbandModel' <NEW_LINE> JA_JP_NARROWBANDMODEL = 'ja-JP_NarrowbandModel' <NEW_LINE> KO_KR_BROADBANDMODEL = 'ko-KR_BroadbandModel' <NEW_LINE> KO_KR_NARROWBANDMODEL = 'ko-KR_NarrowbandModel' <NEW_LINE> PT_BR_BROADBANDMODEL = 'pt-BR_BroadbandModel' <NEW_LINE> PT_BR_NARROWBANDMODEL = 'pt-BR_NarrowbandModel' <NEW_LINE> ZH_CN_BROADBANDMODEL = 'zh-CN_BroadbandModel' <NEW_LINE> ZH_CN_NARROWBANDMODEL = 'zh-CN_NarrowbandModel' | The identifier of the model in the form of its name from the output of the **Get a
model** method. | 62599097dc8b845886d5536b |
class IntegerEnumOneValue( _SchemaEnumMaker( enum_value_to_name={ 0: "POSITIVE_0", } ), IntSchema ): <NEW_LINE> <INDENT> @classmethod <NEW_LINE> @property <NEW_LINE> def POSITIVE_0(cls): <NEW_LINE> <INDENT> return cls._enum_by_value[0](0) | NOTE: This class is auto generated by OpenAPI Generator.
Ref: https://openapi-generator.tech
Do not edit the class manually. | 625990977cff6e4e811b77f8 |
class UpgradeClusterInstancesRequest(AbstractModel): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.ClusterId = None <NEW_LINE> self.Operation = None <NEW_LINE> self.UpgradeType = None <NEW_LINE> self.InstanceIds = None <NEW_LINE> self.ResetParam = None <NEW_LINE> self.SkipPreCheck = None <NEW_LINE> self.MaxNotReadyPercent = None <NEW_LINE> <DEDENT> def _deserialize(self, params): <NEW_LINE> <INDENT> self.ClusterId = params.get("ClusterId") <NEW_LINE> self.Operation = params.get("Operation") <NEW_LINE> self.UpgradeType = params.get("UpgradeType") <NEW_LINE> self.InstanceIds = params.get("InstanceIds") <NEW_LINE> if params.get("ResetParam") is not None: <NEW_LINE> <INDENT> self.ResetParam = UpgradeNodeResetParam() <NEW_LINE> self.ResetParam._deserialize(params.get("ResetParam")) <NEW_LINE> <DEDENT> self.SkipPreCheck = params.get("SkipPreCheck") <NEW_LINE> self.MaxNotReadyPercent = params.get("MaxNotReadyPercent") | UpgradeClusterInstances请求参数结构体
| 6259909750812a4eaa621aa3 |
class GroupEntityMixin(models.Model): <NEW_LINE> <INDENT> label = models.CharField(_('label'), max_length=255) <NEW_LINE> codename = models.SlugField(_('codename'), unique=True, blank=True, max_length=255) <NEW_LINE> class Meta: <NEW_LINE> <INDENT> abstract = True <NEW_LINE> ordering = ('label', ) <NEW_LINE> <DEDENT> def __unicode__(self): <NEW_LINE> <INDENT> return self.label <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return self.label <NEW_LINE> <DEDENT> def save(self, *args, **kwargs): <NEW_LINE> <INDENT> if not self.codename: <NEW_LINE> <INDENT> self.codename = slugify(self.label) <NEW_LINE> <DEDENT> super(GroupEntityMixin, self).save(*args, **kwargs) <NEW_LINE> <DEDENT> @property <NEW_LINE> def groups(self): <NEW_LINE> <INDENT> message = 'The "groups" attribute will be removed in next version. ' + 'Use "groups_manager_group_set" instead.' <NEW_LINE> warnings.warn(message, DeprecationWarning) <NEW_LINE> return self.groups_manager_group_set | This model represents the entities of a group. One group could have more than one entity.
This objects could describe the group's properties (i.e. Administrators, Users, ecc).
:Parameters:
- `label`: (required)
- `codename`: unique codename; if not set, it's autogenerated by slugifying the label
(lower case) | 62599097d8ef3951e32c8d39 |
class ProductOperator(LinearOperator): <NEW_LINE> <INDENT> def __init__(self, *args, **kwargs): <NEW_LINE> <INDENT> self._structure = kwargs.get('structure', None) <NEW_LINE> for A in args: <NEW_LINE> <INDENT> if len(A.shape) != 2 or A.shape[0] != A.shape[1]: <NEW_LINE> <INDENT> raise ValueError( 'For now, the ProductOperator implementation is ' 'limited to the product of multiple square matrices.') <NEW_LINE> <DEDENT> <DEDENT> if args: <NEW_LINE> <INDENT> n = args[0].shape[0] <NEW_LINE> for A in args: <NEW_LINE> <INDENT> for d in A.shape: <NEW_LINE> <INDENT> if d != n: <NEW_LINE> <INDENT> raise ValueError( 'The square matrices of the ProductOperator ' 'must all have the same shape.') <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> self.shape = (n, n) <NEW_LINE> self.ndim = len(self.shape) <NEW_LINE> <DEDENT> self._operator_sequence = args <NEW_LINE> <DEDENT> def matvec(self, x): <NEW_LINE> <INDENT> for A in reversed(self._operator_sequence): <NEW_LINE> <INDENT> x = A.dot(x) <NEW_LINE> <DEDENT> return x <NEW_LINE> <DEDENT> def rmatvec(self, x): <NEW_LINE> <INDENT> for A in self._operator_sequence: <NEW_LINE> <INDENT> x = x.dot(A) <NEW_LINE> <DEDENT> return x <NEW_LINE> <DEDENT> def matmat(self, X): <NEW_LINE> <INDENT> for A in reversed(self._operator_sequence): <NEW_LINE> <INDENT> X = _smart_matrix_product(A, X, structure=self._structure) <NEW_LINE> <DEDENT> return X <NEW_LINE> <DEDENT> @property <NEW_LINE> def T(self): <NEW_LINE> <INDENT> T_args = [A.T for A in reversed(self._operator_sequence)] <NEW_LINE> return ProductOperator(*T_args) | For now, this is limited to products of multiple square matrices. | 62599097656771135c48af0e |
class ScpArgument(object): <NEW_LINE> <INDENT> def __init__(self, arg): <NEW_LINE> <INDENT> self.username, self.hostname, self.path = None, None, None <NEW_LINE> if ':' in arg: <NEW_LINE> <INDENT> hostname, self.path = arg.split(':', 1) <NEW_LINE> if '@' in hostname: <NEW_LINE> <INDENT> self.username, self.hostname = hostname.split('@', 1) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.hostname = hostname <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> self.path = arg <NEW_LINE> <DEDENT> <DEDENT> def isLocal(self): <NEW_LINE> <INDENT> return not bool(self.hostname) <NEW_LINE> <DEDENT> def isRemote(self): <NEW_LINE> <INDENT> return bool(self.hostname) <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> ret = '' <NEW_LINE> if self.username: <NEW_LINE> <INDENT> ret += self.username + '@' <NEW_LINE> <DEDENT> if self.hostname: <NEW_LINE> <INDENT> ret += self.hostname + ':' <NEW_LINE> <DEDENT> ret += self.path <NEW_LINE> return ret <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return '<%s username=%r hostname=%r path=%r>' % (self.__class__.__name__, self.username, self.hostname) | Parse and split SCP argument string
Possible formats:
'/path/to/file' - local file/folder reference
'remote:/path/to/file' - remote file/folder reference, without username
'username@remote:/path/to/file' - remote file/folder reference with username
'remote:' - remote without path and username, references home directory on remote
'username@remote:' - remote without path but with username, reference home directory on remote
i.e.:
'[email protected]:/etc' will be parsed to object.username = 'root',
object.hostname = '127.0.0.1',
object.path = '/etc'
'/boo' will be parsed to object.username = '',
object.hostname = '',
object.path = '/boo' | 62599098be7bc26dc9252d33 |
class RestClientUtils: <NEW_LINE> <INDENT> @staticmethod <NEW_LINE> def verify_response_code(response_code): <NEW_LINE> <INDENT> if response_code is hl.OK: <NEW_LINE> <INDENT> LOG.debug("Success operation result code.") <NEW_LINE> return <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> RestClientUtils.check_status(response_code) <NEW_LINE> <DEDENT> <DEDENT> @staticmethod <NEW_LINE> def check_status(status): <NEW_LINE> <INDENT> raise { hl.NOT_FOUND: RestClientUtils.raise_not_found_error(status), hl.BAD_REQUEST: RestClientUtils.raise_base_request_eror(status), hl.CONFLICT: RestClientUtils.raise_conflict_error(status), hl.UNAUTHORIZED: RestClientUtils.raise_unauthorized_error(status), hl.FORBIDDEN: RestClientUtils.raise_forbidden_error(status), hl.METHOD_NOT_ALLOWED: RestClientUtils.raise_not_allowed(status), hl.INTERNAL_SERVER_ERROR: RestClientUtils.raise_inter_serv_error( status) }.get(status, RestClientUtils.raise_not_supported_error(status)) <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def raise_not_found_error(status): <NEW_LINE> <INDENT> return NotFoundError(status, u'Not found HTTP code' u' was received from gateway server.') <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def raise_base_request_eror(status): <NEW_LINE> <INDENT> return BadRequestError(status, u'Bad request HTTP code ' u'was received from gateway server.') <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def raise_conflict_error(status): <NEW_LINE> <INDENT> return ConflictError(status, u'Conflict HTTP code was' u' received from gateway server.') <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def raise_unauthorized_error(status): <NEW_LINE> <INDENT> return UnauthorizedError(status, u'Authorization error' u' code was received from server. ') <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def raise_forbidden_error(status): <NEW_LINE> <INDENT> return ForbiddenError(status, u'Forbidden HTTP code was ' u'received from gateway server') <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def raise_not_allowed(status): <NEW_LINE> <INDENT> return MethodNotAllowed(status, u'Method not allowed code was ' u'received from gateway server') <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def raise_inter_serv_error(status): <NEW_LINE> <INDENT> return InternalServerError(status, u'Internal server exception ' u'during operation process. ') <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def raise_not_supported_error(status): <NEW_LINE> <INDENT> return NotSupportedError(status, u'Operation is ' u'not supported by gateway server') | The utility class for working with rest clients | 625990987cff6e4e811b7800 |
class Registry(): <NEW_LINE> <INDENT> registry_list = None <NEW_LINE> database = None <NEW_LINE> def __init__(self, database): <NEW_LINE> <INDENT> self.database = database <NEW_LINE> <DEDENT> def get_game(self, game_type, game_id): <NEW_LINE> <INDENT> return self.database.get_data(game_type, {"unique_id": game_id}) <NEW_LINE> <DEDENT> def get_list(self, game_type, date): <NEW_LINE> <INDENT> projection = { "_id": 0, "attributes": 0 } <NEW_LINE> cursor_object = self.database.get_data_list(game_type, {"date": date}, projection) <NEW_LINE> list_of_objects = list(cursor_object) <NEW_LINE> return list_of_objects | config the object functions according to the game | 62599098099cdd3c636762d8 |
class Solution2: <NEW_LINE> <INDENT> def fourSum(self, nums, target): <NEW_LINE> <INDENT> nums.sort() <NEW_LINE> results = [] <NEW_LINE> self.findNsum(nums, target, 4, [], results) <NEW_LINE> return results <NEW_LINE> <DEDENT> def findNsum(self, nums, target, N, result, results): <NEW_LINE> <INDENT> if len(nums) < N or N < 2: return <NEW_LINE> if N == 2: <NEW_LINE> <INDENT> l, r = 0, len(nums) - 1 <NEW_LINE> while l < r: <NEW_LINE> <INDENT> if nums[l] + nums[r] == target: <NEW_LINE> <INDENT> results.append(result + [nums[l], nums[r]]) <NEW_LINE> l += 1 <NEW_LINE> r -= 1 <NEW_LINE> while l < r and nums[l] == nums[l - 1]: <NEW_LINE> <INDENT> l += 1 <NEW_LINE> <DEDENT> while r > l and nums[r] == nums[r + 1]: <NEW_LINE> <INDENT> r -= 1 <NEW_LINE> <DEDENT> <DEDENT> elif nums[l] + nums[r] < target: <NEW_LINE> <INDENT> l += 1 <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> r -= 1 <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> for i in range(0, len(nums) - N + 1): <NEW_LINE> <INDENT> if target < nums[i] * N or target > nums[-1] * N: <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> if i == 0 or i > 0 and nums[i - 1] != nums[i]: <NEW_LINE> <INDENT> self.findNsum(nums[i + 1:], target - nums[i], N - 1, result + [nums[i]], results) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> return | @param numbers: Give an array
@param target: An integer
@return: Find all unique quadruplets in the array which gives the sum of zero | 62599098be7bc26dc9252d34 |
class MqttConnector: <NEW_LINE> <INDENT> client = None <NEW_LINE> onMessageReceived = None <NEW_LINE> topics = [] <NEW_LINE> def on_connect(self, client, userdata, flags, rc): <NEW_LINE> <INDENT> print("Connected with result code " + str(rc)) <NEW_LINE> self.subscribeToAllTopics() <NEW_LINE> <DEDENT> def subscribeToAllTopics(self): <NEW_LINE> <INDENT> print("Now listening on: ") <NEW_LINE> for topic in self.topics: <NEW_LINE> <INDENT> fullTopic = topic + "/#" <NEW_LINE> print(" " + fullTopic) <NEW_LINE> self.client.subscribe(fullTopic) <NEW_LINE> <DEDENT> <DEDENT> def on_message(self, client, userdata, msg): <NEW_LINE> <INDENT> topicParts = msg.topic.partition("/") <NEW_LINE> print("Message received on topic: ") <NEW_LINE> print(topicParts) <NEW_LINE> msgType = CommunicationHelper.getMsgType(topicParts[2]) <NEW_LINE> self.onMessageReceived(topicParts[0], msgType, msg.payload) <NEW_LINE> <DEDENT> def __init__(self, onMessageReceived): <NEW_LINE> <INDENT> self.onMessageReceived = onMessageReceived <NEW_LINE> self.client = mqtt.Client() <NEW_LINE> self.client.on_connect = self.on_connect <NEW_LINE> self.client.on_message = self.on_message <NEW_LINE> self.connect() <NEW_LINE> self.client.loop_start() <NEW_LINE> <DEDENT> def updateSubscriptions(self, topics): <NEW_LINE> <INDENT> self.topics = topics <NEW_LINE> self.subscribeToAllTopics() <NEW_LINE> <DEDENT> def connect(self): <NEW_LINE> <INDENT> self.client.connect(HOST, PORT, KEEPALIVE_SECONDS) <NEW_LINE> <DEDENT> def publish(self, channel, message, messageType): <NEW_LINE> <INDENT> topicPostfix = CommunicationHelper.getMsgStringType(messageType) <NEW_LINE> fullChannel = channel + "/" + topicPostfix <NEW_LINE> print("Publish to channel: " + fullChannel + " Msg:\n" + str(message)) <NEW_LINE> publish.single(fullChannel, message, hostname=HOST, qos=2) | Responsible for mqtt pub/sub | 62599098c4546d3d9def817a |
class Show(URIBase, AsyncIterable): <NEW_LINE> <INDENT> def __init__(self, client, data): <NEW_LINE> <INDENT> self.__client = client <NEW_LINE> self.available_markets = data.pop("available_markets", None) <NEW_LINE> self.copyrights = data.pop("copyrights", None) <NEW_LINE> self.description = data.pop("description", None) <NEW_LINE> self.explicit = data.pop("explicit", None) <NEW_LINE> self.external_urls = data.pop("external_urls").get("spotify", None) <NEW_LINE> self.href = data.pop("href", None) <NEW_LINE> self.id = data.pop("id", None) <NEW_LINE> self.images = list(Image(**image) for image in data.pop("images", None)) <NEW_LINE> self.externally_hosted = data.pop("is_externally_hosted", None) <NEW_LINE> self.languages = data.pop("languages", None) <NEW_LINE> self.media_type = data.pop("media_type", None) <NEW_LINE> self.name = data.pop("name", None) <NEW_LINE> self.publisher = data.pop("publisher", None) <NEW_LINE> self.total_episodes = data.pop("total_episodes", None) <NEW_LINE> self.type = data.pop("type", None) <NEW_LINE> self.uri = data.pop("uri", None) <NEW_LINE> self.episodes = list( Episode(client, episode) for episode in data.pop("episodes", {}) ) <NEW_LINE> self.__aiter_klass__ = Episode <NEW_LINE> self.__aiter_fetch__ = partial( self.__client.http.get_shows_episodes, self.id, limit=50 ) <NEW_LINE> <DEDENT> def __repr__(self) -> str: <NEW_LINE> <INDENT> return f"<spotify.Show: {self.name!r}>" <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return self.id | A Spotify Show Object.
Attributes
----------
id : :class:`str`
The Spotify ID for the show.
copyrights : List[Dict]
The copyright statements of the show.
description : :class:`str`
The show description.
languages : :class:`str`
The languages that show is available to listen.
duration : int
The show length in milliseconds.
explicit : bool
Whether or not the show has explicit
`True` if it does.
`False` if it does not (or unknown)
href : :class:`str`
A link to the Web API endpoint providing full details of the episodes.
images : List[Image]
The images of the show.
available_markets : List[:class:`str`]
The available markets for the show.
url : :class:`str`
The open.spotify URL.
name : :class:`str`
The name of the show.
type : :class:`str`
The type of the show.
uri : :class:`str`
The Spotify URI for the show.
total_episodes : :class:`int`
The number of total episodes.
media_type : :class:`string`
The media type to of the show.
externally_hosted : :class:`bool`
Whether or not the show is externally hosted or not.
`True` if it does.
`False` if it does not (or unknown)
publisher: :class:`str`
The publisher of the show.
episodes: :class:`List[spotify.Episode]`
A list of episodes. | 62599098283ffb24f3cf5659 |
class UserDatabase(ed.Database): <NEW_LINE> <INDENT> def __init__(self, **kwargs): <NEW_LINE> <INDENT> ed.Database.__init__(self, 'Users', User, **kwargs) <NEW_LINE> <DEDENT> def check_for_ip(self, ip, port): <NEW_LINE> <INDENT> user = self.get_entry(IP=':'.join([ip, port])) <NEW_LINE> return user.UID | The UserDatabase class gives access to the saved information about users in
the SQL database | 62599098656771135c48af10 |
class ObnamPlugin(cliapp.Plugin): <NEW_LINE> <INDENT> def __init__(self, app): <NEW_LINE> <INDENT> self.app = app <NEW_LINE> <DEDENT> def disable(self): <NEW_LINE> <INDENT> pass | Base class for plugins in Obnam. | 62599098c4546d3d9def817b |
class RequiredProjectFilter(filters.BaseFilterBackend): <NEW_LINE> <INDENT> def filter_queryset(self, request, queryset, view): <NEW_LINE> <INDENT> r = request.GET or request.POST <NEW_LINE> if not r.get('project_id'): <NEW_LINE> <INDENT> project_ids = [ str(p.id) for p in models.Project.objects.get_objects( request.user).order_by('id',) ] <NEW_LINE> message = 'A project_id parameter is required.' <NEW_LINE> message += ' For example: {0}{1}?project_id={2}.'.format( settings.SERVER_URL, request.get_full_path().split('?')[0], project_ids[0] ) <NEW_LINE> message += ' Valid project_ids for username "{0}" are: {1}'.format( request.user.username, ', '.join(project_ids) ) <NEW_LINE> raise APIException(message) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> query = queryset.filter(project__id=r.get('project_id')) <NEW_LINE> return query | Filter that only allows users to see their own objects. | 625990987cff6e4e811b7804 |
class CachedStream(object): <NEW_LINE> <INDENT> @staticmethod <NEW_LINE> def from_stream(stream): <NEW_LINE> <INDENT> if stream.id not in stream_cache: <NEW_LINE> <INDENT> s = CachedStream() <NEW_LINE> s.id = stream.id <NEW_LINE> s.name = stream.name <NEW_LINE> s.parameters = [] <NEW_LINE> for p in stream.parameters: <NEW_LINE> <INDENT> s.parameters.append(CachedParameter.from_parameter(p)) <NEW_LINE> <DEDENT> stream_cache[stream.id] = s <NEW_LINE> <DEDENT> return stream_cache[stream.id] <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def from_id(stream_id): <NEW_LINE> <INDENT> if stream_id not in stream_cache: <NEW_LINE> <INDENT> stream_cache[stream_id] = CachedStream.from_stream(Stream.query.get(stream_id)) <NEW_LINE> <DEDENT> return stream_cache[stream_id] | Object to hold a cached version of the Stream DB object | 62599098be7bc26dc9252d36 |
class BaseBranchOperator(BaseOperator, SkipMixin): <NEW_LINE> <INDENT> def choose_branch(self, context: Dict) -> Union[str, Iterable[str]]: <NEW_LINE> <INDENT> raise NotImplementedError <NEW_LINE> <DEDENT> def execute(self, context: Dict): <NEW_LINE> <INDENT> branches_to_execute = self.choose_branch(context) <NEW_LINE> self.skip_all_except(context['ti'], branches_to_execute) <NEW_LINE> return branches_to_execute | This is a base class for creating operators with branching functionality,
similarly to BranchPythonOperator.
Users should subclass this operator and implement the function
`choose_branch(self, context)`. This should run whatever business logic
is needed to determine the branch, and return either the task_id for
a single task (as a str) or a list of task_ids.
The operator will continue with the returned task_id(s), and all other
tasks directly downstream of this operator will be skipped. | 62599098dc8b845886d5537d |
class LoggerPipe(threading.Thread): <NEW_LINE> <INDENT> def __init__(self, logger, level, pipe_out): <NEW_LINE> <INDENT> threading.Thread.__init__(self) <NEW_LINE> self.logger = logger <NEW_LINE> self.level = level <NEW_LINE> self.pipe_out = pipe_out <NEW_LINE> self.lock = threading.Lock() <NEW_LINE> self.condition = threading.Condition(self.lock) <NEW_LINE> self.started = False <NEW_LINE> self.finished = False <NEW_LINE> self.start() <NEW_LINE> <DEDENT> def run(self): <NEW_LINE> <INDENT> with self.lock: <NEW_LINE> <INDENT> self.started = True <NEW_LINE> self.condition.notify_all() <NEW_LINE> <DEDENT> for line in self.pipe_out: <NEW_LINE> <INDENT> self.logger.log(self.level, line.strip()) <NEW_LINE> <DEDENT> with self.lock: <NEW_LINE> <INDENT> self.finished = True <NEW_LINE> self.condition.notify_all() <NEW_LINE> <DEDENT> <DEDENT> def wait_until_started(self): <NEW_LINE> <INDENT> with self.lock: <NEW_LINE> <INDENT> while not self.started: <NEW_LINE> <INDENT> self.condition.wait() <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def wait_until_finished(self): <NEW_LINE> <INDENT> with self.lock: <NEW_LINE> <INDENT> while not self.finished: <NEW_LINE> <INDENT> self.condition.wait() <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def flush(self): <NEW_LINE> <INDENT> for handler in self.logger.handlers: <NEW_LINE> <INDENT> handler.flush() | Monitors an external program's output and sends it to a logger. | 62599098c4546d3d9def817e |
class b2Sweep(object): <NEW_LINE> <INDENT> thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') <NEW_LINE> __repr__ = _swig_repr <NEW_LINE> def Advance(self, alpha): <NEW_LINE> <INDENT> return _Box2D.b2Sweep_Advance(self, alpha) <NEW_LINE> <DEDENT> def Normalize(self): <NEW_LINE> <INDENT> return _Box2D.b2Sweep_Normalize(self) <NEW_LINE> <DEDENT> localCenter = _swig_property(_Box2D.b2Sweep_localCenter_get, _Box2D.b2Sweep_localCenter_set) <NEW_LINE> c0 = _swig_property(_Box2D.b2Sweep_c0_get, _Box2D.b2Sweep_c0_set) <NEW_LINE> c = _swig_property(_Box2D.b2Sweep_c_get, _Box2D.b2Sweep_c_set) <NEW_LINE> a0 = _swig_property(_Box2D.b2Sweep_a0_get, _Box2D.b2Sweep_a0_set) <NEW_LINE> a = _swig_property(_Box2D.b2Sweep_a_get, _Box2D.b2Sweep_a_set) <NEW_LINE> alpha0 = _swig_property(_Box2D.b2Sweep_alpha0_get, _Box2D.b2Sweep_alpha0_set) <NEW_LINE> __dir__ = _dir_filter <NEW_LINE> def __hash__(self): <NEW_LINE> <INDENT> return _Box2D.b2Sweep___hash__(self) <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return _format_repr(self) <NEW_LINE> <DEDENT> def GetTransform(self, *args): <NEW_LINE> <INDENT> return _Box2D.b2Sweep_GetTransform(self, *args) <NEW_LINE> <DEDENT> def __init__(self, **kwargs): <NEW_LINE> <INDENT> _Box2D.b2Sweep_swiginit(self,_Box2D.new_b2Sweep()) <NEW_LINE> _init_kwargs(self, **kwargs) <NEW_LINE> <DEDENT> __swig_destroy__ = _Box2D.delete_b2Sweep | This describes the motion of a body/shape for TOI computation. Shapes are defined with respect to the body origin, which may no coincide with the center of mass. However, to support dynamics we must interpolate the center of mass position. | 625990985fdd1c0f98e5fd3b |
class KeystoneClient(BaseRelationClient): <NEW_LINE> <INDENT> mandatory_fields = [ "host", "port", "user_domain_name", "project_domain_name", "username", "password", "service", "keystone_db_password", "region_id", "admin_username", "admin_password", "admin_project_name", ] <NEW_LINE> def __init__(self, charm: ops.charm.CharmBase, relation_name: str): <NEW_LINE> <INDENT> super().__init__(charm, relation_name, self.mandatory_fields) <NEW_LINE> <DEDENT> @property <NEW_LINE> def host(self): <NEW_LINE> <INDENT> return self.get_data_from_app("host") <NEW_LINE> <DEDENT> @property <NEW_LINE> def port(self): <NEW_LINE> <INDENT> return self.get_data_from_app("port") <NEW_LINE> <DEDENT> @property <NEW_LINE> def user_domain_name(self): <NEW_LINE> <INDENT> return self.get_data_from_app("user_domain_name") <NEW_LINE> <DEDENT> @property <NEW_LINE> def project_domain_name(self): <NEW_LINE> <INDENT> return self.get_data_from_app("project_domain_name") <NEW_LINE> <DEDENT> @property <NEW_LINE> def username(self): <NEW_LINE> <INDENT> return self.get_data_from_app("username") <NEW_LINE> <DEDENT> @property <NEW_LINE> def password(self): <NEW_LINE> <INDENT> return self.get_data_from_app("password") <NEW_LINE> <DEDENT> @property <NEW_LINE> def service(self): <NEW_LINE> <INDENT> return self.get_data_from_app("service") <NEW_LINE> <DEDENT> @property <NEW_LINE> def keystone_db_password(self): <NEW_LINE> <INDENT> return self.get_data_from_app("keystone_db_password") <NEW_LINE> <DEDENT> @property <NEW_LINE> def region_id(self): <NEW_LINE> <INDENT> return self.get_data_from_app("region_id") <NEW_LINE> <DEDENT> @property <NEW_LINE> def admin_username(self): <NEW_LINE> <INDENT> return self.get_data_from_app("admin_username") <NEW_LINE> <DEDENT> @property <NEW_LINE> def admin_password(self): <NEW_LINE> <INDENT> return self.get_data_from_app("admin_password") <NEW_LINE> <DEDENT> @property <NEW_LINE> def admin_project_name(self): <NEW_LINE> <INDENT> return self.get_data_from_app("admin_project_name") | Requires side of a Keystone Endpoint | 6259909850812a4eaa621aaa |
class TestAddOn(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 testAddOn(self): <NEW_LINE> <INDENT> model = pyacp.models.add_on.AddOn() | AddOn unit test stubs | 62599098091ae356687069fa |
class Attack(GenericUnitCommand): <NEW_LINE> <INDENT> def __init__(self, unit, target): <NEW_LINE> <INDENT> super(Attack, self).__init__(unit, "user_attack", target) | Command class that triggers attack
@param unit: Instance of Unit
@param target: Instance of Target | 6259909850812a4eaa621aab |
class Label(Stmt): <NEW_LINE> <INDENT> def __init__(self, value: str): <NEW_LINE> <INDENT> Stmt.__init__(self) <NEW_LINE> self.value = value | Label statement | 62599098d8ef3951e32c8d41 |
class EurostatReader(_BaseReader): <NEW_LINE> <INDENT> _URL = "http://ec.europa.eu/eurostat/SDMX/diss-web/rest" <NEW_LINE> @property <NEW_LINE> def url(self): <NEW_LINE> <INDENT> if not isinstance(self.symbols, string_types): <NEW_LINE> <INDENT> raise ValueError("data name must be string") <NEW_LINE> <DEDENT> q = "{0}/data/{1}/?startperiod={2}&endperiod={3}" <NEW_LINE> return q.format(self._URL, self.symbols, self.start.year, self.end.year) <NEW_LINE> <DEDENT> @property <NEW_LINE> def dsd_url(self): <NEW_LINE> <INDENT> if not isinstance(self.symbols, string_types): <NEW_LINE> <INDENT> raise ValueError("data name must be string") <NEW_LINE> <DEDENT> return "{0}/datastructure/ESTAT/DSD_{1}".format(self._URL, self.symbols) <NEW_LINE> <DEDENT> def _read_one_data(self, url, params): <NEW_LINE> <INDENT> resp_dsd = self._get_response(self.dsd_url) <NEW_LINE> dsd = _read_sdmx_dsd(resp_dsd.content) <NEW_LINE> resp = self._get_response(url) <NEW_LINE> data = read_sdmx(resp.content, dsd=dsd) <NEW_LINE> try: <NEW_LINE> <INDENT> data.index = pd.to_datetime(data.index) <NEW_LINE> data = data.sort_index() <NEW_LINE> <DEDENT> except ValueError: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> try: <NEW_LINE> <INDENT> data = data.truncate(self.start, self.end) <NEW_LINE> <DEDENT> except TypeError: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> return data | Get data for the given name from Eurostat. | 62599098adb09d7d5dc0c324 |
class LeafDetail(generics.RetrieveUpdateDestroyAPIView): <NEW_LINE> <INDENT> serializer_class = LeafSerializer <NEW_LINE> def get_queryset(self): <NEW_LINE> <INDENT> return Leaf.objects.filter(owner=self.request.user) | Leaf Detail class | 62599098c4546d3d9def8180 |
class GELLUS(ColumnCorpus): <NEW_LINE> <INDENT> def __init__(self, base_path: Union[str, Path] = None, in_memory: bool = True): <NEW_LINE> <INDENT> if type(base_path) == str: <NEW_LINE> <INDENT> base_path: Path = Path(base_path) <NEW_LINE> <DEDENT> columns = {0: "text", 1: "ner"} <NEW_LINE> dataset_name = self.__class__.__name__.lower() <NEW_LINE> if not base_path: <NEW_LINE> <INDENT> base_path = Path(flair.cache_root) / "datasets" <NEW_LINE> <DEDENT> data_folder = base_path / dataset_name <NEW_LINE> train_file = data_folder / "train.conll" <NEW_LINE> dev_file = data_folder / "dev.conll" <NEW_LINE> test_file = data_folder / "test.conll" <NEW_LINE> if not (train_file.exists() and dev_file.exists() and test_file.exists()): <NEW_LINE> <INDENT> KaewphanCorpusHelper.download_gellus_dataset(data_folder) <NEW_LINE> nersuite_train = data_folder / "GELLUS-1.0.3" / "nersuite" / "train" <NEW_LINE> KaewphanCorpusHelper.prepare_and_save_dataset(nersuite_train, train_file) <NEW_LINE> nersuite_dev = data_folder / "GELLUS-1.0.3" / "nersuite" / "devel" <NEW_LINE> KaewphanCorpusHelper.prepare_and_save_dataset(nersuite_dev, dev_file) <NEW_LINE> nersuite_test = data_folder / "GELLUS-1.0.3" / "nersuite" / "test" <NEW_LINE> KaewphanCorpusHelper.prepare_and_save_dataset(nersuite_test, test_file) <NEW_LINE> <DEDENT> super(GELLUS, self).__init__( data_folder, columns, tag_to_bioes="ner", in_memory=in_memory ) | Original Gellus corpus containing cell line annotations.
For further information, see Kaewphan et al.:
Cell line name recognition in support of the identification of synthetic lethality in cancer from text
https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4708107/ | 62599098283ffb24f3cf5665 |
class MediaType(APIBase): <NEW_LINE> <INDENT> base = wtypes.text <NEW_LINE> type = wtypes.text <NEW_LINE> def __init__(self, base, type): <NEW_LINE> <INDENT> self.base = base <NEW_LINE> self.type = type | A media type representation. | 62599098adb09d7d5dc0c326 |
class restPlaylist(Resource): <NEW_LINE> <INDENT> def get(self, playlist_id): <NEW_LINE> <INDENT> parser = reqparse.RequestParser() <NEW_LINE> parser.add_argument('rate', type=int, help='Rate to charge for this resource') <NEW_LINE> args = parser.parse_args() <NEW_LINE> pl = Playlist.query.get(playlist_id) <NEW_LINE> data = pl.to_dict() <NEW_LINE> return make_response(jsonify(data), 200) <NEW_LINE> <DEDENT> @login_required <NEW_LINE> def delete(self, playlist_id): <NEW_LINE> <INDENT> pl = Playlist.query.get(playlist_id) <NEW_LINE> db.session.delete(pl) <NEW_LINE> db.session.commit() <NEW_LINE> data = { 'status': 'deleted'} <NEW_LINE> return make_response(jsonify(data), 200) <NEW_LINE> <DEDENT> @login_required <NEW_LINE> def put(self, playlist_id): <NEW_LINE> <INDENT> args = parser.parse_args() <NEW_LINE> playlist_id = int(max(TODOS.keys()).lstrip('todo')) + 1 <NEW_LINE> playlist_id = 'todo%i' % playlist_id <NEW_LINE> TODOS[todo_id] = {'task': args['task']} <NEW_LINE> return TODOS[playlist_id], 201 | Manage playlist | 625990983617ad0b5ee07f20 |
class Test_Function(unittest.TestCase): <NEW_LINE> <INDENT> def test_00_Function(self): <NEW_LINE> <INDENT> tests = ( (1, 1), ('2', 2), ('3', '4'), (10, 11), (100, 1000), ) <NEW_LINE> ahk.start() <NEW_LINE> ahk.ready() <NEW_LINE> add = ahk.Function('add', int, '(x, y)', 'return x + y') <NEW_LINE> for x, y in tests: <NEW_LINE> <INDENT> result = add(x, y) <NEW_LINE> expect = int(x) + int(y) <NEW_LINE> self.assertEqual(result, expect, msg="Unexpected result {0}, expected {1}!".format( result, expect)) <NEW_LINE> <DEDENT> with self.assertRaises(ValueError): <NEW_LINE> <INDENT> add('abc', 'efg') <NEW_LINE> <DEDENT> ahk.terminate() | Test ahk function wrapper object. | 62599098091ae35668706a00 |
Subsets and Splits