code
stringlengths 4
4.48k
| docstring
stringlengths 1
6.45k
| _id
stringlengths 24
24
|
|---|---|---|
class catalogSpider(Spider): <NEW_LINE> <INDENT> name = "catalog" <NEW_LINE> start_urls =["http://www.qincai.net/iohohoioh/index.html"] <NEW_LINE> _pipelines = set([ pipelines.ContentmanagementPipeline, ]) <NEW_LINE> def parse(self,response): <NEW_LINE> <INDENT> sels = response.xpath("//div[@class='rightbox']/div/ul/li[span]") <NEW_LINE> for index, industrySel in enumerate(sels): <NEW_LINE> <INDENT> if index <= 0: <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> item = IndustryItem() <NEW_LINE> item['industryName'] = industrySel.xpath("a/text()").extract()[0] <NEW_LINE> item['industryranking'] = index <NEW_LINE> item["industryurl"] = industrySel.xpath("a/@href").extract()[0] <NEW_LINE> item["industrytotal"] = industrySel.xpath("span/text()").extract()[0] <NEW_LINE> yield Request(item['industryurl'],callback=self.parseCategory,meta={'item':item}) <NEW_LINE> <DEDENT> <DEDENT> def parseCategory(self,response): <NEW_LINE> <INDENT> item = response.meta['item'] <NEW_LINE> item['categoryMember']=[] <NEW_LINE> sels = response.xpath("//div[@class='rightbox']/div/ul/li[span]") <NEW_LINE> categoryMax = len(sels)-1 <NEW_LINE> for index, categorysels in enumerate(sels): <NEW_LINE> <INDENT> if (index ==0): <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> categoryItem = CategoryItem() <NEW_LINE> categoryItem['categoryName'] = categorysels.xpath("a/text()").extract()[0].decode("utf-8", 'ignore') <NEW_LINE> categoryItem['categoryranking'] = index <NEW_LINE> categoryItem['categoryurl'] = categorysels.xpath('a/@href').extract()[0] <NEW_LINE> categoryItem['categorytotal'] = categorysels.xpath('span/text()').extract()[0] <NEW_LINE> yield Request(categoryItem['categoryurl'],callback=self.parseClassify,meta={'item':item,'categoryItem':categoryItem,'categoryMax':categoryMax}) <NEW_LINE> <DEDENT> <DEDENT> def parseClassify(self,response): <NEW_LINE> <INDENT> item = response.meta['item'] <NEW_LINE> categoryItem = response.meta['categoryItem'] <NEW_LINE> categoryMax = response.meta['categoryMax'] <NEW_LINE> categoryItem["classifyMember"] =[] <NEW_LINE> sels = response.xpath("//div[@class='rightbox']/div/ul/li[span]") <NEW_LINE> for index, classifysels in enumerate(sels): <NEW_LINE> <INDENT> if index ==0: <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> classifyItem = ClassifyItem() <NEW_LINE> classifyItem['classifyName'] = classifysels.xpath('a/text()').extract()[0].decode("utf-8", 'ignore') <NEW_LINE> classifyItem['classifyranking']= index <NEW_LINE> classifyItem['classifyurl'] = classifysels.xpath('a/@href').extract()[0] <NEW_LINE> classifyItem['classifytotal'] = classifysels.xpath('span/text()').extract()[0] <NEW_LINE> categoryItem["classifyMember"].append(classifyItem) <NEW_LINE> <DEDENT> item['categoryMember'].append(categoryItem) <NEW_LINE> if len(item['categoryMember'])==categoryMax: <NEW_LINE> <INDENT> logging.info(item) <NEW_LINE> return item | Crawl catalog information
| 6259908f55399d3f056281c1 |
class TempDirectory(File): <NEW_LINE> <INDENT> def __new__(cls): <NEW_LINE> <INDENT> return object.__new__(cls) <NEW_LINE> <DEDENT> def __init__(self): <NEW_LINE> <INDENT> File.__init__(self, mkdtemp()) <NEW_LINE> <DEDENT> def __enter__(self): <NEW_LINE> <INDENT> return self <NEW_LINE> <DEDENT> def __exit__(self, exc_type, exc_val, exc_tb): <NEW_LINE> <INDENT> from mo_threads import Thread <NEW_LINE> Thread.run("delete dir " + self.name, delete_daemon, file=self, caller_stack=get_stacktrace(1)) | A CONTEXT MANAGER FOR AN ALLOCATED, BUT UNOPENED TEMPORARY DIRECTORY
WILL BE DELETED WHEN EXITED | 6259908f8a349b6b43687f0d |
class LoginForm(FlaskForm): <NEW_LINE> <INDENT> email = StringField('Email', validators = [DataRequired()]) <NEW_LINE> password = PasswordField('Password', validators = [DataRequired()]) <NEW_LINE> submit = SubmitField('Login') | Login Form | 6259908fad47b63b2c5a94ff |
@python_2_unicode_compatible <NEW_LINE> class Category(MPTTModel): <NEW_LINE> <INDENT> name = models.CharField(max_length=64, unique=True) <NEW_LINE> description = models.TextField(null=True, blank=True) <NEW_LINE> parent = TreeForeignKey('self', null=True, blank=True, related_name='subcategories') <NEW_LINE> class MPTTMeta: <NEW_LINE> <INDENT> order_insertion_by = ['name'] <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return self.name <NEW_LINE> <DEDENT> class Meta: <NEW_LINE> <INDENT> ordering = ['name',] | Nested category model. | 6259908fd8ef3951e32c8cb4 |
class MLP(nn.Module): <NEW_LINE> <INDENT> def __init__(self, n_inputs, n_hidden, n_classes): <NEW_LINE> <INDENT> super(MLP, self).__init__() <NEW_LINE> modules = [] <NEW_LINE> for h in n_hidden: <NEW_LINE> <INDENT> lin = nn.Linear(n_inputs, h) <NEW_LINE> nn.init.normal_(lin.weight, mean=0, std=0.0001) <NEW_LINE> modules.append(lin) <NEW_LINE> modules.append(nn.ReLU()) <NEW_LINE> n_inputs = h <NEW_LINE> <DEDENT> modules.append(nn.Linear(n_inputs, n_classes)) <NEW_LINE> self.mlp_modules = nn.ModuleList(modules) <NEW_LINE> <DEDENT> def forward(self, x): <NEW_LINE> <INDENT> out = x <NEW_LINE> for _, m in enumerate(self.mlp_modules): <NEW_LINE> <INDENT> out = m(out) <NEW_LINE> <DEDENT> return out | This class implements a Multi-layer Perceptron in PyTorch.
It handles the different layers and parameters of the model.
Once initialized an MLP object can perform forward. | 6259908f099cdd3c63676251 |
class BBoxOutput(BasicIO, BasicBoundingBox, SimpleHandler): <NEW_LINE> <INDENT> def __init__(self, identifier, title=None, abstract=None, crss=None, dimensions=None, mode=MODE.NONE): <NEW_LINE> <INDENT> BasicIO.__init__(self, identifier, title, abstract) <NEW_LINE> BasicBoundingBox.__init__(self, crss, dimensions) <NEW_LINE> SimpleHandler.__init__(self, mode=mode) | Basic BoundingBox output class
| 6259908fad47b63b2c5a9501 |
class Branch(models.Model): <NEW_LINE> <INDENT> name_full = models.CharField( help_text="The full name of the branch", max_length=255, ) <NEW_LINE> name_short = models.CharField( help_text="The abbreviated name of the branch", max_length=255, ) <NEW_LINE> contact_name = models.CharField( help_text="The main contact for the branch", max_length=255, blank=True, null=True, ) <NEW_LINE> address = models.TextField( help_text="The full address of the branch", max_length=1000, blank=True, null=True, ) <NEW_LINE> phone = models.CharField( help_text="The main phone number for the branch", max_length=20, blank=True, null=True, ) <NEW_LINE> fax = models.CharField( help_text="The main fax number for the branch", max_length=20, blank=True, null=True, ) <NEW_LINE> email = models.CharField( help_text="The main email for the branch", max_length=255, blank=True, null=True, ) <NEW_LINE> logo = models.ImageField( help_text="A logo for the branch", blank=True, null=True, ) <NEW_LINE> history = HistoricalRecords() <NEW_LINE> def __str__(self): <NEW_LINE> <INDENT> return self.name_full | Details on the branch | 6259908f656771135c48ae89 |
class QueryBody(Model): <NEW_LINE> <INDENT> _validation = { 'query': {'required': True}, } <NEW_LINE> _attribute_map = { 'query': {'key': 'query', 'type': 'str'}, 'timespan': {'key': 'timespan', 'type': 'str'}, 'applications': {'key': 'applications', 'type': '[str]'}, } <NEW_LINE> def __init__(self, *, query: str, timespan: str=None, applications=None, **kwargs) -> None: <NEW_LINE> <INDENT> super(QueryBody, self).__init__(**kwargs) <NEW_LINE> self.query = query <NEW_LINE> self.timespan = timespan <NEW_LINE> self.applications = applications | The Analytics query. Learn more about the [Analytics query
syntax](https://azure.microsoft.com/documentation/articles/app-insights-analytics-reference/).
All required parameters must be populated in order to send to Azure.
:param query: Required. The query to execute.
:type query: str
:param timespan: Optional. The timespan over which to query data. This is
an ISO8601 time period value. This timespan is applied in addition to any
that are specified in the query expression.
:type timespan: str
:param applications: A list of Application IDs for cross-application
queries.
:type applications: list[str] | 6259908f099cdd3c63676252 |
class Lossable(interfaces.Lossable): <NEW_LINE> <INDENT> def loss(self, outputs, targets): <NEW_LINE> <INDENT> return 'loss(' + outputs + ', ' + targets + ')' | Implements the `Lossable` interface, to be inherited by test classes as a
mock dependency.
>>> lossable = Lossable()
>>> lossable.loss('outputs', 'targets')
'loss(outputs, targets)' | 6259908f283ffb24f3cf5551 |
class GroupViewset(SimpleHyperlinkedModelViewSet): <NEW_LINE> <INDENT> queryset = Group.objects.all() <NEW_LINE> serializer_class = SimpleGroupSerializer <NEW_LINE> model = Group | group viewset for api | 6259908fbe7bc26dc9252caf |
class User(UserMixin, db.Model): <NEW_LINE> <INDENT> __tablename__ = 'users' <NEW_LINE> id = db.Column(db.Integer, primary_key=True, autoincrement=True) <NEW_LINE> username = db.Column(db.String(50), nullable=False, unique=True) <NEW_LINE> email = db.Column(db.String(100), nullable=False, unique=True) <NEW_LINE> password_hash = db.Column(db.String(100), nullable=False) <NEW_LINE> lists = db.relationship("List", backref="users", lazy="dynamic", cascade="all, delete-orphan") <NEW_LINE> @property <NEW_LINE> def password(self): <NEW_LINE> <INDENT> raise AttributeError('password is not a readable attribute.') <NEW_LINE> <DEDENT> @password.setter <NEW_LINE> def password(self, password): <NEW_LINE> <INDENT> self.password_hash = generate_password_hash(password) <NEW_LINE> <DEDENT> def verify_password(self, password): <NEW_LINE> <INDENT> return check_password_hash(self.password_hash, password) <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return '<User: {}>'.format(self.username) | Create a User table | 625990907cff6e4e811b76f7 |
class Benchmark(FunkLoadTestCase): <NEW_LINE> <INDENT> def setUp(self): <NEW_LINE> <INDENT> self.server_url = self.conf_get('main', 'url') <NEW_LINE> <DEDENT> def test_simple(self): <NEW_LINE> <INDENT> server_url = self.server_url <NEW_LINE> if not re.match('https?://', server_url): <NEW_LINE> <INDENT> raise Exception("The `server_url` setting doesn't have a scheme.") <NEW_LINE> <DEDENT> username = self.conf_get('test_benchmark', 'username', None) <NEW_LINE> password = self.conf_get('test_benchmark', 'password', None) <NEW_LINE> if username and password: <NEW_LINE> <INDENT> self.post(self.server_url + "/api/user/login", params=[['username', username], ['password', password]], description="Login as %s" % username) <NEW_LINE> <DEDENT> nb_times = self.conf_getInt('test_benchmark', 'nb_times') <NEW_LINE> names = self.conf_get('test_benchmark', 'page_names').split(';') <NEW_LINE> for i in range(nb_times): <NEW_LINE> <INDENT> r = random.randint(0, len(names) - 1) <NEW_LINE> url = server_url + '/api/read/' + urllib.parse.quote(names[r]) <NEW_LINE> self.get(url, description='Getting %s' % names[r]) | This test uses a configuration file Benchmark.conf. | 62599090656771135c48ae8b |
class GameObject_MapObject(Structure): <NEW_LINE> <INDENT> fields = Skeleton() | GAMEOBJECT_TYPE_MAPOBJECT (14) | 62599090f9cc0f698b1c6126 |
class UserInfo(models.Model): <NEW_LINE> <INDENT> user = models.OneToOneField(User, on_delete=models.CASCADE) <NEW_LINE> slack_id = models.CharField(max_length=16) <NEW_LINE> def __str__(self): <NEW_LINE> <INDENT> return f'Username: {self.user} Slack ID: {self.slack_id}' | Model used to extend Django's base User model | 62599090283ffb24f3cf5558 |
class TimeAxis(AbstractAxis): <NEW_LINE> <INDENT> def __init__(self, begin, end, styles=[]): <NEW_LINE> <INDENT> super(TimeAxis, self).__init__( begin=begin, end=end, styles=styles) <NEW_LINE> <DEDENT> def count(self, receive): <NEW_LINE> <INDENT> foo, style = list(self._styles.items())[0] <NEW_LINE> receive(style, self.begin) <NEW_LINE> receive(style, self.end) | Abstract time axis | 62599090ec188e330fdfa568 |
class ClumperError(Exception): <NEW_LINE> <INDENT> pass | Base Exception for Clumper errors | 62599090283ffb24f3cf5559 |
class TipoDeAtributo(db.Model): <NEW_LINE> <INDENT> __tablename__ = 'TipoDeAtributo' <NEW_LINE> idTipoDeAtributo = db.Column(db.Integer, primary_key=True, nullable=False) <NEW_LINE> nombre = db.Column(db.String(45), unique=True, nullable=False) <NEW_LINE> tipoDeDato = db.Column(db.String(20), nullable=False) <NEW_LINE> detalle = db.Column(db.Integer) <NEW_LINE> descripcion = db.Column(db.String(150)) <NEW_LINE> def __init__(self, nombre=None, tipoDeDato=None, detalle=None, descripcion=None): <NEW_LINE> <INDENT> self.nombre = nombre <NEW_LINE> self.tipoDeDato = tipoDeDato <NEW_LINE> self.detalle = detalle <NEW_LINE> self.descripcion = descripcion <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return self.nombre | Modelo de Tipo de Atributo | 6259909097e22403b383cbb1 |
class Square: <NEW_LINE> <INDENT> def __init__(self, size=0): <NEW_LINE> <INDENT> self.__size = size <NEW_LINE> if not isinstance(size, int): <NEW_LINE> <INDENT> raise TypeError('size must be an integer') <NEW_LINE> <DEDENT> if size < 0: <NEW_LINE> <INDENT> raise ValueError('size must be >= 0') <NEW_LINE> <DEDENT> <DEDENT> def area(self): <NEW_LINE> <INDENT> area = self.__size * self.__size <NEW_LINE> return area | defines a square by size | 62599090dc8b845886d55273 |
class GetUserTablesMySqlTaskProperties(ProjectTaskProperties): <NEW_LINE> <INDENT> _validation = { 'task_type': {'required': True}, 'errors': {'readonly': True}, 'state': {'readonly': True}, 'commands': {'readonly': True}, 'output': {'readonly': True}, } <NEW_LINE> _attribute_map = { 'task_type': {'key': 'taskType', 'type': 'str'}, 'errors': {'key': 'errors', 'type': '[ODataError]'}, 'state': {'key': 'state', 'type': 'str'}, 'commands': {'key': 'commands', 'type': '[CommandProperties]'}, 'client_data': {'key': 'clientData', 'type': '{str}'}, 'input': {'key': 'input', 'type': 'GetUserTablesMySqlTaskInput'}, 'output': {'key': 'output', 'type': '[GetUserTablesMySqlTaskOutput]'}, } <NEW_LINE> def __init__( self, *, client_data: Optional[Dict[str, str]] = None, input: Optional["GetUserTablesMySqlTaskInput"] = None, **kwargs ): <NEW_LINE> <INDENT> super(GetUserTablesMySqlTaskProperties, self).__init__(client_data=client_data, **kwargs) <NEW_LINE> self.task_type = 'GetUserTablesMySql' <NEW_LINE> self.input = input <NEW_LINE> self.output = None | Properties for the task that collects user tables for the given list of databases.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param task_type: Required. Task type.Constant filled by server.
:type task_type: str
:ivar errors: Array of errors. This is ignored if submitted.
:vartype errors: list[~azure.mgmt.datamigration.models.ODataError]
:ivar state: The state of the task. This is ignored if submitted. Possible values include:
"Unknown", "Queued", "Running", "Canceled", "Succeeded", "Failed", "FailedInputValidation",
"Faulted".
:vartype state: str or ~azure.mgmt.datamigration.models.TaskState
:ivar commands: Array of command properties.
:vartype commands: list[~azure.mgmt.datamigration.models.CommandProperties]
:param client_data: Key value pairs of client data to attach meta data information to task.
:type client_data: dict[str, str]
:param input: Task input.
:type input: ~azure.mgmt.datamigration.models.GetUserTablesMySqlTaskInput
:ivar output: Task output. This is ignored if submitted.
:vartype output: list[~azure.mgmt.datamigration.models.GetUserTablesMySqlTaskOutput] | 62599090d8ef3951e32c8cba |
class Provider(BaseProvider): <NEW_LINE> <INDENT> vat_id_formats = ( 'LU########', ) <NEW_LINE> def vat_id(self): <NEW_LINE> <INDENT> return self.bothify(self.random_element(self.vat_id_formats)) | A Faker provider for the Luxembourgish VAT IDs | 62599090656771135c48ae8e |
class AlphaComputerPlayer(ComputerPlayer): <NEW_LINE> <INDENT> def __init__(self, name="", level=1): <NEW_LINE> <INDENT> super().__init__(name, level) <NEW_LINE> <DEDENT> def play(self, plateau): <NEW_LINE> <INDENT> score, column = self.max_c(plateau, self.level, inf) <NEW_LINE> return column <NEW_LINE> <DEDENT> def min_c(self, plateau, depth, alpha): <NEW_LINE> <INDENT> if depth == 0: <NEW_LINE> <INDENT> return (self.assess(plateau),0) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> score_min = inf <NEW_LINE> column_min = 0 <NEW_LINE> for j in range(7): <NEW_LINE> <INDENT> if plateau.canPlayColumn(j): <NEW_LINE> <INDENT> plateau.play(j, self.getOpponentId()) <NEW_LINE> if plateau.connectsFour(self.getOpponentId()): <NEW_LINE> <INDENT> plateau.unPlay(j) <NEW_LINE> return (-inf, j) <NEW_LINE> <DEDENT> score, temp = self.max_c(plateau, depth-1, score_min) <NEW_LINE> plateau.unPlay(j) <NEW_LINE> if score <= score_min: <NEW_LINE> <INDENT> score_min = score <NEW_LINE> column_min = j <NEW_LINE> if score < alpha: <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> <DEDENT> <DEDENT> return (score_min, column_min) <NEW_LINE> <DEDENT> def max_c(self, plateau, depth, alpha): <NEW_LINE> <INDENT> if depth == 0: <NEW_LINE> <INDENT> return (self.assess(plateau),0) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> score_max = -inf <NEW_LINE> column_max = 0 <NEW_LINE> for j in range(7): <NEW_LINE> <INDENT> if plateau.canPlayColumn(j): <NEW_LINE> <INDENT> plateau.play(j, self.id) <NEW_LINE> if plateau.connectsFour(self.id): <NEW_LINE> <INDENT> plateau.unPlay(j) <NEW_LINE> return (inf, j) <NEW_LINE> <DEDENT> score, temp = self.min_c(plateau, depth-1, score_max) <NEW_LINE> plateau.unPlay(j) <NEW_LINE> if score >= score_max: <NEW_LINE> <INDENT> score_max = score <NEW_LINE> column_max = j <NEW_LINE> if score > alpha: <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> <DEDENT> if depth == self.level and score_max == -inf: <NEW_LINE> <INDENT> if self.level > 1: <NEW_LINE> <INDENT> return self.max_c(plateau, self.level-1, inf) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> return (score_max, column_max) | This class implements the alpha-beta pruning algorithm to make mini-max
computationally more efficient | 6259909060cbc95b06365bc5 |
class AvailableServicesDataUpdater: <NEW_LINE> <INDENT> def perform_update(self,entities_type, content): <NEW_LINE> <INDENT> AvailableService.clean() <NEW_LINE> for s in content: <NEW_LINE> <INDENT> service = AvailableService(s) <NEW_LINE> service.save() | The AvailableServicesDataUpdater class implements the operations
for updating the available service collection | 6259909055399d3f056281cf |
class Renderer(object): <NEW_LINE> <INDENT> __metaclass__ = abc.ABCMeta <NEW_LINE> def __init__(self, out=None, title=None, width=80): <NEW_LINE> <INDENT> self._font = 0 <NEW_LINE> self._out = out or log.out <NEW_LINE> self._title = title <NEW_LINE> self._width = width <NEW_LINE> <DEDENT> def Entities(self, buf): <NEW_LINE> <INDENT> return buf <NEW_LINE> <DEDENT> def Escape(self, buf): <NEW_LINE> <INDENT> return buf <NEW_LINE> <DEDENT> def Finish(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def Font(self, unused_attr, unused_out=None): <NEW_LINE> <INDENT> return '' <NEW_LINE> <DEDENT> def Link(self, target, text): <NEW_LINE> <INDENT> if text: <NEW_LINE> <INDENT> if target and '://' in target: <NEW_LINE> <INDENT> return '{0} ({1})'.format(text, target) <NEW_LINE> <DEDENT> return text <NEW_LINE> <DEDENT> if target: <NEW_LINE> <INDENT> return target <NEW_LINE> <DEDENT> return '[]()' | Markdown renderer base class.
The member functions provide an abstract document model that matches markdown
entities to output document renderings.
Attributes:
_font: The font attribute bitmask.
_out: The output stream.
_title: The document tile.
_width: The output width in characters. | 625990903617ad0b5ee07e0c |
class ExportTrack(bpy.types.Operator): <NEW_LINE> <INDENT> bl_idname = "wm.export_track_pos_only" <NEW_LINE> bl_label = "export track" <NEW_LINE> def execute(self, context): <NEW_LINE> <INDENT> export_track(context) <NEW_LINE> return {'FINISHED'} | Tooltip | 62599090be7bc26dc9252cb3 |
class Cuirass(item.Equippable): <NEW_LINE> <INDENT> pass | whoops I forgot the target | 62599090dc8b845886d55277 |
class Piece: <NEW_LINE> <INDENT> def __init__(self, position, color): <NEW_LINE> <INDENT> self.posn = position <NEW_LINE> self.color = color <NEW_LINE> <DEDENT> def move(self, posn_2): <NEW_LINE> <INDENT> print("Invalid move.") | Piece Superclass. All piece objects inherit the Piece class | 62599090d8ef3951e32c8cbc |
class Cabinet(models.Model): <NEW_LINE> <INDENT> idc = models.ForeignKey(IDC, verbose_name='所在机房') <NEW_LINE> name = models.CharField(max_length=255, null=False, verbose_name='机柜名称') <NEW_LINE> class Meta: <NEW_LINE> <INDENT> db_table = 'resources_cabint' <NEW_LINE> ordering = ['id'] <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return self.name | 机柜. | 62599090adb09d7d5dc0c219 |
class RequestTestResponse(BaseResponse): <NEW_LINE> <INDENT> def __init__(self, response, status, headers): <NEW_LINE> <INDENT> BaseResponse.__init__(self, response, status, headers) <NEW_LINE> self.body_data = pickle.loads(self.get_data()) <NEW_LINE> <DEDENT> def __getitem__(self, key): <NEW_LINE> <INDENT> return self.body_data[key] | Subclass of the normal response class we use to test response
and base classes. Has some methods to test if things in the
response match. | 6259909060cbc95b06365bc7 |
class ordering(enum.IntEnum): <NEW_LINE> <INDENT> forwards = 0 <NEW_LINE> backwards = 1 | ordering for compounded_ex
| 62599090283ffb24f3cf555f |
class LSM303(object): <NEW_LINE> <INDENT> def __init__(self, hires=True, accel_address=LSM303_ADDRESS_ACCEL, mag_address=LSM303_ADDRESS_MAG, i2c=None, **kwargs): <NEW_LINE> <INDENT> if i2c is None: <NEW_LINE> <INDENT> import libraries.Adafruit_GPIO.I2C as I2C <NEW_LINE> i2c = I2C <NEW_LINE> <DEDENT> self._accel = i2c.get_i2c_device(accel_address, **kwargs) <NEW_LINE> self._mag = i2c.get_i2c_device(mag_address, **kwargs) <NEW_LINE> self._accel.write8(LSM303_REGISTER_ACCEL_CTRL_REG1_A, 0x27) <NEW_LINE> if hires: <NEW_LINE> <INDENT> self._accel.write8(LSM303_REGISTER_ACCEL_CTRL_REG4_A, 0b00001000) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self._accel.write8(LSM303_REGISTER_ACCEL_CTRL_REG4_A, 0) <NEW_LINE> <DEDENT> self._mag.write8(LSM303_REGISTER_MAG_MR_REG_M, 0x00) <NEW_LINE> <DEDENT> def read(self): <NEW_LINE> <INDENT> accel_raw = self._accel.readList(LSM303_REGISTER_ACCEL_OUT_X_L_A | 0x80, 6) <NEW_LINE> accel = struct.unpack('<hhh', accel_raw) <NEW_LINE> accel = (accel[0] >> 4, accel[1] >> 4, accel[2] >> 4) <NEW_LINE> mag_raw = self._mag.readList(LSM303_REGISTER_MAG_OUT_X_H_M, 6) <NEW_LINE> mag = struct.unpack('>hhh', mag_raw) <NEW_LINE> return (accel, mag) <NEW_LINE> <DEDENT> def set_mag_gain(self, gain=LSM303_MAGGAIN_1_3): <NEW_LINE> <INDENT> self._mag.write8(LSM303_REGISTER_MAG_CRB_REG_M, gain) | LSM303 accelerometer & magnetometer. | 625990903617ad0b5ee07e10 |
class PreferencesModule(PgAdminModule): <NEW_LINE> <INDENT> def get_own_javascripts(self): <NEW_LINE> <INDENT> return [{ 'name': 'pgadmin.preferences', 'path': url_for('preferences.index') + 'preferences', 'when': None }] <NEW_LINE> <DEDENT> def get_own_stylesheets(self): <NEW_LINE> <INDENT> return [] <NEW_LINE> <DEDENT> def get_own_menuitems(self): <NEW_LINE> <INDENT> return { 'file_items': [ MenuItem(name='mnu_preferences', priority=999, module="pgAdmin.Preferences", callback='show', icon='fa fa-cog', label=gettext('Preferences')) ] } <NEW_LINE> <DEDENT> def get_exposed_url_endpoints(self): <NEW_LINE> <INDENT> return [ 'preferences.index', 'preferences.get_by_name', 'preferences.get_all' ] | PreferenceModule represets the preferences of different modules to the
user in UI.
And, allows the user to modify (not add/remove) as per their requirement. | 62599090dc8b845886d55279 |
class Description(pygame.sprite.Sprite): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> pygame.sprite.Sprite.__init__(self) <NEW_LINE> self.dart = pygame.image.load("sprites/descriptions/dart.png").convert() <NEW_LINE> self.tack = pygame.image.load("sprites/descriptions/tack.png").convert() <NEW_LINE> self.ice = pygame.image.load("sprites/descriptions/ice.png").convert() <NEW_LINE> self.bomb = pygame.image.load("sprites/descriptions/bomb.png").convert() <NEW_LINE> self.superr = pygame.image.load("sprites/descriptions/super.png").convert() <NEW_LINE> self.images = [self.dart, self.tack, self.ice, self.bomb, self.superr] <NEW_LINE> self.image = self.dart <NEW_LINE> self.towerType = 1 <NEW_LINE> self.rect = self.image.get_rect() <NEW_LINE> self.rect.left = 800 <NEW_LINE> self.rect.top = 165 <NEW_LINE> <DEDENT> def setVisible(self, visible): <NEW_LINE> <INDENT> if visible: <NEW_LINE> <INDENT> self.rect.left = 488 <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.rect.left = 800 <NEW_LINE> <DEDENT> <DEDENT> def setImage(self, towerType): <NEW_LINE> <INDENT> self.towerType = towerType <NEW_LINE> self.image = self.images[towerType-1] | This class defines the sprite for the tower description class. | 62599090099cdd3c6367625a |
class RogueBoxOptions: <NEW_LINE> <INDENT> def __init__(self, game_exe_path=None, rogue_options=RogueOptions(), max_step_count=500, episodes_for_evaluation=200, evaluator=None, state_generator="Dummy_StateGenerator", reward_generator="Dummy_RewardGenerator", transform_descent_action=False, refresh_after_commands=True, start_game=False, move_rogue=False, busy_wait_seconds=0.0005, max_busy_wait_seconds=5): <NEW_LINE> <INDENT> self.game_exe_path = game_exe_path <NEW_LINE> self.rogue_options = rogue_options <NEW_LINE> self.max_step_count = max_step_count <NEW_LINE> self.episodes_for_evaluation = episodes_for_evaluation <NEW_LINE> self.evaluator = evaluator <NEW_LINE> self.state_generator = state_generator <NEW_LINE> self.reward_generator = reward_generator <NEW_LINE> self.transform_descent_action = transform_descent_action <NEW_LINE> self.refresh_after_commands = refresh_after_commands <NEW_LINE> self.start_game = start_game <NEW_LINE> self.move_rogue = move_rogue <NEW_LINE> self.busy_wait_seconds = busy_wait_seconds <NEW_LINE> self.max_busy_wait_seconds = max_busy_wait_seconds | RogueBox options class | 62599090f9cc0f698b1c612c |
class BetaHelloServiceStub(object): <NEW_LINE> <INDENT> def SayHello(self, request, timeout, metadata=None, with_call=False, protocol_options=None): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> SayHello.future = None <NEW_LINE> def SayHelloStrict(self, request, timeout, metadata=None, with_call=False, protocol_options=None): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> SayHelloStrict.future = None | The Beta API is deprecated for 0.15.0 and later.
It is recommended to use the GA API (classes and functions in this
file not marked beta) for all further purposes. This class was generated
only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0. | 625990904a966d76dd5f0ba7 |
class URL_Fuzzer: <NEW_LINE> <INDENT> def __init__(self, host): <NEW_LINE> <INDENT> if type(host) is Host: <NEW_LINE> <INDENT> self.host = host <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise ValueError("wrong type for attribute host!") <NEW_LINE> <DEDENT> Logger.info("fuzzing url", self.host.getURL()) <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def __spiderworker__(content): <NEW_LINE> <INDENT> rootURL = content.getURL() <NEW_LINE> newContent = Content(rootURL) <NEW_LINE> newContent.setContentType(content.getContentType()) <NEW_LINE> newContent.setStatus(content.getStatus()) <NEW_LINE> if content.getStatus() in URL.GOOD_STATUS: <NEW_LINE> <INDENT> if ('text' in content.getContentType() or 'script' in content.getContentType()): <NEW_LINE> <INDENT> refs = WebApi.grabRefs(content.getContent()) <NEW_LINE> urls =[] <NEW_LINE> for ref in refs: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> url = URL.prettifyURL(rootURL,ref) <NEW_LINE> urls.append(url) <NEW_LINE> <DEDENT> except ValueError: <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> <DEDENT> newContent.setContentType("linklist") <NEW_LINE> newContent.setContent(urls) <NEW_LINE> <DEDENT> <DEDENT> return newContent <NEW_LINE> <DEDENT> def spider(self): <NEW_LINE> <INDENT> Logger.info("Spidering URL", self.host.getURL()) <NEW_LINE> toProceed=[] <NEW_LINE> doneURLs=[] <NEW_LINE> rootcontent = Content(self.host.getURL()) <NEW_LINE> rootcontent.setProcessor(URL_Fuzzer.__spiderworker__) <NEW_LINE> toProceed.append(rootcontent) <NEW_LINE> for i in range(0, Settings.readAttribute("recursion_depth",0)): <NEW_LINE> <INDENT> for a in range(0,len(toProceed)): <NEW_LINE> <INDENT> content = toProceed.pop() <NEW_LINE> Content_Worker.queue.put(content) <NEW_LINE> <DEDENT> Logger.info('Processing recursion', i, Content_Worker.queue.qsize(), 'task(s) to be done') <NEW_LINE> Content_Worker.queue.join() <NEW_LINE> Logger.info(Content_Worker.done.qsize(),"result(s) to analyze") <NEW_LINE> while not Content_Worker.done.empty(): <NEW_LINE> <INDENT> content = Content_Worker.done.get() <NEW_LINE> Content_Worker.done.task_done() <NEW_LINE> if content.getContentType() != "linklist": <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> urls = content.getContent() <NEW_LINE> for url in urls: <NEW_LINE> <INDENT> path = url.getPath() <NEW_LINE> if self.host.isExternal(url) or url.getURL() in doneURLs or len(path) == 0: <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> doneURLs.append(url.getURL()) <NEW_LINE> length = content.getSize() <NEW_LINE> self.host.getRootdir().appendPath(path, length) <NEW_LINE> newContent = Content(url) <NEW_LINE> newContent.setProcessor(URL_Fuzzer.__spiderworker__) <NEW_LINE> toProceed.append(newContent) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> print(self.host.getRootdir()) <NEW_LINE> Logger.info("spidering completed") <NEW_LINE> <DEDENT> def fuzz(self): <NEW_LINE> <INDENT> Logger.info("fuzzing URL", self.host.getURL()) <NEW_LINE> Logger.info("fuzzing completed") | class to perform spidering and fuzzing tasks | 6259909097e22403b383cbbb |
@attr.s(slots=True, auto_attribs=True, kw_only=True) <NEW_LINE> class PopupMenu(): <NEW_LINE> <INDENT> title: str <NEW_LINE> contents: List[PopupChoice] = attr.Factory(list) <NEW_LINE> x: int = 10 <NEW_LINE> y: int = 5 <NEW_LINE> w: int = map.w - 20 <NEW_LINE> h: int = map.h - 10 <NEW_LINE> auto_close: bool = True <NEW_LINE> include_description: Any = None <NEW_LINE> include_esc: bool = True <NEW_LINE> reveal_all: bool = True | This contains the input and render information for a popup menu. | 6259909060cbc95b06365bca |
class CommonTests: <NEW_LINE> <INDENT> def setUp(self): <NEW_LINE> <INDENT> self.backend = None <NEW_LINE> raise NotImplementedError() <NEW_LINE> <DEDENT> def test_check_backend(self): <NEW_LINE> <INDENT> self.assertTrue(self.backend.check_backend()) <NEW_LINE> <DEDENT> @pytest.mark.usefixtures("mac") <NEW_LINE> def test_scan(self): <NEW_LINE> <INDENT> if not self.backend.supports_scanning(): <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> devices = self.backend.scan_for_devices(timeout=7) <NEW_LINE> mac_list = [d[0].lower() for d in devices] <NEW_LINE> self.assertIn(self.mac.lower(), mac_list) <NEW_LINE> <DEDENT> @pytest.mark.usefixtures("mac") <NEW_LINE> def test_connect(self): <NEW_LINE> <INDENT> self.backend.connect(self.mac) <NEW_LINE> self.backend.disconnect() <NEW_LINE> <DEDENT> @pytest.mark.usefixtures("mac") <NEW_LINE> def test_read_0x38(self): <NEW_LINE> <INDENT> self.backend.connect(self.mac) <NEW_LINE> result = self.backend.read_handle(0x38) <NEW_LINE> self.assertIsNotNone(result) <NEW_LINE> self.assertGreater(len(result), 5) | Base class for integration tests | 625990905fdd1c0f98e5fc3c |
class ShowcaseDownloadPolicy(bb.Union): <NEW_LINE> <INDENT> _catch_all = 'other' <NEW_LINE> disabled = None <NEW_LINE> enabled = None <NEW_LINE> other = None <NEW_LINE> def is_disabled(self): <NEW_LINE> <INDENT> return self._tag == 'disabled' <NEW_LINE> <DEDENT> def is_enabled(self): <NEW_LINE> <INDENT> return self._tag == 'enabled' <NEW_LINE> <DEDENT> def is_other(self): <NEW_LINE> <INDENT> return self._tag == 'other' <NEW_LINE> <DEDENT> def _process_custom_annotations(self, annotation_type, processor): <NEW_LINE> <INDENT> super(ShowcaseDownloadPolicy, self)._process_custom_annotations(annotation_type, processor) <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return 'ShowcaseDownloadPolicy(%r, %r)' % (self._tag, self._value) | This class acts as a tagged union. Only one of the ``is_*`` methods will
return true. To get the associated value of a tag (if one exists), use the
corresponding ``get_*`` method.
:ivar disabled: Do not allow files to be downloaded from Showcases.
:ivar enabled: Allow files to be downloaded from Showcases. | 6259909050812a4eaa621a29 |
class Player: <NEW_LINE> <INDENT> def __init__(self, name, hand): <NEW_LINE> <INDENT> self.name = name <NEW_LINE> self.hand = hand <NEW_LINE> <DEDENT> def play_card(self): <NEW_LINE> <INDENT> drawn_card = self.hand.remove_cards() <NEW_LINE> print("{} has placed: {}".format(self.name, drawn_card)) <NEW_LINE> print("\n") <NEW_LINE> return drawn_card <NEW_LINE> <DEDENT> def remove_war_cards(self): <NEW_LINE> <INDENT> war_cards = [] <NEW_LINE> if len(self.hand.cards)<3: <NEW_LINE> <INDENT> return self.hand.cards <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> for x in range(3): <NEW_LINE> <INDENT> war_cards.append(self.hand.remove_cards) <NEW_LINE> <DEDENT> return war_cards <NEW_LINE> <DEDENT> <DEDENT> def still_has_cards(self): <NEW_LINE> <INDENT> return len(self.hand.cards) != 0 | This is the Player class, which takes in a name and an instance of a Hand class object. The Player can play cards and check if they still have cards. | 625990907cff6e4e811b7709 |
class set_hadoop_config_args: <NEW_LINE> <INDENT> thrift_spec = ( None, (1, TType.STRING, 'request', None, None, ), ) <NEW_LINE> def __init__(self, request=None,): <NEW_LINE> <INDENT> self.request = request <NEW_LINE> <DEDENT> def read(self, iprot): <NEW_LINE> <INDENT> if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: <NEW_LINE> <INDENT> fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) <NEW_LINE> return <NEW_LINE> <DEDENT> iprot.readStructBegin() <NEW_LINE> while True: <NEW_LINE> <INDENT> (fname, ftype, fid) = iprot.readFieldBegin() <NEW_LINE> if ftype == TType.STOP: <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> if fid == 1: <NEW_LINE> <INDENT> if ftype == TType.STRING: <NEW_LINE> <INDENT> self.request = iprot.readString(); <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> iprot.skip(ftype) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> iprot.skip(ftype) <NEW_LINE> <DEDENT> iprot.readFieldEnd() <NEW_LINE> <DEDENT> iprot.readStructEnd() <NEW_LINE> <DEDENT> def write(self, oprot): <NEW_LINE> <INDENT> if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: <NEW_LINE> <INDENT> oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) <NEW_LINE> return <NEW_LINE> <DEDENT> oprot.writeStructBegin('set_hadoop_config_args') <NEW_LINE> if self.request is not None: <NEW_LINE> <INDENT> oprot.writeFieldBegin('request', TType.STRING, 1) <NEW_LINE> oprot.writeString(self.request) <NEW_LINE> oprot.writeFieldEnd() <NEW_LINE> <DEDENT> oprot.writeFieldStop() <NEW_LINE> oprot.writeStructEnd() <NEW_LINE> <DEDENT> def validate(self): <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> def __hash__(self): <NEW_LINE> <INDENT> value = 17 <NEW_LINE> value = (value * 31) ^ hash(self.request) <NEW_LINE> return value <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> L = ['%s=%r' % (key, value) for key, value in self.__dict__.iteritems()] <NEW_LINE> return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) <NEW_LINE> <DEDENT> def __eq__(self, other): <NEW_LINE> <INDENT> return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ <NEW_LINE> <DEDENT> def __ne__(self, other): <NEW_LINE> <INDENT> return not (self == other) | Attributes:
- request | 62599090656771135c48ae94 |
class EmailValidation(models.Model): <NEW_LINE> <INDENT> username = models.CharField(max_length=30, unique=True) <NEW_LINE> email = models.EmailField(verbose_name=_('E-mail')) <NEW_LINE> password = models.CharField(max_length=30) <NEW_LINE> key = models.CharField(max_length=70, unique=True, db_index=True) <NEW_LINE> created = models.DateTimeField(auto_now_add=True) <NEW_LINE> objects = EmailValidationManager() <NEW_LINE> class Meta: <NEW_LINE> <INDENT> ordering = ['username', 'created'] <NEW_LINE> verbose_name = _("Email Validation") <NEW_LINE> verbose_name_plural = _("Email Validations") <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return _("Email validation process for %(user)s") % {'user': self.username} <NEW_LINE> <DEDENT> def is_expired(self): <NEW_LINE> <INDENT> return (now() - self.created).days > 7 <NEW_LINE> <DEDENT> def resend(self): <NEW_LINE> <INDENT> template_body = "email/validation.txt" <NEW_LINE> template_subject = "email/validation_subject.txt" <NEW_LINE> site_name, domain = Site.objects.get_current().name, Site.objects.get_current().domain <NEW_LINE> key = self.key <NEW_LINE> body = loader.get_template(template_body).render(Context(locals())) <NEW_LINE> subject = loader.get_template(template_subject) <NEW_LINE> subject = subject.render(Context(locals())).strip() <NEW_LINE> try: <NEW_LINE> <INDENT> send_mail(subject=subject, message=body, from_email=None, recipient_list=[self.email]) <NEW_LINE> <DEDENT> except: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> self.created = now() <NEW_LINE> self.save() <NEW_LINE> return True | Email Validation model | 62599090adb09d7d5dc0c221 |
class ProfileForms(messages.Message): <NEW_LINE> <INDENT> items = messages.MessageField(ProfileForm, 1, repeated=True) | ProfileForms -- multiple Profile outbound form messages | 625990903617ad0b5ee07e18 |
class DocumentReference(Base): <NEW_LINE> <INDENT> __tablename__ = 'document_reference' <NEW_LINE> __table_args__ = {'schema': 'forest_distance_lines'} <NEW_LINE> id = sa.Column(sa.String, primary_key=True, autoincrement=False) <NEW_LINE> document_id = sa.Column( sa.String, sa.ForeignKey(Document.id), nullable=False ) <NEW_LINE> reference_document_id = sa.Column( sa.String, sa.ForeignKey(Document.id), nullable=False ) <NEW_LINE> document = relationship( Document, backref='referenced_documents', foreign_keys=[document_id] ) <NEW_LINE> referenced_document = relationship( Document, foreign_keys=[reference_document_id] ) <NEW_LINE> article_numbers = sa.Column(sa.String, nullable=True) <NEW_LINE> liefereinheit = sa.Column(sa.Integer, nullable=True) | Meta bucket (join table) for the relationship between documents.
Attributes:
id (int): The identifier. This is used in the database only and must not be set manually. If
you don't like it - don't care about.
document_id (int): The foreign key to the document which references to another document.
reference_document_id (int): The foreign key to the document which is referenced.
document (pyramid_oereb.standard.models.forest_distance_lines.Document):
The dedicated relation to the document (which references) instance from database.
referenced_document (pyramid_oereb.standard.models.forest_distance_lines.Document):
The dedicated relation to the document (which is referenced) instance from database.
article_numbers (str): A colon of article numbers which clarify the reference. This is a
string separated by '|'. | 62599090a05bb46b3848bf88 |
class PySmear2D(object): <NEW_LINE> <INDENT> def __init__(self, data=None, model=None): <NEW_LINE> <INDENT> self.data = data <NEW_LINE> self.model = model <NEW_LINE> self.accuracy = 'Low' <NEW_LINE> self.limit = 3.0 <NEW_LINE> self.index = None <NEW_LINE> self.coords = 'polar' <NEW_LINE> self.smearer = True <NEW_LINE> <DEDENT> def set_accuracy(self, accuracy='Low'): <NEW_LINE> <INDENT> self.accuracy = accuracy <NEW_LINE> <DEDENT> def set_smearer(self, smearer=True): <NEW_LINE> <INDENT> self.smearer = smearer <NEW_LINE> <DEDENT> def set_data(self, data=None): <NEW_LINE> <INDENT> self.data = data <NEW_LINE> <DEDENT> def set_model(self, model=None): <NEW_LINE> <INDENT> self.model = model <NEW_LINE> <DEDENT> def set_index(self, index=None): <NEW_LINE> <INDENT> self.index = index <NEW_LINE> <DEDENT> def get_value(self): <NEW_LINE> <INDENT> if self.smearer: <NEW_LINE> <INDENT> res = Pinhole2D(data=self.data, index=self.index, nsigma=3.0, accuracy=self.accuracy, coords=self.coords) <NEW_LINE> val = self.model.evalDistribution(res.q_calc) <NEW_LINE> return res.apply(val) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> index = self.index if self.index is not None else slice(None) <NEW_LINE> qx_data = self.data.qx_data[index] <NEW_LINE> qy_data = self.data.qy_data[index] <NEW_LINE> q_calc = [qx_data, qy_data] <NEW_LINE> val = self.model.evalDistribution(q_calc) <NEW_LINE> return val | Q smearing class for SAS 2d pinhole data | 62599090bf627c535bcb319b |
class PolicyGradient(object): <NEW_LINE> <INDENT> def __init__(self, lr=None): <NEW_LINE> <INDENT> self.lr = lr <NEW_LINE> <DEDENT> def learn(self, act_prob, action, reward, length=None): <NEW_LINE> <INDENT> self.reward = fluid.layers.py_func( func=reward_func, x=[action, length], out=reward) <NEW_LINE> neg_log_prob = layers.cross_entropy(act_prob, action) <NEW_LINE> cost = neg_log_prob * reward <NEW_LINE> cost = (layers.reduce_sum(cost) / layers.reduce_sum(length) ) if length is not None else layers.reduce_mean(cost) <NEW_LINE> optimizer = fluid.optimizer.Adam(self.lr) <NEW_LINE> optimizer.minimize(cost) <NEW_LINE> return cost | policy gradient | 6259909050812a4eaa621a2a |
class _Data(object): <NEW_LINE> <INDENT> def __init__(self, workspace): <NEW_LINE> <INDENT> self.workspace = workspace <NEW_LINE> self.settings = {"title" : "Test Report", "summary" : "",} <NEW_LINE> self.data_testsuites = {} <NEW_LINE> for dut in self.workspace.duts(): <NEW_LINE> <INDENT> dut_info = {} <NEW_LINE> dut_info["ip"] = dut.ip <NEW_LINE> dut_info["name"] = dut.name <NEW_LINE> for testsuite in dut.testsuites(): <NEW_LINE> <INDENT> if testsuite.name in self.data_testsuites: <NEW_LINE> <INDENT> self.data_testsuites[testsuite.name].merge(testsuite, dut_info) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.data_testsuites[testsuite.name] = _DataTestSuite(testsuite, dut_info, self) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> <DEDENT> def config(self, **kwargs): <NEW_LINE> <INDENT> for key in kwargs: <NEW_LINE> <INDENT> if key in self.settings: <NEW_LINE> <INDENT> self.settings[key] = kwargs[key] <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> @property <NEW_LINE> def title(self): <NEW_LINE> <INDENT> return self.settings["title"] <NEW_LINE> <DEDENT> @property <NEW_LINE> def summary(self): <NEW_LINE> <INDENT> return self.settings["summary"] <NEW_LINE> <DEDENT> @property <NEW_LINE> def duts(self): <NEW_LINE> <INDENT> for dut in self.workspace.duts(): <NEW_LINE> <INDENT> dut_info = {} <NEW_LINE> dut_info["ip"] = dut.ip <NEW_LINE> dut_info["name"] = dut.name <NEW_LINE> yield dut_info <NEW_LINE> <DEDENT> <DEDENT> @property <NEW_LINE> def testsuites(self): <NEW_LINE> <INDENT> for data_testsuite_name, data_testsuite in self.data_testsuites.items(): <NEW_LINE> <INDENT> yield data_testsuite <NEW_LINE> <DEDENT> <DEDENT> @property <NEW_LINE> def total(self): <NEW_LINE> <INDENT> total = 0 <NEW_LINE> for testsuite in self.testsuites: <NEW_LINE> <INDENT> total += testsuite.len <NEW_LINE> <DEDENT> return total <NEW_LINE> <DEDENT> @property <NEW_LINE> def passed(self): <NEW_LINE> <INDENT> passed = 0 <NEW_LINE> for testsuite in self.testsuites: <NEW_LINE> <INDENT> passed += testsuite.passed <NEW_LINE> <DEDENT> return passed <NEW_LINE> <DEDENT> @property <NEW_LINE> def failed(self): <NEW_LINE> <INDENT> failed = 0 <NEW_LINE> for testsuite in self.testsuites: <NEW_LINE> <INDENT> failed += testsuite.failed <NEW_LINE> <DEDENT> return failed <NEW_LINE> <DEDENT> @property <NEW_LINE> def NotRun(self): <NEW_LINE> <INDENT> NotRun = 0 <NEW_LINE> for testsuite in self.testsuites: <NEW_LINE> <INDENT> NotRun += testsuite.NotRun <NEW_LINE> <DEDENT> return NotRun | extract information from workspace
testsuites with same name in different dut will be merged | 62599090283ffb24f3cf5569 |
class AlignmentSetMetadataType (DataSetMetadataType): <NEW_LINE> <INDENT> _TypeDefinition = None <NEW_LINE> _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY <NEW_LINE> _Abstract = False <NEW_LINE> _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'AlignmentSetMetadataType') <NEW_LINE> _XSDLocation = pyxb.utils.utility.Location('/tmp/tmpiTHi4xxsds/PacBioDatasets.xsd', 131, 1) <NEW_LINE> _ElementMap = DataSetMetadataType._ElementMap.copy() <NEW_LINE> _AttributeMap = DataSetMetadataType._AttributeMap.copy() <NEW_LINE> __Aligner = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Aligner'), 'Aligner', '__httppacificbiosciences_comPacBioDatasets_xsd_AlignmentSetMetadataType_httppacificbiosciences_comPacBioDatasets_xsdAligner', False, pyxb.utils.utility.Location('/tmp/tmpiTHi4xxsds/PacBioDatasets.xsd', 135, 5), ) <NEW_LINE> Aligner = property(__Aligner.value, __Aligner.set, None, None) <NEW_LINE> _ElementMap.update({ __Aligner.name() : __Aligner }) <NEW_LINE> _AttributeMap.update({ }) | Complex type {http://pacificbiosciences.com/PacBioDatasets.xsd}AlignmentSetMetadataType with content type ELEMENT_ONLY | 6259909055399d3f056281dd |
class Controller(object): <NEW_LINE> <INDENT> def __init__(self, baseurl: str, username: str = None, password: str = None) -> None: <NEW_LINE> <INDENT> self._session = Session() <NEW_LINE> self._session.auth = (username, password) <NEW_LINE> self._prefix = baseurl + "/ZAutomation/api/v1" <NEW_LINE> self.devices = self.get_all_devices() <NEW_LINE> <DEDENT> def update(self): <NEW_LINE> <INDENT> self.devices = self.get_all_devices() <NEW_LINE> return True <NEW_LINE> <DEDENT> def device(self, device_id: str): <NEW_LINE> <INDENT> for device in self.devices: <NEW_LINE> <INDENT> if device.device_id == device_id: <NEW_LINE> <INDENT> return device <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def get_all_devices(self) -> List[GenericDevice]: <NEW_LINE> <INDENT> response = self._session.get(self._prefix + "/devices") <NEW_LINE> all_devices = [] <NEW_LINE> for device_dict in response.json().get('data').get('devices'): <NEW_LINE> <INDENT> if device_dict['permanently_hidden']: <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> if not device_dict['visibility']: <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> all_devices.append(create_device(device_dict, self._session, self._prefix)) <NEW_LINE> <DEDENT> return all_devices <NEW_LINE> <DEDENT> def get_device(self, device_id: str) -> GenericDevice: <NEW_LINE> <INDENT> response = self._session.get(self._prefix + "/devices/" + device_id) <NEW_LINE> device_dict = response.json().get('data') <NEW_LINE> return create_device(device_dict, self._session, self._prefix) | Z-way Controller class. | 62599090f9cc0f698b1c6130 |
class SMPacketServerNSCGON(SMPacket): <NEW_LINE> <INDENT> command = smcommand.SMServerCommand.NSCGON <NEW_LINE> _payload = [ (smencoder.SMPayloadType.INT, "nb_players", 1), (smencoder.SMPayloadType.INTLIST, "ids", (1, "nb_players")), (smencoder.SMPayloadType.INTLIST, "score", (4, "nb_players")), (smencoder.SMPayloadType.INTLIST, "grade", (1, "nb_players")), (smencoder.SMPayloadType.INTLIST, "difficulty", (1, "nb_players")), (smencoder.SMPayloadType.INTLIST, "flawless", (2, "nb_players")), (smencoder.SMPayloadType.INTLIST, "perfect", (2, "nb_players")), (smencoder.SMPayloadType.INTLIST, "great", (2, "nb_players")), (smencoder.SMPayloadType.INTLIST, "good", (2, "nb_players")), (smencoder.SMPayloadType.INTLIST, "bad", (2, "nb_players")), (smencoder.SMPayloadType.INTLIST, "miss", (2, "nb_players")), (smencoder.SMPayloadType.INTLIST, "held", (2, "nb_players")), (smencoder.SMPayloadType.INTLIST, "max_combo", (2, "nb_players")), (smencoder.SMPayloadType.NTLIST, "options", "nb_players"), ] | Server command 132 (Game over stats)
This packet is send in response to the game over packet. It
contains information regarding how well each player did.
:param int nb_players: NB of players stats in this packet (size of the next list)
:param list ids: Player's ID (calculate from the SMPacketServerNSCUUL)
:param list score: Player's score
:param list grade: Player's grade
:param list difficulty: Player's difficulty
:param list flawless: NB of flawless note
:param list perfect: NB of perfect note
:param list great: NB of great note
:param list good: NB of good note
:param list bad: NB of bad note
:param list miss: NB of miss note
:param list held: NB of held note
:param list max_combo: Player's max combo
:param list options: Player's options | 62599090283ffb24f3cf556a |
class WindowsSystemRegistryPathTest(test_lib.PreprocessPluginTest): <NEW_LINE> <INDENT> _FILE_DATA = 'regf' <NEW_LINE> def setUp(self): <NEW_LINE> <INDENT> self._fake_file_system = self._BuildSingleFileFakeFileSystem( u'/Windows/System32/config/SYSTEM', self._FILE_DATA) <NEW_LINE> mount_point = fake_path_spec.FakePathSpec(location=u'/') <NEW_LINE> self._searcher = file_system_searcher.FileSystemSearcher( self._fake_file_system, mount_point) <NEW_LINE> <DEDENT> def testGetValue(self): <NEW_LINE> <INDENT> knowledge_base_object = knowledge_base.KnowledgeBase() <NEW_LINE> plugin = windows.WindowsSystemRegistryPath() <NEW_LINE> plugin.Run(self._searcher, knowledge_base_object) <NEW_LINE> path = knowledge_base_object.GetValue('sysregistry') <NEW_LINE> self.assertEqual(path, u'/Windows/System32/config') | Tests for the Windows system Registry path preprocess plug-in object. | 62599090ad47b63b2c5a951b |
class linear_layer: <NEW_LINE> <INDENT> def __init__(self, input_D, output_D): <NEW_LINE> <INDENT> self.params = dict() <NEW_LINE> self.params['W']=np.random.normal(0,0.1,(input_D,output_D)) <NEW_LINE> self.params['b']=np.random.normal(0,0.1,(1,output_D)) <NEW_LINE> self.gradient = dict() <NEW_LINE> self.gradient['W']=np.zeros((input_D,output_D)) <NEW_LINE> self.gradient['b']=np.zeros((1,output_D)) <NEW_LINE> <DEDENT> def forward(self, X): <NEW_LINE> <INDENT> [email protected]['W'] + self.params['b'] <NEW_LINE> return forward_output <NEW_LINE> <DEDENT> def backward(self, X, grad): <NEW_LINE> <INDENT> self.gradient['W']=X.T@grad <NEW_LINE> self.gradient['b']=np.sum(grad,axis=0).reshape(1,-1) <NEW_LINE> [email protected]['W'].T <NEW_LINE> return backward_output | The linear (affine/fully-connected) module.
It is built up with two arguments:
- input_D: the dimensionality of the input example/instance of the forward pass
- output_D: the dimensionality of the output example/instance of the forward pass
It has two learnable parameters:
- self.params['W']: the W matrix (numpy array) of shape input_D-by-output_D
- self.params['b']: the b vector (numpy array) of shape 1-by-output_D
It will record the partial derivatives of loss w.r.t. self.params['W'] and self.params['b'] in:
- self.gradient['W']: input_D-by-output_D numpy array
- self.gradient['b']: 1-by-output_D numpy array | 625990908a349b6b43687f2b |
class ShowTaskList(gdb.Command): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> super(ShowTaskList, self).__init__( "show Task-List", gdb.COMMAND_SUPPORT ) <NEW_LINE> <DEDENT> def invoke(self, arg, from_tty): <NEW_LINE> <INDENT> sched = Scheduler() <NEW_LINE> sched.ShowTaskList() | Generate a print out of the current tasks and their states.
| 62599090283ffb24f3cf556c |
class ChartCacheHelper: <NEW_LINE> <INDENT> prefix = "bc:chart:cache" <NEW_LINE> def __init__(self): <NEW_LINE> <INDENT> self.crh = RedisHelper(prefix=ChartCacheHelper.prefix) <NEW_LINE> <DEDENT> def put(self, chart_id, data): <NEW_LINE> <INDENT> self.crh.put(chart_id, data) <NEW_LINE> <DEDENT> def get(self, chart_id): <NEW_LINE> <INDENT> return self.rh.get(chart_id) <NEW_LINE> <DEDENT> def delete(self, chart_id): <NEW_LINE> <INDENT> self.rh.delete(chart_id) <NEW_LINE> <DEDENT> def deleteN(self, chart_id): <NEW_LINE> <INDENT> self.rh.deleteN(chart_id) <NEW_LINE> <DEDENT> def flush(self): <NEW_LINE> <INDENT> self.rh.flush() | 图表数据缓存 | 62599090d8ef3951e32c8cc3 |
class SMSTotalSensor(LTESensor): <NEW_LINE> <INDENT> @property <NEW_LINE> def state(self): <NEW_LINE> <INDENT> return len(self.modem_data.data.sms) | Total SMS sensor entity. | 62599090656771135c48ae97 |
class UIHost(UINode): <NEW_LINE> <INDENT> def __init__(self, parent, host, name): <NEW_LINE> <INDENT> UINode.__init__(self, name, parent) <NEW_LINE> self._host = host <NEW_LINE> self._parent = parent <NEW_LINE> self.refresh() <NEW_LINE> <DEDENT> def refresh(self): <NEW_LINE> <INDENT> self._children = set([]) <NEW_LINE> <DEDENT> def summary(self): <NEW_LINE> <INDENT> status = self._host.status <NEW_LINE> if status == types.HostStatus.UP: <NEW_LINE> <INDENT> state = ' [UP]' <NEW_LINE> <DEDENT> elif status == types.HostStatus.MAINTENANCE: <NEW_LINE> <INDENT> state = ' [Maint.]' <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> state = '' <NEW_LINE> <DEDENT> return 'Address: %s%s' % (self._host.address, state), None <NEW_LINE> <DEDENT> def ui_command_deactivate(self): <NEW_LINE> <INDENT> self._parent.ui_command_deactivate(self._host.name) <NEW_LINE> self.refresh() <NEW_LINE> <DEDENT> def ui_command_activate(self): <NEW_LINE> <INDENT> self._parent.ui_command_activate(self._host.name) <NEW_LINE> self.refresh() | A single host object UI. | 62599090283ffb24f3cf556d |
class ProcessOperation(Operation.Operation): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> description = [ { "name": _("Point Example"), "property": "point_example", "type": "point", "default": (0.25, 0.25) }, { "name": _("Scalar Example"), "property": "scalar_example", "type": "scalar", "default": 0.3 }, { "name": _("Integer Example"), "property": "integer_example", "type": "integer-field", "default": 1 } ] <NEW_LINE> super(ProcessOperation, self).__init__(process_name, script_id, description) <NEW_LINE> self.point_example = (0.25, 0.25) <NEW_LINE> self.scalar_example = 0.3 <NEW_LINE> self.integer_example = 1 <NEW_LINE> <DEDENT> def process(self, data): <NEW_LINE> <INDENT> point_example = self.get_property("point_example") <NEW_LINE> scalar_example = self.get_property("scalar_example") <NEW_LINE> integer_example = self.get_property("integer_example") <NEW_LINE> return your_processing_function(data, point_example, scalar_example, integer_example) <NEW_LINE> <DEDENT> def get_processed_data_shape_and_dtype(self, data_shape, data_dtype): <NEW_LINE> <INDENT> return data_shape[1:], data_dtype <NEW_LINE> <DEDENT> def get_processed_spatial_calibrations(self, data_shape, data_dtype, spatial_calibrations): <NEW_LINE> <INDENT> return spatial_calibrations | A Swift plugin for you to use. | 625990904a966d76dd5f0bb1 |
class Processor: <NEW_LINE> <INDENT> def __init__(self, context): <NEW_LINE> <INDENT> self.__handlers = {} <NEW_LINE> self.__context = context <NEW_LINE> <DEDENT> @property <NEW_LINE> def context(self): <NEW_LINE> <INDENT> return self.__context <NEW_LINE> <DEDENT> def register(self, command, handler): <NEW_LINE> <INDENT> self.__handlers[command] = handler <NEW_LINE> <DEDENT> def register_handlers(self, handlers): <NEW_LINE> <INDENT> for handler in handlers: <NEW_LINE> <INDENT> self.register(handler[0], handler[1]) <NEW_LINE> <DEDENT> <DEDENT> def exec(self, command, *data): <NEW_LINE> <INDENT> if command not in self.__handlers: <NEW_LINE> <INDENT> raise Exception("No '{}' command registered".format(command)) <NEW_LINE> <DEDENT> return self.__handlers[command](self.__context, *data) | Commands processor to manipulate meeting state. | 62599090bf627c535bcb31a1 |
class OpenHumansMember(models.Model): <NEW_LINE> <INDENT> user = models.OneToOneField(User, on_delete=models.CASCADE) <NEW_LINE> oh_id = models.CharField(max_length=16, primary_key=True, unique=True) <NEW_LINE> access_token = models.CharField(max_length=256) <NEW_LINE> refresh_token = models.CharField(max_length=256) <NEW_LINE> token_expires = models.DateTimeField() <NEW_LINE> public = models.BooleanField(default=False) <NEW_LINE> @staticmethod <NEW_LINE> def get_expiration(expires_in): <NEW_LINE> <INDENT> return (arrow.now() + timedelta(seconds=expires_in)).format() <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def create(cls, oh_id, data): <NEW_LINE> <INDENT> new_username = make_unique_username( base='{}_openhumans'.format(oh_id)) <NEW_LINE> new_user = User(username=new_username) <NEW_LINE> new_user.save() <NEW_LINE> oh_member = cls( user=new_user, oh_id=oh_id, access_token=data["access_token"], refresh_token=data["refresh_token"], token_expires=cls.get_expiration(data["expires_in"])) <NEW_LINE> return oh_member <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return "<OpenHumansMember(oh_id='{}')>".format( self.oh_id) <NEW_LINE> <DEDENT> def get_access_token(self, client_id=settings.OPENHUMANS_CLIENT_ID, client_secret=settings.OPENHUMANS_CLIENT_SECRET): <NEW_LINE> <INDENT> delta = timedelta(seconds=60) <NEW_LINE> if arrow.get(self.token_expires) - delta < arrow.now(): <NEW_LINE> <INDENT> self._refresh_tokens(client_id=client_id, client_secret=client_secret) <NEW_LINE> <DEDENT> return self.access_token <NEW_LINE> <DEDENT> def _refresh_tokens(self, client_id, client_secret): <NEW_LINE> <INDENT> response = requests.post( OH_TOKEN_URL, data={ 'grant_type': 'refresh_token', 'refresh_token': self.refresh_token}, auth=requests.auth.HTTPBasicAuth(client_id, client_secret)) <NEW_LINE> if response.status_code == 200: <NEW_LINE> <INDENT> data = response.json() <NEW_LINE> self.access_token = data['access_token'] <NEW_LINE> self.refresh_token = data['refresh_token'] <NEW_LINE> self.token_expires = self.get_expiration(data['expires_in']) <NEW_LINE> self.save() | Store OAuth2 data for Open Humans member.
A User account is created for this Open Humans member. | 62599090dc8b845886d55287 |
@compat.python_2_unicode_compatible <NEW_LINE> class BaseNgramModel(object): <NEW_LINE> <INDENT> def __init__(self, ngram_counter): <NEW_LINE> <INDENT> self.ngram_counter = ngram_counter <NEW_LINE> self.ngrams = ngram_counter.ngrams[ngram_counter.order] <NEW_LINE> self._ngrams = ngram_counter.ngrams <NEW_LINE> self._order = ngram_counter.order <NEW_LINE> self._check_against_vocab = self.ngram_counter.check_against_vocab <NEW_LINE> <DEDENT> def check_context(self, context): <NEW_LINE> <INDENT> if len(context) >= self._order: <NEW_LINE> <INDENT> raise ValueError("Context is too long for this ngram order: {0}".format(context)) <NEW_LINE> <DEDENT> return tuple(context) <NEW_LINE> <DEDENT> def score(self, word, context): <NEW_LINE> <INDENT> return 0.5 <NEW_LINE> <DEDENT> def logscore(self, word, context): <NEW_LINE> <INDENT> score = self.score(word, context) <NEW_LINE> if score == 0.0: <NEW_LINE> <INDENT> return NEG_INF <NEW_LINE> <DEDENT> return log(score, 2) <NEW_LINE> <DEDENT> def entropy(self, text): <NEW_LINE> <INDENT> normed_text = (self._check_against_vocab(word) for word in text) <NEW_LINE> H = 0.0 <NEW_LINE> processed_ngrams = 0 <NEW_LINE> for ngram in self.ngram_counter.to_ngrams(normed_text): <NEW_LINE> <INDENT> context, word = tuple(ngram[:-1]), ngram[-1] <NEW_LINE> H += self.logscore(word, context) <NEW_LINE> processed_ngrams += 1 <NEW_LINE> <DEDENT> return - (H / processed_ngrams) <NEW_LINE> <DEDENT> def perplexity(self, text): <NEW_LINE> <INDENT> return pow(2.0, self.entropy(text)) | An example of how to consume NgramCounter to create a language model.
This class isn't intended to be used directly, folks should inherit from it
when writing their own ngram models. | 62599090d8ef3951e32c8cc4 |
class BotCategory(commands.Cog): <NEW_LINE> <INDENT> @commands.command(pass_context=True) <NEW_LINE> async def ping(self, ctx): <NEW_LINE> <INDENT> await ctx.send(":ping_pong: Pong!") <NEW_LINE> print("user has pinged") | Category documentations | 62599090adb09d7d5dc0c229 |
class Collection(object): <NEW_LINE> <INDENT> def __init__(self, database, name): <NEW_LINE> <INDENT> self.__database = database <NEW_LINE> self.name = name <NEW_LINE> <DEDENT> @property <NEW_LINE> def database(self): <NEW_LINE> <INDENT> return self.__database <NEW_LINE> <DEDENT> def __eq__(self, other): <NEW_LINE> <INDENT> if isinstance(other, Collection): <NEW_LINE> <INDENT> us = (self.database, self.name) <NEW_LINE> them = (other.database, other.name) <NEW_LINE> return us == them <NEW_LINE> <DEDENT> return NotImplemented <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return "Collection(%r, %r)" % (self.database, self.name) <NEW_LINE> <DEDENT> def find(self, spec_or_id=None, fields={}, skip=0, limit=0, **kwargs): <NEW_LINE> <INDENT> if isinstance(spec_or_id, ObjectId) or isinstance(spec_or_id, basestring): <NEW_LINE> <INDENT> return self.database.connection.request.view_document( self.database.name, self.name, spec_or_id) <NEW_LINE> <DEDENT> return cursor.Cursor(self, spec_or_id, fields, skip, limit, **kwargs) <NEW_LINE> <DEDENT> def find_one(self, spec_or_id=None, **kwargs): <NEW_LINE> <INDENT> if isinstance(spec_or_id, ObjectId) or isinstance(spec_or_id, basestring): <NEW_LINE> <INDENT> return self.database.connection.request.view_document( self.database.name, self.name, spec_or_id) <NEW_LINE> <DEDENT> if not spec_or_id: <NEW_LINE> <INDENT> spec_or_id = {} <NEW_LINE> <DEDENT> documents = self.find(spec_or_id, limit=1, **kwargs) <NEW_LINE> if not documents.count(): <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> return documents[0] <NEW_LINE> <DEDENT> def count(self): <NEW_LINE> <INDENT> return len(self.find()) <NEW_LINE> <DEDENT> def insert(self, doc_or_docs): <NEW_LINE> <INDENT> return self.database.connection.request.insert_documents( self.database.name, self.name, doc_or_docs) <NEW_LINE> <DEDENT> def update(self, spec, document, upsert=False, multi=False): <NEW_LINE> <INDENT> return self.database.connection.request.update_documents( self.database.name, self.name, spec, document, upsert, multi) <NEW_LINE> <DEDENT> def remove(self, spec_or_id=None): <NEW_LINE> <INDENT> if isinstance(spec_or_id, ObjectId) or isinstance(spec_or_id, basestring): <NEW_LINE> <INDENT> return self.database.connection.request.delete_document( self.database.name, self.name, spec_or_id) <NEW_LINE> <DEDENT> if not spec_or_id: <NEW_LINE> <INDENT> spec_or_id = {} <NEW_LINE> <DEDENT> return self.database.connection.request.delete_replace_documents( self.database.name, self.name, spec_or_id, []) | For instance this class, you needs an instance of
:class:`pymongolab.database.Database` and the name of your collection.
Example usage:
.. code-block:: python
>>> from pymongolab import Connection, database, collection
>>> con = Connection("MongoLabAPIKey")
>>> db = database.Database(con, "database")
>>> collection.Collection(db, "collection")
Collection(Database(Connection('MongoLabAPIKey', 'v1'),
'database'), 'collection')
Easy usage (Attibute-style access):
.. code-block:: python
>>> from pymongolab import Connection
>>> con = Connection("MongoLabAPIKey")
>>> db = con.database
>>> db.collection
Collection(Database(Connection('MongoLabAPIKey', 'v1'),
'database'), 'collection')
Easy usage (Dictionary-style access):
.. code-block:: python
>>> from pymongolab import Connection
>>> con = Connection("MongoLabAPIKey")
>>> db = con["database"]
>>> db["collection"]
Collection(Database(Connection('MongoLabAPIKey', 'v1'),
'database'), 'collection') | 6259909055399d3f056281e4 |
class OrderPizza(): <NEW_LINE> <INDENT> def __init__(self, order): <NEW_LINE> <INDENT> self.order = order <NEW_LINE> <DEDENT> def take_order(self, name, price): <NEW_LINE> <INDENT> new_price = float(price) <NEW_LINE> for item in self.order: <NEW_LINE> <INDENT> if name in item: <NEW_LINE> <INDENT> new_price += item[1] <NEW_LINE> self.order.remove(item) <NEW_LINE> <DEDENT> <DEDENT> self.order.append((name, new_price)) <NEW_LINE> return self.order <NEW_LINE> <DEDENT> def status_order(self): <NEW_LINE> <INDENT> return self.order <NEW_LINE> <DEDENT> def print_status(self): <NEW_LINE> <INDENT> result = "" <NEW_LINE> for index in range(len(self.order)): <NEW_LINE> <INDENT> result += "%s - %s" % (self.order[index][0], self.order[index][1]) <NEW_LINE> if index != len(self.order) - 1: <NEW_LINE> <INDENT> result += "\n" <NEW_LINE> <DEDENT> <DEDENT> return result | docstring for OrderPizza | 62599090ad47b63b2c5a9521 |
class InputFileUnknownReference(Exception): <NEW_LINE> <INDENT> def __init__(self, line_number, message): <NEW_LINE> <INDENT> self.line_number = line_number <NEW_LINE> self.message = message <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return ('InputFileUnknownReference (Line ' + str(self.line_number) + '): ' + self.message) | InputFileUnknownReference is an `Exception` thrown when a link or host makes reference
to an unknown object (Host/Router/Link)
:param int line_number: erroneous line of input file
:param str message: error message | 6259909097e22403b383cbc9 |
class EV1Data(ESD1Data): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> ESD1Data.__init__(self) <NEW_LINE> self.pmn = NumParam(default=-999.0, info='minimum power limit', tex_name='p_{mn}', power=True, unit='pu', ) | Data for electric vehicle model. | 625990904a966d76dd5f0bb5 |
class Inference(object): <NEW_LINE> <INDENT> def __init__(self, parameters, output_layer=None, fileobj=None): <NEW_LINE> <INDENT> import py_paddle.swig_paddle as api <NEW_LINE> if output_layer is not None: <NEW_LINE> <INDENT> topo = topology.Topology(output_layer) <NEW_LINE> gm = api.GradientMachine.createFromConfigProto( topo.proto(), api.CREATE_MODE_TESTING, [api.PARAMETER_VALUE]) <NEW_LINE> self.__data_types__ = topo.data_type() <NEW_LINE> <DEDENT> elif fileobj is not None: <NEW_LINE> <INDENT> tmp = cPickle.load(fileobj) <NEW_LINE> gm = api.GradientMachine.createByConfigProtoStr( tmp['protobin'], api.CREATE_MODE_TESTING, [api.PARAMETER_VALUE]) <NEW_LINE> self.__data_types__ = tmp['data_type'] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise ValueError("Either output_layer or fileobj must be set") <NEW_LINE> <DEDENT> for param in gm.getParameters(): <NEW_LINE> <INDENT> val = param.getBuf(api.PARAMETER_VALUE) <NEW_LINE> name = param.getName() <NEW_LINE> assert isinstance(val, api.Vector) <NEW_LINE> val.copyFromNumpyArray(parameters.get(name).flatten()) <NEW_LINE> param.setValueUpdated() <NEW_LINE> <DEDENT> self.__gradient_machine__ = gm <NEW_LINE> <DEDENT> def iter_infer(self, input, feeding=None): <NEW_LINE> <INDENT> from data_feeder import DataFeeder <NEW_LINE> feeder = DataFeeder(self.__data_types__, feeding) <NEW_LINE> batch_size = len(input) <NEW_LINE> def __reader_impl__(): <NEW_LINE> <INDENT> for each_sample in input: <NEW_LINE> <INDENT> yield each_sample <NEW_LINE> <DEDENT> <DEDENT> reader = minibatch.batch(__reader_impl__, batch_size=batch_size) <NEW_LINE> self.__gradient_machine__.start() <NEW_LINE> for data_batch in reader(): <NEW_LINE> <INDENT> yield self.__gradient_machine__.forwardTest(feeder(data_batch)) <NEW_LINE> <DEDENT> self.__gradient_machine__.finish() <NEW_LINE> <DEDENT> def iter_infer_field(self, field, **kwargs): <NEW_LINE> <INDENT> if not isinstance(field, list) and not isinstance(field, tuple): <NEW_LINE> <INDENT> field = [field] <NEW_LINE> <DEDENT> for result in self.iter_infer(**kwargs): <NEW_LINE> <INDENT> for each_result in result: <NEW_LINE> <INDENT> item = [each_result[each_field] for each_field in field] <NEW_LINE> yield item <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def infer(self, input, field='value', flatten_result=True, **kwargs): <NEW_LINE> <INDENT> retv = None <NEW_LINE> kwargs['input'] = input <NEW_LINE> for result in self.iter_infer_field(field=field, **kwargs): <NEW_LINE> <INDENT> if retv is None: <NEW_LINE> <INDENT> retv = [[] for i in xrange(len(result))] <NEW_LINE> <DEDENT> for i, item in enumerate(result): <NEW_LINE> <INDENT> retv[i].append(item) <NEW_LINE> <DEDENT> <DEDENT> if flatten_result: <NEW_LINE> <INDENT> retv = [numpy.concatenate(out) for out in retv] <NEW_LINE> <DEDENT> if len(retv) == 1: <NEW_LINE> <INDENT> return retv[0] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return retv | Inference combines neural network output and parameters together
to do inference.
.. code-block:: python
inferer = Inference(output_layer=prediction, parameters=parameters)
for data_batch in batches:
print inferer.infer(data_batch)
:param output_layer: The neural network that should be inferenced.
:type output_layer: paddle.v2.config_base.Layer or the sequence
of paddle.v2.config_base.Layer
:param parameters: The parameters dictionary.
:type parameters: paddle.v2.parameters.Parameters | 62599090a05bb46b3848bf8d |
class UnformattedLines(Line): <NEW_LINE> <INDENT> def append(self, leaf: Leaf, preformatted: bool = True) -> None: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> list(generate_comments(leaf)) <NEW_LINE> <DEDENT> except FormatOn as f_on: <NEW_LINE> <INDENT> self.leaves.append(f_on.leaf_from_consumed(leaf)) <NEW_LINE> raise <NEW_LINE> <DEDENT> self.leaves.append(leaf) <NEW_LINE> if leaf.type == token.INDENT: <NEW_LINE> <INDENT> self.depth += 1 <NEW_LINE> <DEDENT> elif leaf.type == token.DEDENT: <NEW_LINE> <INDENT> self.depth -= 1 <NEW_LINE> <DEDENT> <DEDENT> def __str__(self) -> str: <NEW_LINE> <INDENT> if not self: <NEW_LINE> <INDENT> return "\n" <NEW_LINE> <DEDENT> res = "" <NEW_LINE> for leaf in self.leaves: <NEW_LINE> <INDENT> res += str(leaf) <NEW_LINE> <DEDENT> return res <NEW_LINE> <DEDENT> def append_comment(self, comment: Leaf) -> bool: <NEW_LINE> <INDENT> raise NotImplementedError("Unformatted lines don't store comments separately.") <NEW_LINE> <DEDENT> def maybe_remove_trailing_comma(self, closing: Leaf) -> bool: <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> def maybe_increment_for_loop_variable(self, leaf: Leaf) -> bool: <NEW_LINE> <INDENT> return False | Just like :class:`Line` but stores lines which aren't reformatted. | 62599090099cdd3c63676263 |
class FileNamespaceManager(OpenResourceNamespaceManager): <NEW_LINE> <INDENT> def __init__(self, namespace, data_dir=None, file_dir=None, lock_dir=None, digest_filenames=True, **kwargs): <NEW_LINE> <INDENT> self.digest_filenames = digest_filenames <NEW_LINE> if not file_dir and not data_dir: <NEW_LINE> <INDENT> raise MissingCacheParameter("data_dir or file_dir is required") <NEW_LINE> <DEDENT> elif file_dir: <NEW_LINE> <INDENT> self.file_dir = file_dir <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.file_dir = data_dir + "/container_file" <NEW_LINE> <DEDENT> util.verify_directory(self.file_dir) <NEW_LINE> if not lock_dir and not data_dir: <NEW_LINE> <INDENT> raise MissingCacheParameter("data_dir or lock_dir is required") <NEW_LINE> <DEDENT> elif lock_dir: <NEW_LINE> <INDENT> self.lock_dir = lock_dir <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.lock_dir = data_dir + "/container_file_lock" <NEW_LINE> <DEDENT> util.verify_directory(self.lock_dir) <NEW_LINE> OpenResourceNamespaceManager.__init__(self, namespace) <NEW_LINE> self.file = util.encoded_path(root=self.file_dir, identifiers=[self.namespace], extension='.cache', digest_filenames=self.digest_filenames) <NEW_LINE> self.hash = {} <NEW_LINE> debug("data file %s", self.file) <NEW_LINE> <DEDENT> def get_access_lock(self): <NEW_LINE> <INDENT> return file_synchronizer(identifier=self.namespace, lock_dir=self.lock_dir) <NEW_LINE> <DEDENT> def get_creation_lock(self, key): <NEW_LINE> <INDENT> return file_synchronizer( identifier="dbmcontainer/funclock/%s/%s" % ( self.namespace, key ), lock_dir=self.lock_dir ) <NEW_LINE> <DEDENT> def file_exists(self, file): <NEW_LINE> <INDENT> return os.access(file, os.F_OK) <NEW_LINE> <DEDENT> def do_open(self, flags, replace): <NEW_LINE> <INDENT> if not replace and self.file_exists(self.file): <NEW_LINE> <INDENT> fh = open(self.file, 'rb') <NEW_LINE> self.hash = cPickle.load(fh) <NEW_LINE> fh.close() <NEW_LINE> <DEDENT> self.flags = flags <NEW_LINE> <DEDENT> def do_close(self): <NEW_LINE> <INDENT> if self.flags == 'c' or self.flags == 'w': <NEW_LINE> <INDENT> fh = open(self.file, 'wb') <NEW_LINE> cPickle.dump(self.hash, fh) <NEW_LINE> fh.close() <NEW_LINE> <DEDENT> self.hash = {} <NEW_LINE> self.flags = None <NEW_LINE> <DEDENT> def do_remove(self): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> os.remove(self.file) <NEW_LINE> <DEDENT> except OSError: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> self.hash = {} <NEW_LINE> <DEDENT> def __getitem__(self, key): <NEW_LINE> <INDENT> return self.hash[key] <NEW_LINE> <DEDENT> def __contains__(self, key): <NEW_LINE> <INDENT> return key in self.hash <NEW_LINE> <DEDENT> def __setitem__(self, key, value): <NEW_LINE> <INDENT> self.hash[key] = value <NEW_LINE> <DEDENT> def __delitem__(self, key): <NEW_LINE> <INDENT> del self.hash[key] <NEW_LINE> <DEDENT> def keys(self): <NEW_LINE> <INDENT> return self.hash.keys() | :class:`.NamespaceManager` that uses binary files for storage.
Each namespace is implemented as a single file storing a
dictionary of key/value pairs, serialized using the Python
``pickle`` module. | 62599090adb09d7d5dc0c22d |
class ClusterAlgebraElement(ElementWrapper): <NEW_LINE> <INDENT> def _add_(self, other): <NEW_LINE> <INDENT> return self.parent().retract(self.lift() + other.lift()) <NEW_LINE> <DEDENT> def _neg_(self): <NEW_LINE> <INDENT> return self.parent().retract(-self.lift()) <NEW_LINE> <DEDENT> def _div_(self, other): <NEW_LINE> <INDENT> return self.lift() / other.lift() <NEW_LINE> <DEDENT> def d_vector(self): <NEW_LINE> <INDENT> monomials = self.lift().dict() <NEW_LINE> minimal = map(min, zip(*monomials)) <NEW_LINE> return tuple(-vector(minimal))[:self.parent().rank()] <NEW_LINE> <DEDENT> def _repr_(self): <NEW_LINE> <INDENT> numer, denom = self.lift()._fraction_pair() <NEW_LINE> return repr(numer / denom) | An element of a cluster algebra. | 62599090283ffb24f3cf5573 |
class Item(BaseModel): <NEW_LINE> <INDENT> uuid = UUIDField(unique=True) <NEW_LINE> name = CharField() <NEW_LINE> price = DecimalField(auto_round=True) <NEW_LINE> description = TextField() <NEW_LINE> availability = IntegerField() <NEW_LINE> category = TextField() <NEW_LINE> _schema = ItemSchema <NEW_LINE> _search_attributes = ['name', 'category', 'description'] <NEW_LINE> def __str__(self): <NEW_LINE> <INDENT> return '{}, {}, {}, {}'.format( self.uuid, self.name, self.price, self.description) <NEW_LINE> <DEDENT> def is_favorite(self, item): <NEW_LINE> <INDENT> for f in self.favorites: <NEW_LINE> <INDENT> if f.item_id == item.id: <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> <DEDENT> return False | Item describes a product for the e-commerce platform.
Attributes:
uuid (UUID): Item UUID
name (str): Name for the product
price (decimal.Decimal): Price for a single product
description (str): Product description
availability (int): Quantity of items available
category (str): Category group of the item | 62599090be7bc26dc9252cbf |
class AuthenticatedView(View): <NEW_LINE> <INDENT> @method_decorator(login_required) <NEW_LINE> def dispatch(self, *args, **kwargs): <NEW_LINE> <INDENT> return super(AuthenticatedView, self).dispatch(*args, **kwargs) | A view that when inherited requires a login for both GET and POST methods of a view class | 62599090ad47b63b2c5a9525 |
class NeuralNetBuilder(AspectBuilder): <NEW_LINE> <INDENT> def __init__(self, spec): <NEW_LINE> <INDENT> self.spec = spec <NEW_LINE> <DEDENT> def build(self, robot, model, plugin, analyzer_mode): <NEW_LINE> <INDENT> self._process_brain(plugin, robot.brain) <NEW_LINE> <DEDENT> def _process_brain(self, plugin, brain): <NEW_LINE> <INDENT> for neuron in brain.neuron: <NEW_LINE> <INDENT> spec = self.spec.get(neuron.type) <NEW_LINE> if spec is None: <NEW_LINE> <INDENT> err("Cannot build unknown neuron type '%s'." % neuron.type) <NEW_LINE> <DEDENT> params = spec.unserialize_params(neuron.param) <NEW_LINE> plugin.add_element(Neuron(neuron, params)) <NEW_LINE> <DEDENT> for conn in brain.connection: <NEW_LINE> <INDENT> plugin.add_element(NeuralConnection(conn)) | Default neural network builder. Assumes the neural net construction as specified
in the example protobuf message. | 625990917cff6e4e811b7717 |
class EntityVisitor(object): <NEW_LINE> <INDENT> __metaclass__ = ABCMeta <NEW_LINE> @abstractmethod <NEW_LINE> def visit_rule(self, rule, depth=0): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def visit_literal(self, literal, depth=0): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def visit_function(self, function, depth=0): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def visit_condition(self, condition, depth=0): <NEW_LINE> <INDENT> pass | Our visitor base class.
Each visitor implementation defines an operation for
our CGA entities (conditions, rules, etc).
The main one here is serialization (see writer.py).
The various _visit_x methods define the operation implemented by
this visitor for each Entity subclass.
Add a new EntityVisitor subclass to define a new operation over
a tree of entities.
Example operations:
- Custom serialization.
- Validate an entity tree to make sure it would serialize to
valid CGA. | 62599091656771135c48ae9b |
@attr.s <NEW_LINE> class GlobalNovaImageCollection(object): <NEW_LINE> <INDENT> tenant_id = attr.ib() <NEW_LINE> clock = attr.ib() <NEW_LINE> regional_collections = attr.ib(default=attr.Factory(dict)) <NEW_LINE> def collection_for_region(self, region_name, image_store): <NEW_LINE> <INDENT> if region_name not in self.regional_collections: <NEW_LINE> <INDENT> self.regional_collections[region_name] = ( RegionalNovaImageCollection(tenant_id=self.tenant_id, region_name=region_name, clock=self.clock, image_store=image_store)) <NEW_LINE> <DEDENT> return self.regional_collections[region_name] | A :obj:`GlobalNovaImageCollection` is a set of all the
:obj:`RegionalNovaImageCollection` objects owned by a given tenant. In other
words, all the image objects that a single tenant owns globally. | 6259909197e22403b383cbcd |
class PadLayer(Layer): <NEW_LINE> <INDENT> def __init__( self, layer = None, paddings = None, mode = 'CONSTANT', name = 'pad_layer', ): <NEW_LINE> <INDENT> Layer.__init__(self, name=name) <NEW_LINE> assert paddings is not None, "paddings should be a Tensor of type int32. see https://www.tensorflow.org/api_docs/python/tf/pad" <NEW_LINE> self.inputs = layer.outputs <NEW_LINE> print(" [TL] PadLayer %s: paddings:%s mode:%s" % (self.name, list(paddings), mode)) <NEW_LINE> self.outputs = tf.pad(self.inputs, paddings=paddings, mode=mode, name=name) <NEW_LINE> self.all_layers = list(layer.all_layers) <NEW_LINE> self.all_params = list(layer.all_params) <NEW_LINE> self.all_drop = dict(layer.all_drop) <NEW_LINE> self.all_layers.extend( [self.outputs] ) | The :class:`PadLayer` class is a Padding layer for any modes and dimensions.
Please see `tf.pad <https://www.tensorflow.org/api_docs/python/tf/pad>`_ for usage.
Parameters
----------
layer : a :class:`Layer` instance
The `Layer` class feeding into this layer.
padding : a Tensor of type int32.
mode : one of "CONSTANT", "REFLECT", or "SYMMETRIC" (case-insensitive)
name : a string or None
An optional name to attach to this layer. | 625990917cff6e4e811b7719 |
class ComputeTargetVpnGatewaysInsertRequest(_messages.Message): <NEW_LINE> <INDENT> project = _messages.StringField(1, required=True) <NEW_LINE> region = _messages.StringField(2, required=True) <NEW_LINE> targetVpnGateway = _messages.MessageField('TargetVpnGateway', 3) | A ComputeTargetVpnGatewaysInsertRequest object.
Fields:
project: Project ID for this request.
region: The name of the region for this request.
targetVpnGateway: A TargetVpnGateway resource to be passed as the request
body. | 6259909160cbc95b06365bd3 |
class DoublePatcher(TweakPatcher,ListPatcher): <NEW_LINE> <INDENT> listLabel = _(u'Source Mods/Files') <NEW_LINE> def GetConfigPanel(self,parent,gConfigSizer,gTipText): <NEW_LINE> <INDENT> if self.gConfigPanel: return self.gConfigPanel <NEW_LINE> self.gTipText = gTipText <NEW_LINE> gConfigPanel = self.gConfigPanel = wx.Window(parent) <NEW_LINE> text = fill(self.text,70) <NEW_LINE> gText = staticText(self.gConfigPanel,text) <NEW_LINE> self.gList = balt.listBox(gConfigPanel, kind='checklist') <NEW_LINE> self.gList.Bind(wx.EVT_MOTION,self.OnMouse) <NEW_LINE> self.gList.Bind(wx.EVT_RIGHT_DOWN,self.OnMouse) <NEW_LINE> self.gList.Bind(wx.EVT_RIGHT_UP,self.OnMouse) <NEW_LINE> self.gTweakList = balt.listBox(gConfigPanel, kind='checklist') <NEW_LINE> self.gTweakList.Bind(wx.EVT_CHECKLISTBOX,self.TweakOnListCheck) <NEW_LINE> self.gTweakList.Bind(wx.EVT_MOTION,self.TweakOnMouse) <NEW_LINE> self.gTweakList.Bind(wx.EVT_LEAVE_WINDOW,self.TweakOnMouse) <NEW_LINE> self.gTweakList.Bind(wx.EVT_RIGHT_DOWN,self.TweakOnMouse) <NEW_LINE> self.gTweakList.Bind(wx.EVT_RIGHT_UP,self.TweakOnMouse) <NEW_LINE> self.mouseItem = -1 <NEW_LINE> self.mouseState = None <NEW_LINE> self.gSelectAll = button(gConfigPanel,_(u'Select All'),onClick=self.SelectAll) <NEW_LINE> self.gDeselectAll = button(gConfigPanel,_(u'Deselect All'),onClick=self.DeselectAll) <NEW_LINE> gSelectSizer = (vSizer( (self.gSelectAll,0,wx.TOP,12), (self.gDeselectAll,0,wx.TOP,4), ),0,wx.EXPAND|wx.LEFT,4) <NEW_LINE> self.gTweakSelectAll = button(gConfigPanel,_(u'Select All'),onClick=self.TweakSelectAll) <NEW_LINE> self.gTweakDeselectAll = button(gConfigPanel,_(u'Deselect All'),onClick=self.TweakDeselectAll) <NEW_LINE> gTweakSelectSizer = (vSizer( (self.gTweakSelectAll,0,wx.TOP,12), (self.gTweakDeselectAll,0,wx.TOP,4), ),0,wx.EXPAND|wx.LEFT,4) <NEW_LINE> gSizer = vSizer( (gText,), (hsbSizer((gConfigPanel,wx.ID_ANY,self.__class__.listLabel), ((4,0),0,wx.EXPAND), (self.gList,1,wx.EXPAND|wx.TOP,2), gSelectSizer,),1,wx.EXPAND|wx.TOP,4), (hsbSizer((gConfigPanel,wx.ID_ANY,self.__class__.subLabel), ((4,0),0,wx.EXPAND), (self.gTweakList,1,wx.EXPAND|wx.TOP,2), gTweakSelectSizer,),1,wx.EXPAND|wx.TOP,4), ) <NEW_LINE> gConfigPanel.SetSizer(gSizer) <NEW_LINE> gConfigSizer.Add(gConfigPanel,1,wx.EXPAND) <NEW_LINE> self.SetItems(self.getAutoItems()) <NEW_LINE> self.SetTweaks() <NEW_LINE> return gConfigPanel | Patcher panel with option to select source elements. | 625990913617ad0b5ee07e28 |
class _ASoulTrapTweak(_AGmstCCTweak): <NEW_LINE> <INDENT> tweak_choices = [(u'4', 4), (u'16', 16), (u'28', 28), (u'38', 38)] | Base class for Soul Trap tweaks. | 6259909197e22403b383cbcf |
class H5Data(Data): <NEW_LINE> <INDENT> def __init__(self, batch_size, cache=None, preloading=0, features_name='features', labels_name='labels', spectators_name = None): <NEW_LINE> <INDENT> super(H5Data, self).__init__(batch_size,cache,(spectators_name is not None)) <NEW_LINE> self.features_name = features_name <NEW_LINE> self.labels_name = labels_name <NEW_LINE> self.spectators_name = spectators_name <NEW_LINE> self.fpl = None <NEW_LINE> if preloading: <NEW_LINE> <INDENT> self.fpl = FilePreloader( [] , file_open = lambda n : h5py.File(n,'r'), n_ahead=preloading) <NEW_LINE> self.fpl.start() <NEW_LINE> <DEDENT> <DEDENT> def load_data(self, in_file_name): <NEW_LINE> <INDENT> if self.fpl: <NEW_LINE> <INDENT> h5_file = self.fpl.getFile( in_file_name ) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> h5_file = h5py.File( in_file_name, 'r' ) <NEW_LINE> <DEDENT> X = self.load_hdf5_data( h5_file[self.features_name] ) <NEW_LINE> Y = self.load_hdf5_data( h5_file[self.labels_name] ) <NEW_LINE> if self.spectators_name is not None: <NEW_LINE> <INDENT> Z = self.load_hdf5_data( h5_file[self.spectators_name] ) <NEW_LINE> <DEDENT> if self.fpl: <NEW_LINE> <INDENT> self.fpl.closeFile( in_file_name ) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> h5_file.close() <NEW_LINE> <DEDENT> if self.spectators_name is not None: <NEW_LINE> <INDENT> return X,Y,Z <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return X,Y <NEW_LINE> <DEDENT> <DEDENT> def load_hdf5_data(self, data): <NEW_LINE> <INDENT> if hasattr(data, 'keys'): <NEW_LINE> <INDENT> out = [ self.load_hdf5_data( data[key] ) for key in sorted(data.keys()) ] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> out = data[:] <NEW_LINE> <DEDENT> return out <NEW_LINE> <DEDENT> def count_data(self): <NEW_LINE> <INDENT> num_data = 0 <NEW_LINE> for in_file_name in self.file_names: <NEW_LINE> <INDENT> h5_file = h5py.File( in_file_name, 'r' ) <NEW_LINE> X = h5_file[self.features_name] <NEW_LINE> if hasattr(X, 'keys'): <NEW_LINE> <INDENT> num_data += len(X[ list(X.keys())[0] ]) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> num_data += len(X) <NEW_LINE> <DEDENT> h5_file.close() <NEW_LINE> <DEDENT> return num_data <NEW_LINE> <DEDENT> def finalize(self): <NEW_LINE> <INDENT> if self.fpl: <NEW_LINE> <INDENT> self.fpl.stop() | Loads data stored in hdf5 files
Attributes:
features_name, labels_name, spectators_name: names of the datasets containing the features,
labels, and spectators respectively | 625990918a349b6b43687f37 |
class Meta: <NEW_LINE> <INDENT> verbose_name_plural = "hypotheses" | Hypothesis Model meta options.
For more information, please see:
https://docs.djangoproject.com/en/1.10/topics/db/models/#meta-options | 62599091656771135c48ae9d |
class RequestLogger(wsgi.Middleware): <NEW_LINE> <INDENT> @webob.dec.wsgify(RequestClass=wsgi.Request) <NEW_LINE> def __call__(self, req): <NEW_LINE> <INDENT> req_id = req.headers.get('x-qonos-request-id') <NEW_LINE> if req_id is not None: <NEW_LINE> <INDENT> LOG.info('Processing Qonos request: %s' % req_id) <NEW_LINE> <DEDENT> resp = req.get_response(self.application) <NEW_LINE> if req_id is not None: <NEW_LINE> <INDENT> LOG.info('Returning Qonos request: %s' % req_id) <NEW_LINE> <DEDENT> return resp <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def factory(cls, global_conf, **local_conf): <NEW_LINE> <INDENT> def filter(app): <NEW_LINE> <INDENT> return cls(app) <NEW_LINE> <DEDENT> return filter | Logs qonos request id, if present, before and after processing a request
The request id is determined by looking for the header
'x-qonos-request-id'. | 6259909155399d3f056281ee |
class OnSolarScheduleConstraint(SolarScheduleConstraint): <NEW_LINE> <INDENT> pass | Constraint between a Unit and on-SolarSchedules. | 62599091a05bb46b3848bf91 |
class BERTModel(nn.Block): <NEW_LINE> <INDENT> def __init__(self, center_hiddens, center_ffn_hiddens, center_heads, center_layers, reg_encode_ffn_hiddens, reg_encode_layers, reg_hiddens, cls_hiddens, dropout): <NEW_LINE> <INDENT> super(BERTModel, self).__init__() <NEW_LINE> self.center = BERTEncoder(center_hiddens, center_ffn_hiddens, center_heads, center_layers, dropout) <NEW_LINE> self.reg_encoder = BERTEncoder(center_hiddens, reg_encode_ffn_hiddens, center_heads, reg_encode_layers, dropout) <NEW_LINE> self.reg_predictor = ThrptPred(reg_hiddens, dropout) <NEW_LINE> self.valid_predictor = ValidPred(cls_hiddens, dropout) <NEW_LINE> <DEDENT> def forward(self, features): <NEW_LINE> <INDENT> encoded_X = self.center(features) <NEW_LINE> valid_preds = self.valid_predictor(encoded_X) <NEW_LINE> encoded_X = self.reg_encoder(encoded_X) <NEW_LINE> thrpt_preds = self.reg_predictor(encoded_X) <NEW_LINE> return (valid_preds, thrpt_preds) | Define a BERT model. | 6259909197e22403b383cbd3 |
class MockTelnet(StatefulTelnet): <NEW_LINE> <INDENT> def __init__(self, prompt, commands): <NEW_LINE> <INDENT> self._password_input = False <NEW_LINE> super(MockTelnet, self).__init__() <NEW_LINE> self.prompt = prompt <NEW_LINE> self.commands = {c.name: c for c in commands} <NEW_LINE> self.cmdstack = [] <NEW_LINE> self.password_input = False <NEW_LINE> self.terminal = self <NEW_LINE> self.commands["_exit"] = ExitCommand("_exit") <NEW_LINE> <DEDENT> @property <NEW_LINE> def password_input(self): <NEW_LINE> <INDENT> return self._password_input <NEW_LINE> <DEDENT> @password_input.setter <NEW_LINE> def password_input(self, value): <NEW_LINE> <INDENT> if self._password_input != value: <NEW_LINE> <INDENT> self._password_input = value <NEW_LINE> if self._password_input: <NEW_LINE> <INDENT> self.enable_input_replacement("") <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.disable_input_replacement() <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def connectionMade(self): <NEW_LINE> <INDENT> super(MockTelnet, self).connectionMade() <NEW_LINE> self.keyHandlers = self._key_handlers <NEW_LINE> self.write('Username:') <NEW_LINE> self.handler = self.validate_username <NEW_LINE> <DEDENT> def loseConnection(self): <NEW_LINE> <INDENT> self.connectionLost("requested") <NEW_LINE> <DEDENT> def validate_username(self, _): <NEW_LINE> <INDENT> self.write('Password:') <NEW_LINE> self.handler = self.validate_password <NEW_LINE> <DEDENT> def validate_password(self, _): <NEW_LINE> <INDENT> self.cmdstack = [RootCommand(self)] <NEW_LINE> self.cmdstack[0].resume() <NEW_LINE> self.handler = self.command <NEW_LINE> <DEDENT> def show_prompt(self): <NEW_LINE> <INDENT> self.write(self.prompt) <NEW_LINE> <DEDENT> def command(self, data): <NEW_LINE> <INDENT> line = data.rstrip() <NEW_LINE> if len(self.cmdstack) > 1: <NEW_LINE> <INDENT> self.cmdstack[-1].lineReceived(line) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> parts = line.split(" ") <NEW_LINE> command = parts[0] <NEW_LINE> if command in self.commands: <NEW_LINE> <INDENT> self.call_command(self.commands[command], parts) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def call_command(self, cmd, parts=None): <NEW_LINE> <INDENT> cmd(self) <NEW_LINE> cmd.args = parts <NEW_LINE> self.cmdstack.append(cmd) <NEW_LINE> cmd.start() <NEW_LINE> <DEDENT> def nextLine(self): <NEW_LINE> <INDENT> return self.next_line() | This aims to act as a telent server over the SAME contract as MockSSH
Taking the same commands and making them work the same ensure
the same test code can be applied to SSH and Telnet | 625990918a349b6b43687f3b |
class RequestList(ProtectedListView): <NEW_LINE> <INDENT> template_name = 'requests/list.html' <NEW_LINE> context_object_name = 'users_request_list' <NEW_LINE> def get_queryset(self): <NEW_LINE> <INDENT> return Request.objects.filter(ideal_time__gte=timezone.now(), user = self.request.user.id) | Front page after user login. Displays their requests. | 62599091bf627c535bcb31af |
@needs_mesos <NEW_LINE> class MesosPromisedRequirementsTest(hidden.AbstractPromisedRequirementsTest, MesosTestSupport): <NEW_LINE> <INDENT> def getBatchSystemName(self): <NEW_LINE> <INDENT> self._startMesos(self.cpuCount) <NEW_LINE> return "mesos" <NEW_LINE> <DEDENT> def tearDown(self): <NEW_LINE> <INDENT> self._stopMesos() | Tests against the Mesos batch system | 6259909160cbc95b06365bd6 |
class InterpolationException(AocUtilsException): <NEW_LINE> <INDENT> pass | Something went wrong with an interpolation | 6259909197e22403b383cbd5 |
class UploadImageHandler(BaseHandler): <NEW_LINE> <INDENT> def get(self): <NEW_LINE> <INDENT> pid = self.get_argument("pid", None) <NEW_LINE> self.render('upload_image.html', pid=pid) <NEW_LINE> <DEDENT> @session <NEW_LINE> def post(self): <NEW_LINE> <INDENT> uid = self.SESSION['uid'] <NEW_LINE> p=AvatarProcessor(uid) <NEW_LINE> f=self.request.files['upload'][0] <NEW_LINE> r = p.process(f['body']) <NEW_LINE> self.redirect('/image/upload?pid='+r) | 图片上传
| 62599091283ffb24f3cf557e |
@common.register_class_methods <NEW_LINE> class CMP(CheckConfig): <NEW_LINE> <INDENT> built_in_policies = [ "ns_cmp_content_type", "ns_cmp_msapp", "ns_cmp_mscss", "ns_nocmp_mozilla_47", "ns_nocmp_xml_ie" ] <NEW_LINE> @common.register_for_cmd("set", "cmp", "parameter") <NEW_LINE> def set_cmp_parameter(self, cmp_param_tree): <NEW_LINE> <INDENT> if cmp_param_tree.keyword_exists("policyType"): <NEW_LINE> <INDENT> self._initial_cmp_parameter = cmp_param_tree.keyword_value("policyType")[0].value.lower() <NEW_LINE> if self._initial_cmp_parameter == "classic": <NEW_LINE> <INDENT> return [cmp_param_tree] <NEW_LINE> <DEDENT> <DEDENT> return [] <NEW_LINE> <DEDENT> @common.register_for_cmd("set", "cmp", "policy") <NEW_LINE> def set_cmp_policy(self, cmp_policy_tree): <NEW_LINE> <INDENT> policy_name = cmp_policy_tree.positional_value(0).value <NEW_LINE> if policy_name in self.built_in_policies: <NEW_LINE> <INDENT> return [cmp_policy_tree] <NEW_LINE> <DEDENT> return [] <NEW_LINE> <DEDENT> @common.register_for_cmd("add", "cmp", "policy") <NEW_LINE> def check_cmp_policy(self, cmp_policy_tree): <NEW_LINE> <INDENT> original_cmd = copy.deepcopy(cmp_policy_tree) <NEW_LINE> CheckConfig.check_keyword_expr(cmp_policy_tree, 'rule') <NEW_LINE> if cmp_policy_tree.invalid: <NEW_LINE> <INDENT> return [original_cmd] <NEW_LINE> <DEDENT> return [] <NEW_LINE> <DEDENT> @common.register_for_cmd("bind", "cmp", "global") <NEW_LINE> def check_cmp_global_bind(self, bind_cmd_tree): <NEW_LINE> <INDENT> if bind_cmd_tree.keyword_exists("state"): <NEW_LINE> <INDENT> return [bind_cmd_tree] <NEW_LINE> <DEDENT> policy_name = bind_cmd_tree.positional_value(0).value <NEW_LINE> if policy_name in self.built_in_policies: <NEW_LINE> <INDENT> return [bind_cmd_tree] <NEW_LINE> <DEDENT> return [] | Checks CMP feature commands. | 625990917cff6e4e811b7723 |
class PriceProfileAdmin(SimpleHistoryAdmin): <NEW_LINE> <INDENT> list_display = ('name', 'a', 'b', 'c', 'alpha', 'use_for_draft') <NEW_LINE> ordering = ('name',) <NEW_LINE> search_fields = ('name',) <NEW_LINE> list_filter = ('use_for_draft',) | The admin class for :class:`Consumptions <preferences.models.PriceProfile>`. | 62599091099cdd3c6367626a |
class Post(db.Model): <NEW_LINE> <INDENT> __tablename__ = 'post' <NEW_LINE> id = db.Column(db.Integer, primary_key=True) <NEW_LINE> title = db.Column(db.String(50)) <NEW_LINE> excerpt = db.Column(db.String(200)) <NEW_LINE> description = db.Column(db.Text()) <NEW_LINE> image = db.Column(db.String(100)) <NEW_LINE> created_at = db.Column(db.DateTime(), default= datetime.now()) <NEW_LINE> updated_at = db.Column(db.DateTime(), onupdate=datetime.now()) <NEW_LINE> user_id = db.Column(db.Integer, db.ForeignKey('users.id')) <NEW_LINE> categories = db.relationship('Category', secondary=post_cat, backref=db.backref('posts', lazy='dynamic')) <NEW_LINE> comments = db.relationship("Comments", backref="pcomments") <NEW_LINE> tags = db.relationship('Tags', secondary=post_tag, backref=db.backref('tposts', lazy='dynamic')) <NEW_LINE> status = db.Column(db.Integer) <NEW_LINE> def __init__(self, title=None, excerpt=None, description=None, image=None, user_id=None, categories=[], tags=[], status=0): <NEW_LINE> <INDENT> self.title = title <NEW_LINE> self.excerpt = excerpt <NEW_LINE> self.description = description <NEW_LINE> self.image = image <NEW_LINE> self.user_id = user_id <NEW_LINE> self.categories = categories <NEW_LINE> self.tags = tags <NEW_LINE> self.status = status <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return '%s' % self.title <NEW_LINE> <DEDENT> def dump_datetime(self, value): <NEW_LINE> <INDENT> if value is None: <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> return [value.strftime("%Y-%m-%d"), value.strftime("%H:%M:%S")] <NEW_LINE> <DEDENT> def serialize(self): <NEW_LINE> <INDENT> return { 'id' : self.id, 'title' : self.title, 'excerpt' : self.excerpt, 'description': self.description, 'image' : self.image, 'created_at' : self.dump_datetime(self.created_at), 'updated_at' : self.dump_datetime(self.updated_at) } <NEW_LINE> <DEDENT> def serialize2(self): <NEW_LINE> <INDENT> return { 'id' : self.id, 'title' : self.title, 'excerpt' : self.excerpt, 'description': self.description } | Creates the post model
Functions:
dump_datetime -- Deserialize datetime object into string form for JSON processing.
serialize -- Creates a dict from post object
serialize2 -- Creates a dict from post object | 6259909150812a4eaa621a37 |
class EndPointWrapper(object): <NEW_LINE> <INDENT> def __init__(self, tty, switchEventQueue): <NEW_LINE> <INDENT> self.id = None <NEW_LINE> self.log = logging.getLogger("EndPoint[{}]".format(self.id)) <NEW_LINE> self.switchEventQueue = switchEventQueue <NEW_LINE> escapingSink = EscapingSink(TtySink(tty)) <NEW_LINE> escapingSource = EscapingSource(TtySource(tty)) <NEW_LINE> self.outgoingFrameBuffer = deque() <NEW_LINE> frameTransmitter = FrameTransmitter(escapingSink) <NEW_LINE> frameReceiver = FrameReceiver(escapingSource) <NEW_LINE> self.incomingFrameHandler = IncomingFrameHandler() <NEW_LINE> self.endPoint = EndPoint(escapingSource, frameReceiver, self.incomingFrameHandler, self.outgoingFrameBuffer, frameTransmitter, escapingSink) <NEW_LINE> frameReceiver.setFrameHandler(self.endPoint) <NEW_LINE> self.incomingFrameHandler.frameNotifier.addObserver(self) <NEW_LINE> self.pingPong = PingPong(self.outgoingFrameBuffer) <NEW_LINE> self.incomingFrameHandler.frameNotifier.addObserver(self.pingPong) <NEW_LINE> self.hardwareRuleManager = HardwareRuleManager(self.outgoingFrameBuffer) <NEW_LINE> self.incomingFrameHandler.frameNotifier.addObserver(self.hardwareRuleManager) <NEW_LINE> <DEDENT> def update(self, observable, frame): <NEW_LINE> <INDENT> if frame[0] == OpCode.MY_ID() and len(frame[1]) == 1: <NEW_LINE> <INDENT> self.id = frame[1][0] <NEW_LINE> self.log = logging.getLogger("EndPoint[{}]".format(self.id)) <NEW_LINE> self.log.setLevel(logging.DEBUG) <NEW_LINE> self.log.debug("Starting...") <NEW_LINE> <DEDENT> elif frame[0] == OpCode.LOG() and len(frame[1]) > 0: <NEW_LINE> <INDENT> if self.log != None: <NEW_LINE> <INDENT> self.log.info("".join(map(chr, frame[1]))) <NEW_LINE> <DEDENT> <DEDENT> elif frame[0] == OpCode.SWITCH_ACTIVE() and len(frame[1]) == 1: <NEW_LINE> <INDENT> self.switchEventQueue.append(("{}-{}".format(self.id, frame[1][0]), 1)) <NEW_LINE> <DEDENT> elif frame[0] == OpCode.SWITCH_INACTIVE() and len(frame[1]) == 1: <NEW_LINE> <INDENT> self.switchEventQueue.append(("{}-{}".format(self.id, frame[1][0]), 0)) <NEW_LINE> <DEDENT> <DEDENT> def ensureID(self): <NEW_LINE> <INDENT> while self.id == None: <NEW_LINE> <INDENT> self.schedule() <NEW_LINE> <DEDENT> <DEDENT> def schedule(self): <NEW_LINE> <INDENT> self.endPoint.schedule() <NEW_LINE> <DEDENT> def addHardwareRule(self, switchId, activity, solenoidId, attack, sustain): <NEW_LINE> <INDENT> self.hardwareRuleManager.addRule(HardwareRule(Stimulus(switchId, activity), SolenoidAction(True, solenoidId, attack, sustain))) <NEW_LINE> <DEDENT> def pulseSolenoid(self, activity): <NEW_LINE> <INDENT> self.outgoingFrameBuffer += [[OpCode.PULSE_COIL()] + activity.toByteArray()] <NEW_LINE> <DEDENT> def setSwitchDebounceThreshold(self, switchId, microseconds, activity): <NEW_LINE> <INDENT> self.outgoingFrameBuffer += [[OpCode.SWITCH_DEBOUNCE_CONFIG()] + [switchId] + [1 if activity else 0] + [microseconds & 255, (microseconds >> 8) & 255, (microseconds >> 16) & 255, microseconds >> 24]] <NEW_LINE> <DEDENT> def setSwitchPullup(self, switchId, pullup): <NEW_LINE> <INDENT> self.outgoingFrameBuffer += [[OpCode.SWITCH_PULLUP_CONFIG()] + [switchId] + [1 if pullup else 0]] | classdocs | 62599091dc8b845886d5529b |
class PositionCommand(Command): <NEW_LINE> <INDENT> NAME = "POSITION" <NEW_LINE> def __init__( self, stream_name: str, instance_name: str, prev_token: int, new_token: int ): <NEW_LINE> <INDENT> self.stream_name = stream_name <NEW_LINE> self.instance_name = instance_name <NEW_LINE> self.prev_token = prev_token <NEW_LINE> self.new_token = new_token <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def from_line(cls: Type["PositionCommand"], line: str) -> "PositionCommand": <NEW_LINE> <INDENT> stream_name, instance_name, prev_token, new_token = line.split(" ", 3) <NEW_LINE> return cls(stream_name, instance_name, int(prev_token), int(new_token)) <NEW_LINE> <DEDENT> def to_line(self) -> str: <NEW_LINE> <INDENT> return " ".join( ( self.stream_name, self.instance_name, str(self.prev_token), str(self.new_token), ) ) | Sent by an instance to tell others the stream position without needing to
send an RDATA.
Two tokens are sent, the new position and the last position sent by the
instance (in an RDATA or other POSITION). The tokens are chosen so that *no*
rows were written by the instance between the `prev_token` and `new_token`.
(If an instance hasn't sent a position before then the new position can be
used for both.)
Format::
POSITION <stream_name> <instance_name> <prev_token> <new_token>
On receipt of a POSITION command instances should check if they have missed
any updates, and if so then fetch them out of band. Instances can check this
by comparing their view of the current token for the sending instance with
the included `prev_token`.
The `<instance_name>` is the process that sent the command and is the source
of the stream. | 625990915fdd1c0f98e5fc5a |
class BrowserDetectionError(Exception): <NEW_LINE> <INDENT> def __init__(self, message, cause): <NEW_LINE> <INDENT> super().__init__(message) <NEW_LINE> self.cause = cause | BrowserDetectionError | 62599091a05bb46b3848bf96 |
class CallbacksRegistry: <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.callbacks = {BEFORE_APPLY: [], AFTER_APPLY: []} <NEW_LINE> <DEDENT> def add(self, trigger, callable, actions=ACTIONS, resources=SUPPORTED_RESOURCES): <NEW_LINE> <INDENT> assert trigger in self.callbacks, "{} is not a supported trigger".format( trigger ) <NEW_LINE> assert all( action in ACTIONS for action in actions ), "Some actions are not supported" <NEW_LINE> assert all( resource in SUPPORTED_RESOURCES for resource in resources ), "Some resources are not supported" <NEW_LINE> callback = Callback(callable, actions, resources) <NEW_LINE> self.callbacks[trigger].append(callback) <NEW_LINE> return callback <NEW_LINE> <DEDENT> async def run(self, trigger, action, resource): <NEW_LINE> <INDENT> assert trigger in self.callbacks, "Invalid trigger {}".format(trigger) <NEW_LINE> for callback in self.callbacks[trigger]: <NEW_LINE> <INDENT> if action in callback.actions and resource.__class__ in callback.resources: <NEW_LINE> <INDENT> await callback.callable(action, resource) | A named registry collects (async) callbacks for a specific action
during the apply workflow. | 625990917cff6e4e811b7727 |
class ExcHandlerError(RuntimeError): <NEW_LINE> <INDENT> def __init__(self, badExcListenerID, topicObj, origExc=None): <NEW_LINE> <INDENT> self.badExcListenerID = badExcListenerID <NEW_LINE> import traceback <NEW_LINE> self.exc = traceback.format_exc() <NEW_LINE> msg = 'The exception handler registered with pubsub raised an ' + 'exception, *while* handling an exception raised by listener ' + ' "%s" of topic "%s"):\n%s' % (self.badExcListenerID, topicObj.getName(), self.exc) <NEW_LINE> RuntimeError.__init__(self, msg) | When an exception gets raised within some listener during a
sendMessage(), the registered handler (see pub.setListenerExcHandler())
gets called (via its __call__ method) and the send operation can
resume on remaining listeners. However, if the handler itself
raises an exception while it is being called, the send operation
must be aborted: an ExcHandlerError exception gets raised. | 6259909160cbc95b06365bda |
class MyAlgorithm(object): <NEW_LINE> <INDENT> def __init__(self, datasetdir): <NEW_LINE> <INDENT> self.datasetdir = datasetdir <NEW_LINE> trained_file = "./model2.pkl" <NEW_LINE> self.classifier = keras.models.load_model(trained_file) <NEW_LINE> self.classes = joblib.load("./model.pkl") <NEW_LINE> <DEDENT> def predict(self, full_img, bbox): <NEW_LINE> <INDENT> x, y, w, h = bbox <NEW_LINE> target_img = full_img[y:y+h, x:x+w, :] <NEW_LINE> feature = self.feature_extraction(target_img).reshape(1, 32, 32, 1) <NEW_LINE> recog_result = self.classifier.predict_classes(feature, verbose=0) <NEW_LINE> codes = [] <NEW_LINE> for res in recog_result: <NEW_LINE> <INDENT> codes.append(self.classes[res]) <NEW_LINE> <DEDENT> return codes <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def feature_extraction(cls, img): <NEW_LINE> <INDENT> blur_image = cv2.bilateralFilter(img, 14, 14, 3) <NEW_LINE> gray_image = cv2.cvtColor(blur_image, cv2.COLOR_BGR2GRAY) <NEW_LINE> ret, binary_image = cv2.threshold(gray_image, 0,255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU) <NEW_LINE> img32 = cv2.resize(binary_image, (32, 32)).reshape(1, 32, 32, 1) <NEW_LINE> return img32 | アルゴリズム | 62599091f9cc0f698b1c613e |
class TestHomotopy(SimulationTest): <NEW_LINE> <INDENT> @classmethod <NEW_LINE> def setUpClass(cls): <NEW_LINE> <INDENT> SimulationTest.setup_class_base('OperatorTests.mo', 'OperatorTests.HomotopyTest') <NEW_LINE> <DEDENT> @testattr(stddist_full = True) <NEW_LINE> def setUp(self): <NEW_LINE> <INDENT> self.setup_base(start_time=0.0, final_time=0.5, time_step=0.01) <NEW_LINE> self.run() <NEW_LINE> <DEDENT> @testattr(stddist_full = True) <NEW_LINE> def test_trajectories(self): <NEW_LINE> <INDENT> self.assert_end_value('x', 0.5) | Basic test of Modelica operators. | 6259909155399d3f056281fa |
class BiosVfProcessorC3Report(ManagedObject): <NEW_LINE> <INDENT> consts = BiosVfProcessorC3ReportConsts() <NEW_LINE> naming_props = set([]) <NEW_LINE> mo_meta = MoMeta("BiosVfProcessorC3Report", "biosVfProcessorC3Report", "Processor-C3-Report", VersionMeta.Version151f, "InputOutput", 0x1f, [], ["admin", "read-only", "user"], [u'biosPlatformDefaults', u'biosSettings'], [], ["Get", "Set"]) <NEW_LINE> prop_meta = { "child_action": MoPropertyMeta("child_action", "childAction", "string", VersionMeta.Version151f, MoPropertyMeta.INTERNAL, None, None, None, None, [], []), "dn": MoPropertyMeta("dn", "dn", "string", VersionMeta.Version151f, MoPropertyMeta.READ_WRITE, 0x2, 0, 255, None, [], []), "rn": MoPropertyMeta("rn", "rn", "string", VersionMeta.Version151f, MoPropertyMeta.READ_WRITE, 0x4, 0, 255, None, [], []), "status": MoPropertyMeta("status", "status", "string", VersionMeta.Version151f, MoPropertyMeta.READ_WRITE, 0x8, None, None, None, ["", "created", "deleted", "modified", "removed"], []), "vp_processor_c3_report": MoPropertyMeta("vp_processor_c3_report", "vpProcessorC3Report", "string", VersionMeta.Version151f, MoPropertyMeta.READ_WRITE, 0x10, None, None, None, ["Disabled", "Enabled", "disabled", "enabled", "platform-default"], []), } <NEW_LINE> prop_map = { "childAction": "child_action", "dn": "dn", "rn": "rn", "status": "status", "vpProcessorC3Report": "vp_processor_c3_report", } <NEW_LINE> def __init__(self, parent_mo_or_dn, **kwargs): <NEW_LINE> <INDENT> self._dirty_mask = 0 <NEW_LINE> self.child_action = None <NEW_LINE> self.status = None <NEW_LINE> self.vp_processor_c3_report = None <NEW_LINE> ManagedObject.__init__(self, "BiosVfProcessorC3Report", parent_mo_or_dn, **kwargs) | This is BiosVfProcessorC3Report class. | 6259909150812a4eaa621a39 |
class TagsCanonicalize(command.Command): <NEW_LINE> <INDENT> log = logging.getLogger(__name__) <NEW_LINE> def take_action(self, parsed_args): <NEW_LINE> <INDENT> import pinboard <NEW_LINE> pinboard._debug = 1 <NEW_LINE> client = self.app.get_client() <NEW_LINE> all_tags = client.tags() <NEW_LINE> self.log.info('Found %d separate tags', len(all_tags)) <NEW_LINE> tag_names = (t['name'] for t in all_tags) <NEW_LINE> for tag in tag_names: <NEW_LINE> <INDENT> c_tag = tag.lower() <NEW_LINE> if c_tag != tag: <NEW_LINE> <INDENT> temp_tag = c_tag + '-renaming' <NEW_LINE> self.log.info('Rename "%s" to "%s"', tag, c_tag) <NEW_LINE> if not self.app.options.dry_run: <NEW_LINE> <INDENT> client.rename_tag(tag, temp_tag) <NEW_LINE> client.rename_tag(temp_tag, c_tag) | Combine tags that are the same except for capitalization.
| 62599091ad47b63b2c5a9538 |
class GeoWatchClient(object): <NEW_LINE> <INDENT> backend = None <NEW_LINE> templates = None <NEW_LINE> def close(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def __init__(self, backend="", templates=None): <NEW_LINE> <INDENT> self.backend = backend <NEW_LINE> self.templates = templates <NEW_LINE> <DEDENT> def __enter__(self): <NEW_LINE> <INDENT> return self <NEW_LINE> <DEDENT> def __exit__(self, *args, **kwargs): <NEW_LINE> <INDENT> self.close() | Base GeoWatch Client class. Extended by others. | 62599091bf627c535bcb31bb |
Subsets and Splits