code
stringlengths 4
4.48k
| docstring
stringlengths 1
6.45k
| _id
stringlengths 24
24
|
|---|---|---|
class PoMessage: <NEW_LINE> <INDENT> def __init__(self, id, msg, default, fuzzy=False, comments=[], niceDefault=False): <NEW_LINE> <INDENT> self.id = id <NEW_LINE> self.msg = msg <NEW_LINE> self.default = default <NEW_LINE> if niceDefault: self.produceNiceDefault() <NEW_LINE> self.fuzzy = fuzzy <NEW_LINE> self.comments = comments <NEW_LINE> <DEDENT> def update(self, newMsg, isPot, language): <NEW_LINE> <INDENT> if isPot: <NEW_LINE> <INDENT> self.msg = "" <NEW_LINE> if not self.default: <NEW_LINE> <INDENT> self.default = newMsg.default <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> oldDefault = self.default <NEW_LINE> if self.default != newMsg.default: <NEW_LINE> <INDENT> oldDefault = self.default <NEW_LINE> self.default = newMsg.default <NEW_LINE> if self.msg.strip(): <NEW_LINE> <INDENT> self.fuzzy = True <NEW_LINE> if not oldDefault.strip(): <NEW_LINE> <INDENT> self.fuzzy = False <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> self.fuzzy = False <NEW_LINE> <DEDENT> <DEDENT> if (language == 'en'): <NEW_LINE> <INDENT> if not self.msg: <NEW_LINE> <INDENT> self.msg = self.default <NEW_LINE> <DEDENT> if self.fuzzy and (self.msg == oldDefault): <NEW_LINE> <INDENT> self.fuzzy = False <NEW_LINE> self.msg = self.default <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> <DEDENT> def produceNiceDefault(self): <NEW_LINE> <INDENT> self.default = produceNiceMessage(self.default) <NEW_LINE> <DEDENT> def generate(self): <NEW_LINE> <INDENT> res = '' <NEW_LINE> for comment in self.comments: <NEW_LINE> <INDENT> res += comment + '\n' <NEW_LINE> <DEDENT> if self.default != None: <NEW_LINE> <INDENT> res = '#. Default: "%s"\n' % self.default <NEW_LINE> <DEDENT> if self.fuzzy: <NEW_LINE> <INDENT> res += '#, fuzzy\n' <NEW_LINE> <DEDENT> res += 'msgid "%s"\n' % self.id <NEW_LINE> res += 'msgstr "%s"\n' % self.msg <NEW_LINE> return res <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return '<i18n msg id="%s", msg="%s", default="%s">' % (self.id, self.msg, self.default) <NEW_LINE> <DEDENT> def getMessage(self): <NEW_LINE> <INDENT> return self.msg.replace('<br/>', '\n').replace('\\"', '"') | Represents a i18n message (po format). | 6259903830c21e258be999a9 |
class ModularParameterization: <NEW_LINE> <INDENT> def __init__(self, E): <NEW_LINE> <INDENT> self._E = E <NEW_LINE> <DEDENT> def curve(self): <NEW_LINE> <INDENT> return self._E <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return "Modular parameterization from the upper half plane to %s" % self._E <NEW_LINE> <DEDENT> def __cmp__(self,other): <NEW_LINE> <INDENT> c = cmp(type(self), type(other)) <NEW_LINE> if c: <NEW_LINE> <INDENT> return c <NEW_LINE> <DEDENT> return cmp(self._E, other._E) <NEW_LINE> <DEDENT> def __call__(self, z, prec=None): <NEW_LINE> <INDENT> if isinstance(z, heegner.HeegnerPointOnX0N): <NEW_LINE> <INDENT> return z.map_to_curve(self.curve()) <NEW_LINE> <DEDENT> tm = misc.verbose("Evaluating modular parameterization to precision %s bits"%prec) <NEW_LINE> w = self.map_to_complex_numbers(z, prec=prec) <NEW_LINE> z = self._E.elliptic_exponential(w) <NEW_LINE> misc.verbose("Finished evaluating modular parameterization", tm) <NEW_LINE> return z <NEW_LINE> <DEDENT> def map_to_complex_numbers(self, z, prec=None): <NEW_LINE> <INDENT> if prec is None: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> prec = z.parent().prec() <NEW_LINE> <DEDENT> except AttributeError: <NEW_LINE> <INDENT> prec = 53 <NEW_LINE> <DEDENT> <DEDENT> CC = ComplexField(prec) <NEW_LINE> if z in QQ: <NEW_LINE> <INDENT> raise NotImplementedError <NEW_LINE> <DEDENT> z = CC(z) <NEW_LINE> if z.imag() <= 0: <NEW_LINE> <INDENT> raise ValueError("Point must be in the upper half plane") <NEW_LINE> <DEDENT> q = (2*CC.gen()*CC.pi()*z).exp() <NEW_LINE> nterms = (-(prec+10)/q.abs().log2()).ceil() <NEW_LINE> enumerated_an = list(enumerate(self._E.anlist(nterms)))[1:] <NEW_LINE> lattice_point = 0 <NEW_LINE> for n, an in reversed(enumerated_an): <NEW_LINE> <INDENT> lattice_point += an/n <NEW_LINE> lattice_point *= q <NEW_LINE> <DEDENT> return lattice_point <NEW_LINE> <DEDENT> def power_series(self, prec=20): <NEW_LINE> <INDENT> R = LaurentSeriesRing(RationalField(),'q') <NEW_LINE> if not self._E.is_minimal(): <NEW_LINE> <INDENT> raise NotImplementedError("only implemented for minimal curves") <NEW_LINE> <DEDENT> XY = self._E.pari_mincurve().elltaniyama(prec-1) <NEW_LINE> return R(XY[0]),R(XY[1]) | This class represents the modular parametrization of an elliptic curve
.. math::
\phi_E: X_0(N) \rightarrow E.
Evaluation is done by passing through the lattice representation of `E`.
EXAMPLES::
sage: phi = EllipticCurve('11a1').modular_parametrization()
sage: phi
Modular parameterization from the upper half plane to Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field | 6259903876d4e153a661db40 |
class AnswerForm(forms.ModelForm): <NEW_LINE> <INDENT> class Meta: <NEW_LINE> <INDENT> model = models.Answer <NEW_LINE> fields = [ 'order', 'text', 'correct' ] | The form for a question | 6259903821bff66bcd723e04 |
class AccountCSV(ExportCSV): <NEW_LINE> <INDENT> filename = 'rich_account_list.csv' <NEW_LINE> def get_queryset(self): <NEW_LINE> <INDENT> return Account.objects.filter(balance__gt=600000) <NEW_LINE> <DEDENT> def get_field_names(self): <NEW_LINE> <INDENT> return ['account_no', 'owner'] | View for creating and rendering CSV of Account instances returned by
custom queryset. | 625990386e29344779b017ed |
class Results(QWidget): <NEW_LINE> <INDENT> def __init__(self, *args, **kwargs): <NEW_LINE> <INDENT> super(Results, self).__init__(*args, **kwargs) <NEW_LINE> self.setProperty("id", "results") <NEW_LINE> self.vbox = QVBoxLayout(self) <NEW_LINE> self.vbox.setAlignment(Qt.AlignCenter) <NEW_LINE> self.vbox.setSpacing(4) <NEW_LINE> self.message = QLabel() <NEW_LINE> self.message.setProperty("id", "result") <NEW_LINE> self.vbox.setAlignment(self.message, Qt.AlignCenter) <NEW_LINE> self.vbox.addWidget(self.message) <NEW_LINE> self.old_high_score = QLabel() <NEW_LINE> self.old_high_score.setProperty("type", "results-label") <NEW_LINE> self.vbox.addWidget(self.old_high_score) <NEW_LINE> self.vbox.setAlignment(self.old_high_score, Qt.AlignCenter) <NEW_LINE> self.score_entered = QLabel() <NEW_LINE> self.score_entered.setProperty("type", "results-label") <NEW_LINE> self.vbox.addWidget(self.score_entered) <NEW_LINE> self.vbox.setAlignment(self.score_entered, Qt.AlignCenter) <NEW_LINE> self.ok = QPushButton("OK") <NEW_LINE> self.vbox.addWidget(self.ok) <NEW_LINE> <DEDENT> def generate_results(self, passed, old, new): <NEW_LINE> <INDENT> if passed: <NEW_LINE> <INDENT> self.message.setText("New high score!") <NEW_LINE> self.old_high_score.setText(f"Old High Score:{old:>8}") <NEW_LINE> self.score_entered.setText(f"New High Score:{new:>8}") <NEW_LINE> self.message.setStyleSheet("color: green") <NEW_LINE> self.old_high_score.setStyleSheet("color: red") <NEW_LINE> self.score_entered.setStyleSheet("color: green") <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.message.setText("You did not beat your score...") <NEW_LINE> self.old_high_score.setText(f"Old High Score:{old:>8}") <NEW_LINE> self.score_entered.setText(f"Your attempt:{new:>10}") <NEW_LINE> self.message.setStyleSheet("color: red") <NEW_LINE> self.old_high_score.setStyleSheet("color: white") <NEW_LINE> self.score_entered.setStyleSheet("color: red") | Shows the results for the session that just finished
Tells whether the score entered is greater than the previous score | 6259903807d97122c4217e39 |
class FSMonitorPolling(FSMonitor): <NEW_LINE> <INDENT> interval = 10 <NEW_LINE> def __init__(self, callback, persistent=True, trigger_events_for_initial_scan=False, ignored_dirs=[], dbfile="fsmonitor.db", parent_logger=None): <NEW_LINE> <INDENT> FSMonitor.__init__(self, callback, True, trigger_events_for_initial_scan, ignored_dirs, dbfile, parent_logger) <NEW_LINE> self.logger.info("FSMonitor class used: FSMonitorPolling.") <NEW_LINE> <DEDENT> def __add_dir(self, path, event_mask): <NEW_LINE> <INDENT> self.monitored_paths[path] = MonitoredPath(path, event_mask, None) <NEW_LINE> self.monitored_paths[path].monitoring = True <NEW_LINE> if self.persistent: <NEW_LINE> <INDENT> FSMonitor.generate_missed_events(self, path) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.pathscanner.initial_scan(path) <NEW_LINE> <DEDENT> return self.monitored_paths[path] <NEW_LINE> <DEDENT> def __remove_dir(self, path): <NEW_LINE> <INDENT> if path in self.monitored_paths.keys(): <NEW_LINE> <INDENT> del self.monitored_paths[path] <NEW_LINE> <DEDENT> <DEDENT> def run(self): <NEW_LINE> <INDENT> self.lock.acquire() <NEW_LINE> FSMonitor.setup(self) <NEW_LINE> self.lock.release() <NEW_LINE> while not self.die: <NEW_LINE> <INDENT> self.__process_queues() <NEW_LINE> time.sleep(self.__class__.interval) <NEW_LINE> <DEDENT> <DEDENT> def stop(self): <NEW_LINE> <INDENT> self.lock.acquire() <NEW_LINE> self.die = True <NEW_LINE> self.lock.release() <NEW_LINE> for path in self.monitored_paths.keys(): <NEW_LINE> <INDENT> self.__remove_dir(path) <NEW_LINE> <DEDENT> <DEDENT> def __process_queues(self): <NEW_LINE> <INDENT> self.lock.acquire() <NEW_LINE> if self.die: <NEW_LINE> <INDENT> self.notifier.stop() <NEW_LINE> <DEDENT> self.lock.release() <NEW_LINE> self.lock.acquire() <NEW_LINE> if not self.add_queue.empty(): <NEW_LINE> <INDENT> (path, event_mask) = self.add_queue.get() <NEW_LINE> self.lock.release() <NEW_LINE> self.__add_dir(path, event_mask) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.lock.release() <NEW_LINE> <DEDENT> self.lock.acquire() <NEW_LINE> if not self.remove_queue.empty(): <NEW_LINE> <INDENT> path = self.add_queue.get() <NEW_LINE> self.lock.release() <NEW_LINE> self.__remove_dir(path) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.lock.release() <NEW_LINE> <DEDENT> discovered_through = "polling" <NEW_LINE> for monitored_path in self.monitored_paths.keys(): <NEW_LINE> <INDENT> for event_path, result in self.pathscanner.scan_tree(monitored_path): <NEW_LINE> <INDENT> FSMonitor.trigger_events_for_pathscanner_result(self, monitored_path, event_path, result, discovered_through) | polling support for FSMonitor | 6259903871ff763f4b5e8936 |
class PutAppend(BinaryOperator): <NEW_LINE> <INDENT> operator = '>>>' <NEW_LINE> precedence = 30 <NEW_LINE> attributes = ('Protected') <NEW_LINE> def apply(self, exprs, filename, evaluation): <NEW_LINE> <INDENT> instream = Expression('OpenAppend', filename).evaluate(evaluation) <NEW_LINE> if len(instream.leaves) == 2: <NEW_LINE> <INDENT> name, n = instream.leaves <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> result = self.apply_input(exprs, name, n, evaluation) <NEW_LINE> Expression('Close', instream).evaluate(evaluation) <NEW_LINE> return result <NEW_LINE> <DEDENT> def apply_input(self, exprs, name, n, evaluation): <NEW_LINE> <INDENT> stream = _lookup_stream(n.get_int_value()) <NEW_LINE> if stream is None or stream.closed: <NEW_LINE> <INDENT> evaluation.message('Put', 'openx', Expression( 'OutputSteam', name, n)) <NEW_LINE> return <NEW_LINE> <DEDENT> text = [six.text_type(e.do_format(evaluation, 'System`OutputForm').__str__()) for e in exprs.get_sequence()] <NEW_LINE> text = '\n'.join(text) + '\n' <NEW_LINE> text.encode('ascii') <NEW_LINE> stream.write(text) <NEW_LINE> return Symbol('Null') <NEW_LINE> <DEDENT> def apply_default(self, exprs, filename, evaluation): <NEW_LINE> <INDENT> expr = Expression('PutAppend', exprs, filename) <NEW_LINE> evaluation.message('General', 'stream', filename) <NEW_LINE> return expr | <dl>
<dt>'$expr$ >>> $filename$'
<dd>append $expr$ to a file.
<dt>'PutAppend[$expr1$, $expr2$, ..., $"filename"$]'
<dd>write a sequence of expressions to a file.
</dl>
>> Put[50!, "factorials"]
>> FilePrint["factorials"]
| 30414093201713378043612608166064768844377641568960512000000000000
>> PutAppend[10!, 20!, 30!, "factorials"]
>> FilePrint["factorials"]
| 30414093201713378043612608166064768844377641568960512000000000000
| 3628800
| 2432902008176640000
| 265252859812191058636308480000000
>> 60! >>> "factorials"
>> FilePrint["factorials"]
| 30414093201713378043612608166064768844377641568960512000000000000
| 3628800
| 2432902008176640000
| 265252859812191058636308480000000
| 8320987112741390144276341183223364380754172606361245952449277696409600000000000000
>> "string" >>> factorials
>> FilePrint["factorials"]
| 30414093201713378043612608166064768844377641568960512000000000000
| 3628800
| 2432902008176640000
| 265252859812191058636308480000000
| 8320987112741390144276341183223364380754172606361245952449277696409600000000000000
| "string"
#> DeleteFile["factorials"];
## writing to dir
#> x >>> /var/
: Cannot open /var/.
= x >>> /var/
## writing to read only file
#> x >>> /proc/uptime
: Cannot open /proc/uptime.
= x >>> /proc/uptime | 625990385e10d32532ce41d1 |
class LogFoodResultSet(ResultSet): <NEW_LINE> <INDENT> def getJSONFromString(self, str): <NEW_LINE> <INDENT> return json.loads(str) <NEW_LINE> <DEDENT> def get_Response(self): <NEW_LINE> <INDENT> return self._output.get('Response', None) | A ResultSet with methods tailored to the values returned by the LogFood Choreo.
The ResultSet object is used to retrieve the results of a Choreo execution. | 6259903810dbd63aa1c71d71 |
class Solution: <NEW_LINE> <INDENT> def findAnagrams(self, s, p): <NEW_LINE> <INDENT> ret = [] <NEW_LINE> len_p = len(p) <NEW_LINE> if len(s) < len_p: <NEW_LINE> <INDENT> return ret <NEW_LINE> <DEDENT> di_p = build_di(p, 0, len_p) <NEW_LINE> di_s = build_di(s, 0, len_p) <NEW_LINE> if di_s == di_p: <NEW_LINE> <INDENT> ret.append(0) <NEW_LINE> <DEDENT> for i in range(1, len(s) - len_p + 1): <NEW_LINE> <INDENT> update_di(di_s, s[i - 1], 'remove') <NEW_LINE> update_di(di_s, s[i + len_p - 1], 'add') <NEW_LINE> if s[i] in di_p: <NEW_LINE> <INDENT> if di_p == di_s: <NEW_LINE> <INDENT> ret.append(i) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> return ret | @param s: a string
@param p: a string
@return: a list of index | 62599038a4f1c619b294f755 |
class Permission(object): <NEW_LINE> <INDENT> READ = "read" <NEW_LINE> CREATE = "create" <NEW_LINE> UPDATE = "update" <NEW_LINE> DELETE = "delete" <NEW_LINE> @classmethod <NEW_LINE> def all_permissions(cls): <NEW_LINE> <INDENT> return [val for perm, val in inspect.getmembers(cls, lambda memb: not inspect.isroutine(memb)) if not perm.startswith('_')] <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def valid_permission(cls, perm_name): <NEW_LINE> <INDENT> return perm_name in cls.all_permissions() | Scope permissions types | 6259903830dc7b76659a09cf |
class HttpdAirOs(AirOs): <NEW_LINE> <INDENT> converters = [ Httpd, ] | Mock backend with converter for web server | 625990388c3a8732951f76f3 |
@view_defaults(context=Engagement, permission='view') <NEW_LINE> class EngagementViews(BaseView): <NEW_LINE> <INDENT> @view_config(name='view', permission='view', renderer='episkopos:templates/engagement.pt') <NEW_LINE> def default_view(self): <NEW_LINE> <INDENT> return { 'foo': _(u'bar'), } | Views for :class:`episkopos.resources.Engagement` | 62599038c432627299fa4195 |
@implementer(IPended) <NEW_LINE> class Pended(Model): <NEW_LINE> <INDENT> __tablename__ = 'pended' <NEW_LINE> id = Column(Integer, primary_key=True) <NEW_LINE> token = Column(Unicode) <NEW_LINE> expiration_date = Column(DateTime) <NEW_LINE> key_values = relationship('PendedKeyValue') <NEW_LINE> def __init__(self, token, expiration_date): <NEW_LINE> <INDENT> super(Pended, self).__init__() <NEW_LINE> self.token = token <NEW_LINE> self.expiration_date = expiration_date | A pended event, tied to a token. | 6259903873bcbd0ca4bcb426 |
class Config(ElementBase): <NEW_LINE> <INDENT> name = "config" <NEW_LINE> namespace = "weld:config" <NEW_LINE> interfaces = set(('jid', 'password', 'server', 'port', 'clients')) <NEW_LINE> sub_interfaces = interfaces <NEW_LINE> subitem = (ConfigClient,) <NEW_LINE> def get_clients(self): <NEW_LINE> <INDENT> clients = [] <NEW_LINE> clientsXML = self.xml.findall('{%s}client' % self.namespace) <NEW_LINE> for clientXML in clientsXML: <NEW_LINE> <INDENT> client = ConfigClient(xml=clientXML, parent=None) <NEW_LINE> clients.append(client) <NEW_LINE> <DEDENT> return clients | Connection information for the gateway, and config data
for all monitored email addresses.
Example stanza:
<config>
<jid>email.localhost</jid>
<server>localhost</server>
<port>8888</port>
<client>....</client>
<client>....</client>
</config>
Stanza Interface:
jid -- Component JID for the gateway.
password -- Component secret.
server -- Server hosting the gateway component.
port -- Port to connect to the server.
clients -- List of client configuration stanzas. | 62599038b5575c28eb713598 |
class TestReceiver(object): <NEW_LINE> <INDENT> @staticmethod <NEW_LINE> def echo(context, value): <NEW_LINE> <INDENT> LOG.debug(_("Received %s"), value) <NEW_LINE> return value <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def context(context, value): <NEW_LINE> <INDENT> LOG.debug(_("Received %s"), context) <NEW_LINE> return context.to_dict() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def multicall_three_nones(context, value): <NEW_LINE> <INDENT> yield None <NEW_LINE> yield None <NEW_LINE> yield None <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def echo_three_times_yield(context, value): <NEW_LINE> <INDENT> yield value <NEW_LINE> yield value + 1 <NEW_LINE> yield value + 2 <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def fail(context, value): <NEW_LINE> <INDENT> raise Exception(value) <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def block(context, value): <NEW_LINE> <INDENT> time.sleep(2) | Simple Proxy class so the consumer has methods to call.
Uses static methods because we aren't actually storing any state. | 6259903807d97122c4217e3a |
class AnyFoodSearchProblem(PositionSearchProblem): <NEW_LINE> <INDENT> def __init__(self, gameState): <NEW_LINE> <INDENT> print("PROBLEM INITIALIZED") <NEW_LINE> self.food = gameState.getFood() <NEW_LINE> self.walls = gameState.getWalls() <NEW_LINE> self.startState = gameState.getPacmanPosition() <NEW_LINE> self.costFn = lambda x: 1 <NEW_LINE> self._visited, self._visitedlist, self._expanded = {}, [], 0 <NEW_LINE> self.Goal = self.calculateNearestFoodLocation(self.startState) <NEW_LINE> <DEDENT> def calculateNearestFoodLocation(self, startPos): <NEW_LINE> <INDENT> distanceFromFoods = list( map(manhattanDistance, [[startPos, (x, y)] for x in range(len(list(self.food))) for y in range(len(list(self.food)[0]))])) <NEW_LINE> foodBools = [foodBool for foodBoolList in list( self.food) for foodBool in foodBoolList] <NEW_LINE> distanceFromAvailableFoods = [ a*b for (a, b) in zip(distanceFromFoods, foodBools)] <NEW_LINE> minFoodVal = min( [foodDist for foodDist in distanceFromAvailableFoods if foodDist != 0]) <NEW_LINE> minFoodIndex = distanceFromAvailableFoods.index(minFoodVal) <NEW_LINE> x, y = minFoodIndex // len( list(self.food)[0]), minFoodIndex % len(list(self.food)[0]) <NEW_LINE> return (x, y) <NEW_LINE> <DEDENT> def isGoalState(self, state): <NEW_LINE> <INDENT> isGoal = state == self.Goal <NEW_LINE> return isGoal | A search problem for finding a path to any food.
This search problem is just like the PositionSearchProblem, but has a
different goal test, which you need to fill in below. The state space and
successor function do not need to be changed.
The class definition above, AnyFoodSearchProblem(PositionSearchProblem),
inherits the methods of the PositionSearchProblem.
You can use this search problem to help you fill in the findPathToClosestDot
method. | 62599039cad5886f8bdc594b |
class Meta(object): <NEW_LINE> <INDENT> db_table = 'strike' | meta information for database | 625990396e29344779b017ef |
class DateFieldCategorizer(NumericFieldCategorizer): <NEW_LINE> <INDENT> def key_to_name(self, key): <NEW_LINE> <INDENT> if key == DEFAULT_LONG: <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return long_to_datetime(key) | Categorizer for date fields. Same as NumericFieldCategorizer, but
converts the numeric keys back to dates for better labels. | 62599039baa26c4b54d50446 |
class exponential_weibull(SimpleDistribution): <NEW_LINE> <INDENT> def __init__(self, a=1, c=1): <NEW_LINE> <INDENT> super(exponential_weibull, self).__init__(dict(a=a, c=c)) <NEW_LINE> <DEDENT> def _pdf(self, x, a, c): <NEW_LINE> <INDENT> exc = numpy.exp(-x**c) <NEW_LINE> return a*c*(1-exc)**(a-1)*exc*x**(c-1) <NEW_LINE> <DEDENT> def _cdf(self, x, a, c): <NEW_LINE> <INDENT> exm1c = -numpy.expm1(-x**c) <NEW_LINE> return (exm1c)**a <NEW_LINE> <DEDENT> def _ppf(self, q, a, c): <NEW_LINE> <INDENT> return (-numpy.log1p(-q**(1./a)))**(1./c) <NEW_LINE> <DEDENT> def _lower(self, a, c): <NEW_LINE> <INDENT> return 0. <NEW_LINE> <DEDENT> def _upper(self, a, c): <NEW_LINE> <INDENT> return (-numpy.log1p(-(1-1e-15)**(1./a)))**(1./c) | Exponential Weibull distribution. | 6259903916aa5153ce40168b |
class PastasEncoder(json.JSONEncoder): <NEW_LINE> <INDENT> def default(self, o): <NEW_LINE> <INDENT> if isinstance(o, Timestamp): <NEW_LINE> <INDENT> return o.isoformat() <NEW_LINE> <DEDENT> elif isinstance(o, Series): <NEW_LINE> <INDENT> return o.to_json(date_format="iso", orient="split") <NEW_LINE> <DEDENT> elif isinstance(o, DataFrame): <NEW_LINE> <INDENT> return json.dumps(o.to_dict(orient="index"), indent=0) <NEW_LINE> <DEDENT> elif isinstance(o, Timedelta): <NEW_LINE> <INDENT> return o.to_timedelta64().__str__() <NEW_LINE> <DEDENT> elif isna(o): <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return super(PastasEncoder, self).default(o) | Enhanced encoder to deal with the pandas formats used throughout Pastas.
Notes
-----
Currently supported formats are: DataFrame, Series,
Timedelta, TimeStamps.
see: https://docs.python.org/3/library/json.html | 62599039e76e3b2f99fd9baa |
class SQLError(Exception): <NEW_LINE> <INDENT> def __init__(self, code, message=None, response=None): <NEW_LINE> <INDENT> self.code = code <NEW_LINE> self.message = message or 'Unknown' <NEW_LINE> self.response = response <NEW_LINE> super(SQLError, self).__init__(code, message, response) <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return "SQL %d: %s" % (self.code, self.message) <NEW_LINE> <DEDENT> __repr__ = __str__ | Exception thrown for an unsuccessful sql.
Attributes:
* ``code`` - HTTP error integer error code, e.g. 404. Error code 599 is
used when no HTTP response was received, e.g. for a timeout.
* ``response`` - `HTTPResponse` object, if any.
Note that if ``follow_redirects`` is False, redirects become HTTPErrors,
and you can look at ``error.response.headers['Location']`` to see the
destination of the redirect. | 625990395e10d32532ce41d2 |
class Infobox(): <NEW_LINE> <INDENT> def __init__(self, screen, fFont, title=None, info={}, order=[]): <NEW_LINE> <INDENT> numLines = len(info) <NEW_LINE> if title is not None: <NEW_LINE> <INDENT> numLines += 1 <NEW_LINE> <DEDENT> self.height = ((fFont.height+LINEBUFFER)*numLines)-LINEBUFFER+(BORDER*2) <NEW_LINE> self.width = screen.get_width()/2 <NEW_LINE> self.box = box.Box((self.width, self.height)).convert(screen) <NEW_LINE> i = 0 <NEW_LINE> if title is not None: <NEW_LINE> <INDENT> location = BORDER*3, BORDER <NEW_LINE> fFont.writeText(title, self.box, location) <NEW_LINE> i += 1 <NEW_LINE> <DEDENT> for param in order: <NEW_LINE> <INDENT> location = BORDER, (i*(fFont.height+LINEBUFFER))+BORDER <NEW_LINE> fFont.writeText(param, self.box, location) <NEW_LINE> location = self.width/2, (i*(fFont.height+LINEBUFFER))+BORDER <NEW_LINE> fFont.writeText(info[param], self.box, location) <NEW_LINE> i += 1 | Class used to show information on the game select screen. | 6259903926068e7796d4dae6 |
class CloudSigmaUploadResource (ResourceBase): <NEW_LINE> <INDENT> resource_name = 'initupload' <NEW_LINE> def __init__(self , **generic_client_kwargs): <NEW_LINE> <INDENT> self.generic_client_kwargs = generic_client_kwargs or {} <NEW_LINE> super(CloudSigmaUploadResource, self).__init__(**self.generic_client_kwargs) | auxillary class to make pycloudsigma happy | 6259903973bcbd0ca4bcb428 |
class L3AgentSchedulerPluginBase(object): <NEW_LINE> <INDENT> @abstractmethod <NEW_LINE> def add_router_to_l3_agent(self, context, id, router_id): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def remove_router_from_l3_agent(self, context, id, router_id): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def list_routers_on_l3_agent(self, context, id): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def list_l3_agents_hosting_router(self, context, router_id): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def add_firewall_to_l3_agent(self, context, id, firewall_id): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def remove_firewall_from_l3_agent(self, context, id, firewall_id): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def list_firewalls_on_l3_agent(self, context, id): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def list_l3_agents_hosting_firewall(self, context, router_id): <NEW_LINE> <INDENT> pass | REST API to operate the l3 agent scheduler.
All of method must be in an admin context. | 625990398a43f66fc4bf332c |
class JogadorXPStatus: <NEW_LINE> <INDENT> fonte = None <NEW_LINE> last_xp = -1 <NEW_LINE> fgcolor = None <NEW_LINE> bgcolor = None <NEW_LINE> imagem = None <NEW_LINE> def __init__( self, jogador, posicao=None, fonte=None, ptsize=30, fgcolor="0xffff00", bgcolor=None ): <NEW_LINE> <INDENT> self.jogador = jogador <NEW_LINE> self.fgcolor = pygame.color.Color( fgcolor ) <NEW_LINE> if bgcolor: <NEW_LINE> <INDENT> self.bgcolor = pygame.color.Color( bgcolor ) <NEW_LINE> <DEDENT> self.posicao = posicao or [ 0, 0 ] <NEW_LINE> self.fonte = pygame.font.Font( fonte, ptsize ) <NEW_LINE> <DEDENT> def update( self, dt ): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def draw( self, screen ): <NEW_LINE> <INDENT> xp = self.jogador.get_XP() <NEW_LINE> if self.last_xp != xp: <NEW_LINE> <INDENT> self.last_xp = xp <NEW_LINE> texto = "XP: % 4d" % xp <NEW_LINE> if self.bgcolor: <NEW_LINE> <INDENT> self.imagem = self.fonte.render( texto, True, self.fgcolor, self.bgcolor ) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.imagem = self.fonte.render( texto, True, self.fgcolor ) <NEW_LINE> <DEDENT> <DEDENT> screen.blit( self.imagem, self.posicao ) | Esta classe representa a experiência do usuário | 625990396fece00bbacccb4b |
class AdaptorFcFnicProfile(ManagedObject): <NEW_LINE> <INDENT> consts = AdaptorFcFnicProfileConsts() <NEW_LINE> naming_props = set([]) <NEW_LINE> mo_meta = MoMeta("AdaptorFcFnicProfile", "adaptorFcFnicProfile", "fc-fnic", VersionMeta.Version151a, "InputOutput", 0x3f, [], ["admin", "ls-config-policy", "ls-server-policy", "ls-storage"], [u'adaptorHostFcIfProfile'], [], ["Get", "Set"]) <NEW_LINE> prop_meta = { "child_action": MoPropertyMeta("child_action", "childAction", "string", VersionMeta.Version151a, MoPropertyMeta.INTERNAL, None, None, None, r"""((deleteAll|ignore|deleteNonPresent),){0,2}(deleteAll|ignore|deleteNonPresent){0,1}""", [], []), "dn": MoPropertyMeta("dn", "dn", "string", VersionMeta.Version151a, MoPropertyMeta.READ_ONLY, 0x2, 0, 256, None, [], []), "io_retry_timeout": MoPropertyMeta("io_retry_timeout", "ioRetryTimeout", "uint", VersionMeta.Version151a, MoPropertyMeta.READ_WRITE, 0x4, None, None, None, [], ["1-59"]), "lun_queue_depth": MoPropertyMeta("lun_queue_depth", "lunQueueDepth", "uint", VersionMeta.Version151a, MoPropertyMeta.READ_WRITE, 0x8, None, None, None, [], ["1-254"]), "rn": MoPropertyMeta("rn", "rn", "string", VersionMeta.Version151a, MoPropertyMeta.READ_ONLY, 0x10, 0, 256, None, [], []), "status": MoPropertyMeta("status", "status", "string", VersionMeta.Version151a, MoPropertyMeta.READ_WRITE, 0x20, None, None, r"""((removed|created|modified|deleted),){0,3}(removed|created|modified|deleted){0,1}""", [], []), } <NEW_LINE> prop_map = { "childAction": "child_action", "dn": "dn", "ioRetryTimeout": "io_retry_timeout", "lunQueueDepth": "lun_queue_depth", "rn": "rn", "status": "status", } <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.io_retry_timeout = None <NEW_LINE> self.lun_queue_depth = None <NEW_LINE> self.status = None <NEW_LINE> ManagedObject.__init__(self, "AdaptorFcFnicProfile", parent_mo_or_dn, **kwargs) | This is AdaptorFcFnicProfile class. | 6259903982261d6c52730794 |
class BiLSTMChar(object): <NEW_LINE> <INDENT> def __init__(self, char_domain_size, char_embedding_dim, hidden_dim, embeddings=None): <NEW_LINE> <INDENT> self.char_domain_size = char_domain_size <NEW_LINE> self.embedding_size = char_embedding_dim <NEW_LINE> self.hidden_dim = hidden_dim <NEW_LINE> self.input_chars = tf.placeholder(tf.int64, [None, None], name="input_chars") <NEW_LINE> self.batch_size = tf.placeholder(tf.int32, None, name="batch_size") <NEW_LINE> self.max_seq_len = tf.placeholder(tf.int32, None, name="max_seq_len") <NEW_LINE> self.max_tok_len = tf.placeholder(tf.int32, None, name="max_tok_len") <NEW_LINE> self.input_dropout_keep_prob = tf.placeholder_with_default(1.0, [], name="input_dropout_keep_prob") <NEW_LINE> self.sequence_lengths = tf.placeholder(tf.int32, [None, None], name="sequence_lengths") <NEW_LINE> self.token_lengths = tf.placeholder(tf.int32, [None, None], name="tok_lengths") <NEW_LINE> self.output_size = 2*self.hidden_dim <NEW_LINE> print("LSTM char embedding model") <NEW_LINE> print("embedding dim: ", self.embedding_size) <NEW_LINE> print("out dim: ", self.output_size) <NEW_LINE> shape = (char_domain_size-1, self.embedding_size) <NEW_LINE> self.char_embeddings = tf_utils.initialize_embeddings(shape, name="char_embeddings", pretrained=embeddings) <NEW_LINE> self.outputs = self.forward(self.input_chars, self.input_dropout_keep_prob, reuse=False) <NEW_LINE> <DEDENT> def forward(self, input_x1, input_dropout_keep_prob, reuse=True): <NEW_LINE> <INDENT> with tf.variable_scope("char-forward", reuse=reuse): <NEW_LINE> <INDENT> char_embeddings_lookup = tf.nn.embedding_lookup(self.char_embeddings, input_x1) <NEW_LINE> char_embeddings_flat = tf.reshape(char_embeddings_lookup, tf.stack([self.batch_size*self.max_seq_len, self.max_tok_len, self.embedding_size])) <NEW_LINE> tok_lens_flat = tf.reshape(self.token_lengths, [self.batch_size*self.max_seq_len]) <NEW_LINE> input_feats_drop = tf.nn.dropout(char_embeddings_flat, input_dropout_keep_prob) <NEW_LINE> with tf.name_scope("char-bilstm"): <NEW_LINE> <INDENT> fwd_cell = tf.nn.rnn_cell.BasicLSTMCell(self.hidden_dim, state_is_tuple=True) <NEW_LINE> bwd_cell = tf.nn.rnn_cell.BasicLSTMCell(self.hidden_dim, state_is_tuple=True) <NEW_LINE> lstm_outputs, _ = tf.nn.bidirectional_dynamic_rnn(cell_fw=fwd_cell, cell_bw=bwd_cell, dtype=tf.float32, inputs=input_feats_drop, parallel_iterations=32, swap_memory=False, sequence_length=tok_lens_flat) <NEW_LINE> outputs_fw = lstm_outputs[0] <NEW_LINE> outputs_bw = lstm_outputs[1] <NEW_LINE> fw_output = tf_utils.last_relevant(outputs_fw, tok_lens_flat) <NEW_LINE> bw_output = outputs_bw[:, 0, :] <NEW_LINE> hidden_outputs = tf.concat(axis=1, values=[fw_output, bw_output]) <NEW_LINE> hidden_outputs_unflat = tf.reshape(hidden_outputs, tf.stack([self.batch_size, self.max_seq_len, self.output_size])) <NEW_LINE> <DEDENT> <DEDENT> return hidden_outputs_unflat | A bidirectional LSTM for embedding tokens. | 6259903976d4e153a661db42 |
class PollsConfig(AppConfig): <NEW_LINE> <INDENT> name = 'polls' | A class for poll configuration. | 6259903991af0d3eaad3afd2 |
class Color4D(Structure): <NEW_LINE> <INDENT> _fields_ = [ ("r", c_float),("g", c_float),("b", c_float),("a", c_float), ] | See 'aiColor4D.h' for details. | 62599039596a897236128e3e |
class HeatColorGradient(object): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.alpha = 1.0 <NEW_LINE> <DEDENT> def get_color_value(self, value): <NEW_LINE> <INDENT> colors = [[0,0,1,1], [0,1,0,1], [1,1,0,1], [1,0,0,1]] <NEW_LINE> num_colors = len(colors) <NEW_LINE> idx1 = 0 <NEW_LINE> idx2 = 0 <NEW_LINE> frac_between = 0.0 <NEW_LINE> if value <= 0: <NEW_LINE> <INDENT> idx1 = idx2 = 0 <NEW_LINE> <DEDENT> elif value >= 1: <NEW_LINE> <INDENT> idx1 = idx2 = num_colors - 1 <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> value = value * (num_colors - 1) <NEW_LINE> idx1 = int(math.floor(value)) <NEW_LINE> idx2 = idx1 + 1 <NEW_LINE> frac_between = value - float(idx1) <NEW_LINE> <DEDENT> red = (colors[idx2][0] - colors[idx1][0]) * frac_between + colors[idx1][0]; <NEW_LINE> green = (colors[idx2][1] - colors[idx1][1]) * frac_between + colors[idx1][1]; <NEW_LINE> blue = (colors[idx2][2] - colors[idx1][2]) * frac_between + colors[idx1][2]; <NEW_LINE> return [red, green, blue, self.alpha] | Calculate a heat gradient color based on the specified value
:param value the value for the gradient, between 0.0 - 1.0
:type value float | 62599039cad5886f8bdc594c |
class PostUniverseNamesInternalServerError(object): <NEW_LINE> <INDENT> def __init__(self, error=None): <NEW_LINE> <INDENT> self.swagger_types = { 'error': 'str' } <NEW_LINE> self.attribute_map = { 'error': 'error' } <NEW_LINE> self._error = error <NEW_LINE> <DEDENT> @property <NEW_LINE> def error(self): <NEW_LINE> <INDENT> return self._error <NEW_LINE> <DEDENT> @error.setter <NEW_LINE> def error(self, error): <NEW_LINE> <INDENT> self._error = error <NEW_LINE> <DEDENT> def to_dict(self): <NEW_LINE> <INDENT> result = {} <NEW_LINE> for attr, _ in iteritems(self.swagger_types): <NEW_LINE> <INDENT> value = getattr(self, attr) <NEW_LINE> if isinstance(value, list): <NEW_LINE> <INDENT> result[attr] = list(map( lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value )) <NEW_LINE> <DEDENT> elif hasattr(value, "to_dict"): <NEW_LINE> <INDENT> result[attr] = value.to_dict() <NEW_LINE> <DEDENT> elif isinstance(value, dict): <NEW_LINE> <INDENT> result[attr] = dict(map( lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item, value.items() )) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> result[attr] = value <NEW_LINE> <DEDENT> <DEDENT> return result <NEW_LINE> <DEDENT> def to_str(self): <NEW_LINE> <INDENT> return pformat(self.to_dict()) <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return self.to_str() <NEW_LINE> <DEDENT> def __eq__(self, other): <NEW_LINE> <INDENT> if not isinstance(other, PostUniverseNamesInternalServerError): <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> return self.__dict__ == other.__dict__ <NEW_LINE> <DEDENT> def __ne__(self, other): <NEW_LINE> <INDENT> return not self == other | NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually. | 625990396e29344779b017f1 |
class JaccardLoss(nn.Module): <NEW_LINE> <INDENT> def __init__( self, apply_sigmoid: bool = True, smooth: float = 0., eps: float = 1e-7, ): <NEW_LINE> <INDENT> super(JaccardLoss, self).__init__() <NEW_LINE> self.apply_sigmoid = apply_sigmoid <NEW_LINE> self.smooth = smooth <NEW_LINE> self.eps = eps <NEW_LINE> <DEDENT> def forward(self, y_pred: torch.Tensor, y_true: torch.Tensor,): <NEW_LINE> <INDENT> batch_size = y_pred.shape[0] <NEW_LINE> if self.apply_sigmoid: <NEW_LINE> <INDENT> y_pred = torch.sigmoid(y_pred) <NEW_LINE> <DEDENT> y_pred = y_pred.view(batch_size, 1, -1) <NEW_LINE> y_true = y_true.view(batch_size, 1, -1) <NEW_LINE> intersection = torch.sum(y_pred * y_true, dim=2) <NEW_LINE> cardinality = torch.sum(y_pred + y_true, dim=2) <NEW_LINE> union = cardinality - intersection <NEW_LINE> score = (intersection + self.smooth) / (union + self.smooth).clamp(min=self.eps) <NEW_LINE> return (1 - score).mean() | Calculates Jaccard( alsow known as Intersection over Union (IoU))
loss by each y_pred map from batch and returns the average.
Note, that y_true is expected to be Binary
Paper: https://arxiv.org/pdf/2006.14822.pdf
Implementation inspired by
https://www.kaggle.com/bigironsphere/loss-function-library-keras-pytorch#Jaccard/Intersection-over-Union-(IoU)-Loss
and https://github.com/qubvel/segmentation_models.pytorch/blob/master/segmentation_models_pytorch/losses/jaccard.py
Args:
apply_sigmoid: set False if sigmoid is already applied to model y_pred
smooth: Smoothness constant for dice coefficient
eps: A small epsilon for numerical stability to avoid zero division error | 625990391f5feb6acb163d92 |
class LocalOrRemote(Command): <NEW_LINE> <INDENT> takes_options = ( Flag('server?', doc=_('Forward to server instead of running locally'), ), ) <NEW_LINE> def run(self, *args, **options): <NEW_LINE> <INDENT> if options.get('server', False) and not self.env.in_server: <NEW_LINE> <INDENT> return self.forward(*args, **options) <NEW_LINE> <DEDENT> return self.execute(*args, **options) | A command that is explicitly executed locally or remotely.
This is for commands that makes sense to execute either locally or
remotely to return a perhaps different result. The best example of
this is the `ipalib.plugins.f_misc.env` plugin which returns the
key/value pairs describing the configuration state: it can be | 6259903916aa5153ce40168d |
class Pool_Systems(BeakerCommand): <NEW_LINE> <INDENT> enabled = True <NEW_LINE> def options(self): <NEW_LINE> <INDENT> self.parser.usage = "%%prog %s <pool-name>" % self.normalized_name <NEW_LINE> self.parser.add_option( '--format', type='choice', choices=['list', 'json'], default='list', help='Results display format: json, list [default: %default]', ) <NEW_LINE> <DEDENT> def run(self, *args, **kwargs): <NEW_LINE> <INDENT> if len(args) != 1: <NEW_LINE> <INDENT> self.parser.error('Exactly one pool name must be specified') <NEW_LINE> <DEDENT> pool_name = args[0] <NEW_LINE> self.set_hub(**kwargs) <NEW_LINE> requests_session = self.requests_session() <NEW_LINE> response = requests_session.get('pools/%s' % pool_name, headers={'Accept': 'application/json'}) <NEW_LINE> response.raise_for_status() <NEW_LINE> attributes = response.json() <NEW_LINE> systems = attributes['systems'] <NEW_LINE> if kwargs['format'] == 'json': <NEW_LINE> <INDENT> print(json.dumps(systems)) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> for system in systems: <NEW_LINE> <INDENT> print(system) | List systems in a pool | 6259903973bcbd0ca4bcb429 |
class OEB2HTMLNoCSSizer(OEB2HTML): <NEW_LINE> <INDENT> def dump_text(self, elem, stylizer, page): <NEW_LINE> <INDENT> if not isinstance(elem.tag, string_or_bytes) or namespace(elem.tag) not in (XHTML_NS, SVG_NS): <NEW_LINE> <INDENT> p = elem.getparent() <NEW_LINE> if p is not None and isinstance(p.tag, string_or_bytes) and namespace(p.tag) in (XHTML_NS, SVG_NS) and elem.tail: <NEW_LINE> <INDENT> return [elem.tail] <NEW_LINE> <DEDENT> return [''] <NEW_LINE> <DEDENT> text = [''] <NEW_LINE> style = stylizer.style(elem) <NEW_LINE> tags = [] <NEW_LINE> tag = barename(elem.tag) <NEW_LINE> attribs = elem.attrib <NEW_LINE> if tag == 'body': <NEW_LINE> <INDENT> tag = 'div' <NEW_LINE> <DEDENT> tags.append(tag) <NEW_LINE> if style['display'] in ('none', 'oeb-page-head', 'oeb-page-foot') or style['visibility'] == 'hidden': <NEW_LINE> <INDENT> return [''] <NEW_LINE> <DEDENT> if 'class' in attribs: <NEW_LINE> <INDENT> del attribs['class'] <NEW_LINE> <DEDENT> if 'style' in attribs: <NEW_LINE> <INDENT> del attribs['style'] <NEW_LINE> <DEDENT> at = '' <NEW_LINE> for k, v in attribs.items(): <NEW_LINE> <INDENT> k = k.split('}')[-1] <NEW_LINE> at += ' %s="%s"' % (k, prepare_string_for_xml(v, attribute=True)) <NEW_LINE> <DEDENT> text.append('<%s%s' % (tag, at)) <NEW_LINE> if tag in SELF_CLOSING_TAGS: <NEW_LINE> <INDENT> text.append(' />') <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> text.append('>') <NEW_LINE> <DEDENT> if style['font-weight'] in ('bold', 'bolder'): <NEW_LINE> <INDENT> text.append('<b>') <NEW_LINE> tags.append('b') <NEW_LINE> <DEDENT> if style['font-style'] == 'italic': <NEW_LINE> <INDENT> text.append('<i>') <NEW_LINE> tags.append('i') <NEW_LINE> <DEDENT> if style['text-decoration'] == 'underline': <NEW_LINE> <INDENT> text.append('<u>') <NEW_LINE> tags.append('u') <NEW_LINE> <DEDENT> if style['text-decoration'] == 'line-through': <NEW_LINE> <INDENT> text.append('<s>') <NEW_LINE> tags.append('s') <NEW_LINE> <DEDENT> if hasattr(elem, 'text') and elem.text: <NEW_LINE> <INDENT> text.append(self.prepare_string_for_html(elem.text)) <NEW_LINE> <DEDENT> for item in elem: <NEW_LINE> <INDENT> text += self.dump_text(item, stylizer, page) <NEW_LINE> <DEDENT> tags.reverse() <NEW_LINE> for t in tags: <NEW_LINE> <INDENT> if t not in SELF_CLOSING_TAGS: <NEW_LINE> <INDENT> text.append('</%s>' % t) <NEW_LINE> <DEDENT> <DEDENT> if hasattr(elem, 'tail') and elem.tail: <NEW_LINE> <INDENT> text.append(self.prepare_string_for_html(elem.tail)) <NEW_LINE> <DEDENT> return text | This will remap a small number of CSS styles to equivalent HTML tags. | 6259903930c21e258be999ae |
class AbstractMelonOrder(): <NEW_LINE> <INDENT> def __init__(self, species, qty, country_code=None, passed_inspection=None): <NEW_LINE> <INDENT> self.species = species <NEW_LINE> self.qty = qty <NEW_LINE> self.shipped = False <NEW_LINE> if passed_inspection: <NEW_LINE> <INDENT> self.passed_inspection = passed_inspection <NEW_LINE> <DEDENT> if country_code: <NEW_LINE> <INDENT> self.country_code = country_code <NEW_LINE> <DEDENT> <DEDENT> def get_total(self): <NEW_LINE> <INDENT> base_price = 5 <NEW_LINE> fee = 0 <NEW_LINE> if self.order_type == "international" and self.qty < 10: <NEW_LINE> <INDENT> fee = 3 <NEW_LINE> <DEDENT> if self.species == "Christmas": <NEW_LINE> <INDENT> base_price = base_price * 1.5 <NEW_LINE> <DEDENT> total = (1 + self.tax) * (self.qty * base_price) + fee <NEW_LINE> return total <NEW_LINE> <DEDENT> def mark_shipped(self): <NEW_LINE> <INDENT> self.shipped = True | An abstract base class that other Melon Orders inherit from. | 62599039dc8b845886d54755 |
class XTP_FUND_TRANSFER_TYPE(IntEnum): <NEW_LINE> <INDENT> XTP_FUND_TRANSFER_OUT = 0 <NEW_LINE> XTP_FUND_TRANSFER_IN = auto() <NEW_LINE> XTP_FUND_TRANSFER_UNKNOWN = auto() | XTP_FUND_TRANSFER_TYPE是资金流转方向类型 | 62599039287bf620b6272d8b |
class SymbolicProblemTypeTest(ProblemTypeTestBase, ProblemTypeTestMixin): <NEW_LINE> <INDENT> problem_name = 'SYMBOLIC TEST PROBLEM' <NEW_LINE> problem_type = 'symbolicresponse' <NEW_LINE> partially_correct = False <NEW_LINE> factory = SymbolicResponseXMLFactory() <NEW_LINE> factory_kwargs = { 'expect': '2*x+3*y', 'question_text': 'Enter a value' } <NEW_LINE> status_indicators = { 'correct': ['div.capa_inputtype div.correct'], 'incorrect': ['div.capa_inputtype div.incorrect'], 'unanswered': ['div.capa_inputtype div.unanswered'], } <NEW_LINE> def answer_problem(self, correctness): <NEW_LINE> <INDENT> choice = "2*x+3*y" if correctness == 'correct' else "3*a+4*b" <NEW_LINE> self.problem_page.fill_answer(choice) | TestCase Class for Symbolic Problem Type | 6259903907d97122c4217e3e |
class TerminationNotice(Exception): <NEW_LINE> <INDENT> pass | This exception is raised inside a thread when it's time for it to die. | 6259903991af0d3eaad3afd4 |
class WizardLinkOrder( LoginRequiredMixin, StaffuserRequiredMixin, WizardLinkMixin, FormView): <NEW_LINE> <INDENT> form_class = EmptyForm <NEW_LINE> template_name = 'block/wizard_link_order.html' <NEW_LINE> def _move_up_down(self, up, down): <NEW_LINE> <INDENT> pk = int(up) if up else int(down) <NEW_LINE> idx = None <NEW_LINE> ordered = [] <NEW_LINE> many_to_many = self._get_many_to_many() <NEW_LINE> for count, item in enumerate(many_to_many): <NEW_LINE> <INDENT> if item.pk == pk: <NEW_LINE> <INDENT> idx = count <NEW_LINE> <DEDENT> ordered.append(item.pk) <NEW_LINE> count = count + 1 <NEW_LINE> <DEDENT> if idx is None: <NEW_LINE> <INDENT> raise BlockError("Cannot find item {} in {}".format(pk, ordered)) <NEW_LINE> <DEDENT> if down: <NEW_LINE> <INDENT> if idx == len(ordered) - 1: <NEW_LINE> <INDENT> raise BlockError("Cannot move the last item down") <NEW_LINE> <DEDENT> ordered[idx], ordered[idx+1] = ordered[idx+1], ordered[idx] <NEW_LINE> <DEDENT> elif up: <NEW_LINE> <INDENT> if idx == 0: <NEW_LINE> <INDENT> raise BlockError("Cannot move the first item up") <NEW_LINE> <DEDENT> ordered[idx], ordered[idx-1] = ordered[idx-1], ordered[idx] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise BlockError("No 'up' or 'down' (why?)") <NEW_LINE> <DEDENT> content_obj = self._content_obj() <NEW_LINE> field = self._get_field() <NEW_LINE> with transaction.atomic(): <NEW_LINE> <INDENT> for order, pk in enumerate(ordered, start=1): <NEW_LINE> <INDENT> obj = field.through.objects.get( pk=pk, content=content_obj, ) <NEW_LINE> obj.order = order <NEW_LINE> obj.save() <NEW_LINE> <DEDENT> content_obj.set_pending_edit() <NEW_LINE> content_obj.save() <NEW_LINE> <DEDENT> <DEDENT> def form_valid(self, form): <NEW_LINE> <INDENT> up = self.request.POST.get('up') <NEW_LINE> down = self.request.POST.get('down') <NEW_LINE> if up or down: <NEW_LINE> <INDENT> self._move_up_down(up, down) <NEW_LINE> <DEDENT> return HttpResponseRedirect( reverse('block.wizard.link.order', kwargs=self._kwargs()) ) | set the order of multiple links | 6259903994891a1f408b9fc8 |
class Comment(models.Model): <NEW_LINE> <INDENT> post = models.ForeignKey('blog.Post', related_name='comments', on_delete=models.CASCADE) <NEW_LINE> author = models.CharField(max_length=200) <NEW_LINE> text = models.TextField() <NEW_LINE> create_date = models.DateTimeField(default=timezone.now()) <NEW_LINE> approved_comment = models.BooleanField(default=False) <NEW_LINE> def approve(self): <NEW_LINE> <INDENT> self.approved_comment = True <NEW_LINE> self.save() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def get_absolute_url(): <NEW_LINE> <INDENT> return reverse('post_list') <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return self.text | Comments on certain blog posts.
Anyone can comment, but they will have to be approved to be shown. | 625990398da39b475be04391 |
class DAPLinkServer(object): <NEW_LINE> <INDENT> def __init__(self, address=None, socket=None, interface=None): <NEW_LINE> <INDENT> if interface: <NEW_LINE> <INDENT> self._interface = INTERFACE[interface] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self._interface = default_interface <NEW_LINE> <DEDENT> if socket: <NEW_LINE> <INDENT> socket = SOCKET[socket] <NEW_LINE> <DEDENT> elif address: <NEW_LINE> <INDENT> socket = socket_by_address(address) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> socket = default_socket <NEW_LINE> <DEDENT> if address: <NEW_LINE> <INDENT> self._server = socket.Server(address) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self._server = socket.Server() <NEW_LINE> <DEDENT> self.interface = self._interface.name <NEW_LINE> self.socket = socket.name <NEW_LINE> self._threads = set() <NEW_LINE> <DEDENT> def init(self): <NEW_LINE> <INDENT> self._server.open() <NEW_LINE> thread = Thread(target=self._server_task) <NEW_LINE> thread.daemon = True <NEW_LINE> thread.shutdown = self._server.shutdown <NEW_LINE> thread.start() <NEW_LINE> self._threads.add(thread) <NEW_LINE> <DEDENT> @property <NEW_LINE> def client_count(self): <NEW_LINE> <INDENT> return max(len(self._threads)-1, 0) <NEW_LINE> <DEDENT> @property <NEW_LINE> def address(self): <NEW_LINE> <INDENT> return self._server.address <NEW_LINE> <DEDENT> def _server_task(self): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> while self._server.isalive(): <NEW_LINE> <INDENT> client = self._server.accept() <NEW_LINE> if client: <NEW_LINE> <INDENT> thread = Thread(target=lambda: self._client_task(client)) <NEW_LINE> thread.daemon = True <NEW_LINE> thread.shutdown = client.shutdown <NEW_LINE> thread.start() <NEW_LINE> self._threads.add(thread) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> finally: <NEW_LINE> <INDENT> self._threads.discard(threading.current_thread()) <NEW_LINE> <DEDENT> <DEDENT> def _client_task(self, client): <NEW_LINE> <INDENT> connection = DAPLinkServerTransport(self._interface) <NEW_LINE> connection.init() <NEW_LINE> try: <NEW_LINE> <INDENT> while True: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> data = client.recv() <NEW_LINE> if not client.isalive(): <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> data = decode(data) <NEW_LINE> <DEDENT> except: <NEW_LINE> <INDENT> raise CommandError('Malformed command') <NEW_LINE> <DEDENT> resp = connection.handle(data) <NEW_LINE> <DEDENT> except: <NEW_LINE> <INDENT> exc = sys.exc_info() <NEW_LINE> type = exc[0].__name__ <NEW_LINE> message = str(exc[1]) <NEW_LINE> logging.error('%s: %s' % (type, message)) <NEW_LINE> try: <NEW_LINE> <INDENT> client.send(encode({'error': type, 'message': message})) <NEW_LINE> <DEDENT> except: <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> continue <NEW_LINE> <DEDENT> <DEDENT> client.send(encode(resp)) <NEW_LINE> <DEDENT> <DEDENT> finally: <NEW_LINE> <INDENT> connection.uninit() <NEW_LINE> client.close() <NEW_LINE> self._threads.discard(threading.current_thread()) <NEW_LINE> <DEDENT> <DEDENT> def uninit(self): <NEW_LINE> <INDENT> threads = self._threads.copy() <NEW_LINE> for thread in threads: <NEW_LINE> <INDENT> thread.shutdown() <NEW_LINE> <DEDENT> for thread in threads: <NEW_LINE> <INDENT> thread.join() <NEW_LINE> <DEDENT> self._server.close() | This class provides the DAPLink interface as a streaming socket
based server. Communication is performed by sending commands
formed as JSON dictionaries. | 6259903907d97122c4217e3f |
class TemplateIncludeError(TemplateError): <NEW_LINE> <INDENT> pass | Raised by the `ControlledLoader` if recursive includes where
detected. | 6259903966673b3332c31597 |
class DictQueryset(AbstractQueryset): <NEW_LINE> <INDENT> def __init__(self, **kw): <NEW_LINE> <INDENT> super(DictQueryset, self).__init__(db_conn=dict(), **kw) <NEW_LINE> <DEDENT> def create_one(self, shield): <NEW_LINE> <INDENT> if shield.id in self.db_conn: <NEW_LINE> <INDENT> status = self.MSG_UPDATED <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> status = self.MSG_CREATED <NEW_LINE> <DEDENT> shield_key = str(getattr(shield, self.api_id)) <NEW_LINE> self.db_conn[shield_key] = shield.to_python() <NEW_LINE> return (status, shield) <NEW_LINE> <DEDENT> def create_many(self, shields): <NEW_LINE> <INDENT> statuses = [self.create_one(shield) for shield in shields] <NEW_LINE> return statuses <NEW_LINE> <DEDENT> def read_all(self): <NEW_LINE> <INDENT> return [(self.MSG_OK, datum) for datum in self.db_conn.values()] <NEW_LINE> <DEDENT> def read_one(self, iid): <NEW_LINE> <INDENT> iid = str(iid) <NEW_LINE> if iid in self.db_conn: <NEW_LINE> <INDENT> return (self.MSG_OK, self.db_conn[iid]) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return (self.MSG_FAILED, iid) <NEW_LINE> <DEDENT> <DEDENT> def read_many(self, ids): <NEW_LINE> <INDENT> return [self.read_one(iid) for iid in ids] <NEW_LINE> <DEDENT> def update_one(self, shield): <NEW_LINE> <INDENT> shield_key = str(getattr(shield, self.api_id)) <NEW_LINE> self.db_conn[shield_key] = shield.to_python() <NEW_LINE> return (self.MSG_UPDATED, shield) <NEW_LINE> <DEDENT> def update_many(self, shields): <NEW_LINE> <INDENT> statuses = [self.update_one(shield) for shield in shields] <NEW_LINE> return statuses <NEW_LINE> <DEDENT> def destroy_one(self, item_id): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> datum = self.db_conn[item_id] <NEW_LINE> del self.db_conn[item_id] <NEW_LINE> <DEDENT> except KeyError: <NEW_LINE> <INDENT> raise ResponseException(404) <NEW_LINE> <DEDENT> return (self.MSG_UPDATED, datum) <NEW_LINE> <DEDENT> def destroy_many(self, ids): <NEW_LINE> <INDENT> statuses = [self.destroy_one(iid) for iid in ids] <NEW_LINE> return statuses | This class exists as an example of how one could implement a Queryset.
This model is an in-memory dictionary and uses the model's id as the key.
The data stored is the result of calling model's `to_python()` function. | 62599039ec188e330fdf9a3a |
class CheckSkuAvailabilityOperations(object): <NEW_LINE> <INDENT> def __init__(self, client, config, serializer, deserializer): <NEW_LINE> <INDENT> self._client = client <NEW_LINE> self._serialize = serializer <NEW_LINE> self._deserialize = deserializer <NEW_LINE> self.api_version = "2017-04-18" <NEW_LINE> self.config = config <NEW_LINE> <DEDENT> def list( self, location, skus, kind, type, custom_headers=None, raw=False, **operation_config): <NEW_LINE> <INDENT> parameters = models.CheckSkuAvailabilityParameter(skus=skus, kind=kind, type=type) <NEW_LINE> url = '/subscriptions/{subscriptionId}/providers/Microsoft.CognitiveServices/locations/{location}/checkSkuAvailability' <NEW_LINE> path_format_arguments = { 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), 'location': self._serialize.url("location", location, 'str') } <NEW_LINE> url = self._client.format_url(url, **path_format_arguments) <NEW_LINE> query_parameters = {} <NEW_LINE> query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') <NEW_LINE> header_parameters = {} <NEW_LINE> header_parameters['Content-Type'] = 'application/json; charset=utf-8' <NEW_LINE> if self.config.generate_client_request_id: <NEW_LINE> <INDENT> header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) <NEW_LINE> <DEDENT> if custom_headers: <NEW_LINE> <INDENT> header_parameters.update(custom_headers) <NEW_LINE> <DEDENT> if self.config.accept_language is not None: <NEW_LINE> <INDENT> header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') <NEW_LINE> <DEDENT> body_content = self._serialize.body(parameters, 'CheckSkuAvailabilityParameter') <NEW_LINE> request = self._client.post(url, query_parameters) <NEW_LINE> response = self._client.send( request, header_parameters, body_content, **operation_config) <NEW_LINE> if response.status_code not in [200]: <NEW_LINE> <INDENT> exp = CloudError(response) <NEW_LINE> exp.request_id = response.headers.get('x-ms-request-id') <NEW_LINE> raise exp <NEW_LINE> <DEDENT> deserialized = None <NEW_LINE> if response.status_code == 200: <NEW_LINE> <INDENT> deserialized = self._deserialize('CheckSkuAvailabilityResultList', response) <NEW_LINE> <DEDENT> if raw: <NEW_LINE> <INDENT> client_raw_response = ClientRawResponse(deserialized, response) <NEW_LINE> return client_raw_response <NEW_LINE> <DEDENT> return deserialized | CheckSkuAvailabilityOperations operations.
:param client: Client for service requests.
:param config: Configuration of service client.
:param serializer: An object model serializer.
:param deserializer: An objec model deserializer.
:ivar api_version: Version of the API to be used with the client request. Current version is 2017-04-18. Constant value: "2017-04-18". | 62599039a4f1c619b294f758 |
class DiagnosticStatusClass(object): <NEW_LINE> <INDENT> OK = "OK" <NEW_LINE> WAITING = "WAITING" <NEW_LINE> FAIL = "FAIL" <NEW_LINE> swagger_types = { } <NEW_LINE> attribute_map = { } <NEW_LINE> def __init__(self): <NEW_LINE> <INDENT> self.discriminator = None <NEW_LINE> <DEDENT> def to_dict(self): <NEW_LINE> <INDENT> result = {} <NEW_LINE> for attr, _ in six.iteritems(self.swagger_types): <NEW_LINE> <INDENT> value = getattr(self, attr) <NEW_LINE> if isinstance(value, list): <NEW_LINE> <INDENT> result[attr] = list(map( lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value )) <NEW_LINE> <DEDENT> elif hasattr(value, "to_dict"): <NEW_LINE> <INDENT> result[attr] = value.to_dict() <NEW_LINE> <DEDENT> elif isinstance(value, dict): <NEW_LINE> <INDENT> result[attr] = dict(map( lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item, value.items() )) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> result[attr] = value <NEW_LINE> <DEDENT> <DEDENT> if issubclass(DiagnosticStatusClass, dict): <NEW_LINE> <INDENT> for key, value in self.items(): <NEW_LINE> <INDENT> result[key] = value <NEW_LINE> <DEDENT> <DEDENT> return result <NEW_LINE> <DEDENT> def to_str(self): <NEW_LINE> <INDENT> return pprint.pformat(self.to_dict()) <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return self.to_str() <NEW_LINE> <DEDENT> def __eq__(self, other): <NEW_LINE> <INDENT> if not isinstance(other, DiagnosticStatusClass): <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> return self.__dict__ == other.__dict__ <NEW_LINE> <DEDENT> def __ne__(self, other): <NEW_LINE> <INDENT> return not self == other | NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually. | 62599039d6c5a102081e32c9 |
class creatverfattr(BaseObj): <NEW_LINE> <INDENT> _attrlist = ("verifier", "attrs") <NEW_LINE> def __init__(self, unpack): <NEW_LINE> <INDENT> self.verifier = verifier4(unpack) <NEW_LINE> self.attrs = fattr4(unpack) | struct creatverfattr {
verifier4 verifier;
fattr4 attrs;
}; | 6259903926238365f5fadcf8 |
class GovFileInput(GovInput, FileInput): <NEW_LINE> <INDENT> template = "govuk_frontend_wtf/file-upload.html" <NEW_LINE> def __call__(self, field, **kwargs): <NEW_LINE> <INDENT> kwargs["value"] = False <NEW_LINE> if self.multiple: <NEW_LINE> <INDENT> kwargs["multiple"] = True <NEW_LINE> <DEDENT> return super().__call__(field, **kwargs) | Render a file chooser input.
:param multiple: allow choosing multiple files | 62599039b57a9660fecd2c1e |
class MooseFigure(MooseImageFile): <NEW_LINE> <INDENT> RE = r'^!figure\s+(.*?)(?:$|\s+)(.*)' <NEW_LINE> def __init__(self, *args, **kwargs): <NEW_LINE> <INDENT> super(MooseFigure, self).__init__(*args, **kwargs) <NEW_LINE> self._settings['prefix'] = 'Figure' <NEW_LINE> self._settings['id'] = None <NEW_LINE> self._figure_number = 0 <NEW_LINE> <DEDENT> def initialize(self): <NEW_LINE> <INDENT> self._figure_number = 0 <NEW_LINE> <DEDENT> def handleMatch(self, match): <NEW_LINE> <INDENT> self._figure_number += 1 <NEW_LINE> rel_filename = match.group(2) <NEW_LINE> settings = self.getSettings(match.group(3)) <NEW_LINE> if not settings['id']: <NEW_LINE> <INDENT> return self.createErrorElement("The 'id' setting must be supplied for the figure: {}".format(rel_filename)) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> settings['id'] = settings['id'].replace(':', '') <NEW_LINE> <DEDENT> if settings['caption']: <NEW_LINE> <INDENT> settings['caption'] = '{} {}: {}'.format(settings['prefix'], self._figure_number, settings['caption']) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> settings['caption'] = '{} {}'.format(settings['prefix'], self._figure_number) <NEW_LINE> <DEDENT> el = self.createImageElement(rel_filename, settings) <NEW_LINE> el.set('data-moose-figure-number', str(self._figure_number)) <NEW_LINE> return el | Defines syntax for adding images as numbered figures with labels that can be referenced (see MooseFigureReference) | 62599039be383301e02549ba |
@implementer(schemas.ICloudWatchLogging) <NEW_LINE> class CloudWatchLogging(Named, CloudWatchLogRetention): <NEW_LINE> <INDENT> log_sets = FieldProperty(schemas.ICloudWatchLogging["log_sets"]) | Contains global defaults for all CloudWatch logging and log sets | 62599039a8ecb033258723c2 |
class xep_0092(base_plugin): <NEW_LINE> <INDENT> def plugin_init(self): <NEW_LINE> <INDENT> self.xep = "0092" <NEW_LINE> self.description = "Software Version" <NEW_LINE> self.stanza = sleekxmpp.plugins.xep_0092.stanza <NEW_LINE> self.name = self.config.get('name', 'SleekXMPP') <NEW_LINE> self.version = self.config.get('version', '0.1-dev') <NEW_LINE> self.os = self.config.get('os', '') <NEW_LINE> self.getVersion = self.get_version <NEW_LINE> self.xmpp.register_handler( Callback('Software Version', StanzaPath('iq@type=get/software_version'), self._handle_version)) <NEW_LINE> register_stanza_plugin(Iq, Version) <NEW_LINE> <DEDENT> def post_init(self): <NEW_LINE> <INDENT> base_plugin.post_init(self) <NEW_LINE> self.xmpp.plugin['xep_0030'].add_feature('jabber:iq:version') <NEW_LINE> <DEDENT> def _handle_version(self, iq): <NEW_LINE> <INDENT> iq.reply() <NEW_LINE> iq['software_version']['name'] = self.name <NEW_LINE> iq['software_version']['version'] = self.version <NEW_LINE> iq['software_version']['os'] = self.os <NEW_LINE> iq.send() <NEW_LINE> <DEDENT> def get_version(self, jid, ifrom=None): <NEW_LINE> <INDENT> iq = self.xmpp.Iq() <NEW_LINE> iq['to'] = jid <NEW_LINE> if ifrom: <NEW_LINE> <INDENT> iq['from'] = ifrom <NEW_LINE> <DEDENT> iq['type'] = 'get' <NEW_LINE> iq['query'] = Version.namespace <NEW_LINE> result = iq.send() <NEW_LINE> if result and result['type'] != 'error': <NEW_LINE> <INDENT> return result['software_version'].values <NEW_LINE> <DEDENT> return False | XEP-0092: Software Version | 6259903963f4b57ef0086645 |
class TestContains(MemoryLeakMixin, TestCase): <NEW_LINE> <INDENT> def test_list_contains_empty(self): <NEW_LINE> <INDENT> @njit <NEW_LINE> def foo(i): <NEW_LINE> <INDENT> l = listobject.new_list(int32) <NEW_LINE> return i in l <NEW_LINE> <DEDENT> self.assertFalse(foo(0)) <NEW_LINE> self.assertFalse(foo(1)) <NEW_LINE> <DEDENT> def test_list_contains_singleton(self): <NEW_LINE> <INDENT> @njit <NEW_LINE> def foo(i): <NEW_LINE> <INDENT> l = listobject.new_list(int32) <NEW_LINE> l.append(0) <NEW_LINE> return i in l <NEW_LINE> <DEDENT> self.assertTrue(foo(0)) <NEW_LINE> self.assertFalse(foo(1)) <NEW_LINE> <DEDENT> def test_list_contains_multiple(self): <NEW_LINE> <INDENT> @njit <NEW_LINE> def foo(i): <NEW_LINE> <INDENT> l = listobject.new_list(int32) <NEW_LINE> for j in range(10, 20): <NEW_LINE> <INDENT> l.append(j) <NEW_LINE> <DEDENT> return i in l <NEW_LINE> <DEDENT> for i in range(10, 20): <NEW_LINE> <INDENT> self.assertTrue(foo(i)) <NEW_LINE> <DEDENT> for i in range(20, 30): <NEW_LINE> <INDENT> self.assertFalse(foo(i)) | Test list contains. | 625990398da39b475be04393 |
class GravimetryModelling(pg.ModellingBase): <NEW_LINE> <INDENT> def __init__(self, verbose=True): <NEW_LINE> <INDENT> super(GravimetryModelling, self).__init__(verbose) <NEW_LINE> self._J = pg.RMatrix() <NEW_LINE> self.sensorPositions = None <NEW_LINE> self.setJacobian(self._J) <NEW_LINE> <DEDENT> def createStartmodel(self): <NEW_LINE> <INDENT> return pg.RVector(self.regionManger().parameterCount(), 0.0) <NEW_LINE> <DEDENT> def setSensorPositions(self, pnts): <NEW_LINE> <INDENT> self.sensorPositions = pnts <NEW_LINE> <DEDENT> def response(self, dDensity): <NEW_LINE> <INDENT> return solveGravimetry(self.regionManager().paraDomain(), dDensity, pnts=self.sensorPositions, complete=False) <NEW_LINE> <DEDENT> def createJacobian(self, model): <NEW_LINE> <INDENT> gdz = solveGravimetry(self.regionManager().paraDomain(), dDensity=None, pnts=self.sensorPositions, complete=False) <NEW_LINE> self._J.resize(len(gdz), len(gdz[0])) <NEW_LINE> for i, gdzi in enumerate(gdz): <NEW_LINE> <INDENT> self._J.setVal(gdzi, i) <NEW_LINE> <DEDENT> raise BaseException('Scale with model??', model) | Gravimetry modelling operator. | 6259903971ff763f4b5e893e |
class Solution2: <NEW_LINE> <INDENT> def hasCycle(self, head: ListNode) -> bool: <NEW_LINE> <INDENT> visited = set() <NEW_LINE> while head: <NEW_LINE> <INDENT> if head in visited: <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> visited.add(head) <NEW_LINE> head = head.next <NEW_LINE> <DEDENT> return False | 哈希表
时间复杂度：O(1)，空间复杂度：O(n)， | 6259903916aa5153ce401691 |
class GoogleCloudVisionV1p2beta1ImageAnnotationContext(_messages.Message): <NEW_LINE> <INDENT> pageNumber = _messages.IntegerField(1, variant=_messages.Variant.INT32) <NEW_LINE> uri = _messages.StringField(2) | If an image was produced from a file (e.g. a PDF), this message gives
information about the source of that image.
Fields:
pageNumber: If the file was a PDF or TIFF, this field gives the page
number within the file used to produce the image.
uri: The URI of the file used to produce the image. | 6259903923e79379d538d6a5 |
class SlackPMAppTokenError(SlackPMErrorBase): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> super(SlackPMAppTokenError, self).__init__('Invalid Application Token') | Invalid Application Token. | 6259903930dc7b76659a09d7 |
class TestSimpleSignalOrderFillCycleForPortfolioHandler(unittest.TestCase): <NEW_LINE> <INDENT> def setUp(self): <NEW_LINE> <INDENT> initial_cash = Decimal("500000.00") <NEW_LINE> events_queue = EventsQueue() <NEW_LINE> price_handler = PriceHandlerMock() <NEW_LINE> position_sizer = PositionSizerMock() <NEW_LINE> risk_manager = RiskManagerMock() <NEW_LINE> self.portfolio_handler = PortfolioHandler( events_queue, initial_cash, price_handler, position_sizer, risk_manager ) <NEW_LINE> <DEDENT> def test_create_order_from_signal_basic_check(self): <NEW_LINE> <INDENT> signal_event = SignalEvent("MSFT", "BOT") <NEW_LINE> order = self.portfolio_handler._create_order_from_signal(signal_event) <NEW_LINE> self.assertEqual(order.ticker, "MSFT") <NEW_LINE> self.assertEqual(order.action, "BOT") <NEW_LINE> self.assertEqual(order.quantity, 0) <NEW_LINE> <DEDENT> def test_place_orders_onto_queue_basic_check(self): <NEW_LINE> <INDENT> order = OrderEvent("MSFT", "BOT", 100) <NEW_LINE> order_list = [order] <NEW_LINE> self.portfolio_handler._place_orders_onto_queue(order_list) <NEW_LINE> ret_order = self.portfolio_handler.events_queue.dequeue() <NEW_LINE> self.assertEqual(ret_order.ticker, "MSFT") <NEW_LINE> self.assertEqual(ret_order.action, "BOT") <NEW_LINE> self.assertEqual(ret_order.quantity, 100) <NEW_LINE> <DEDENT> def test_convert_fill_to_portfolio_update_basic_check(self): <NEW_LINE> <INDENT> fill_event_buy = FillEvent( datetime.datetime.utcnow(), "MSFT", "BOT", 100, "ARCA", Decimal("50.25"), Decimal("1.00") ) <NEW_LINE> self.portfolio_handler._convert_fill_to_portfolio_update(fill_event_buy) <NEW_LINE> port = self.portfolio_handler.portfolio <NEW_LINE> self.assertEqual(port.cur_cash, Decimal("494974.00")) <NEW_LINE> fill_event_sell = FillEvent( datetime.datetime.utcnow(), "MSFT", "SLD", 100, "ARCA", Decimal("50.25"), Decimal("1.00") ) <NEW_LINE> self.portfolio_handler._convert_fill_to_portfolio_update(fill_event_sell) <NEW_LINE> <DEDENT> def test_on_signal_basic_check(self): <NEW_LINE> <INDENT> signal_event = SignalEvent("MSFT", "BOT") <NEW_LINE> self.portfolio_handler.on_signal(signal_event) <NEW_LINE> ret_order = self.portfolio_handler.events_queue.dequeue() <NEW_LINE> self.assertEqual(ret_order.ticker, "MSFT") <NEW_LINE> self.assertEqual(ret_order.action, "BOT") <NEW_LINE> self.assertEqual(ret_order.quantity, 100) | Tests a simple Signal, Order and Fill cycle for the
PortfolioHandler. This is, in effect, a sanity check. | 62599039507cdc57c63a5f3e |
class Simple: <NEW_LINE> <INDENT> def decide_action(self, target, game): <NEW_LINE> <INDENT> actor = self.owner <NEW_LINE> distance = actor.distance_to_ent(target) <NEW_LINE> results = [] <NEW_LINE> if distance >= 2: <NEW_LINE> <INDENT> actor.move_astar(target, game) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> results.extend(actor.f.attack_setup(target, game)) <NEW_LINE> <DEDENT> return results | Simple behavior moves the npc straight towards the player, attack if next to them and use a skill if available. | 62599039a4f1c619b294f759 |
class Proxy(Model): <NEW_LINE> <INDENT> proxy = CharField(primary_key=True) <NEW_LINE> check_time = DateTimeField(null=True) <NEW_LINE> response_time = FloatField(null=True) <NEW_LINE> status_code = IntegerField(null=True) <NEW_LINE> class Meta: <NEW_LINE> <INDENT> database = db | 数据库model | 6259903973bcbd0ca4bcb42d |
class SEResNet(Chain): <NEW_LINE> <INDENT> def __init__(self, channels, init_block_channels, bottleneck, conv1_stride, in_channels=3, in_size=(224, 224), classes=1000): <NEW_LINE> <INDENT> super(SEResNet, self).__init__() <NEW_LINE> self.in_size = in_size <NEW_LINE> self.classes = classes <NEW_LINE> with self.init_scope(): <NEW_LINE> <INDENT> self.features = SimpleSequential() <NEW_LINE> with self.features.init_scope(): <NEW_LINE> <INDENT> setattr(self.features, "init_block", ResInitBlock( in_channels=in_channels, out_channels=init_block_channels)) <NEW_LINE> in_channels = init_block_channels <NEW_LINE> for i, channels_per_stage in enumerate(channels): <NEW_LINE> <INDENT> stage = SimpleSequential() <NEW_LINE> with stage.init_scope(): <NEW_LINE> <INDENT> for j, out_channels in enumerate(channels_per_stage): <NEW_LINE> <INDENT> stride = 2 if (j == 0) and (i != 0) else 1 <NEW_LINE> setattr(stage, "unit{}".format(j + 1), SEResUnit( in_channels=in_channels, out_channels=out_channels, stride=stride, bottleneck=bottleneck, conv1_stride=conv1_stride)) <NEW_LINE> in_channels = out_channels <NEW_LINE> <DEDENT> <DEDENT> setattr(self.features, "stage{}".format(i + 1), stage) <NEW_LINE> <DEDENT> setattr(self.features, "final_pool", partial( F.average_pooling_2d, ksize=7, stride=1)) <NEW_LINE> <DEDENT> self.output = SimpleSequential() <NEW_LINE> with self.output.init_scope(): <NEW_LINE> <INDENT> setattr(self.output, "flatten", partial( F.reshape, shape=(-1, in_channels))) <NEW_LINE> setattr(self.output, "fc", L.Linear( in_size=in_channels, out_size=classes)) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def __call__(self, x): <NEW_LINE> <INDENT> x = self.features(x) <NEW_LINE> x = self.output(x) <NEW_LINE> return x | SE-ResNet model from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.
Parameters:
----------
channels : list of list of int
Number of output channels for each unit.
init_block_channels : int
Number of output channels for the initial unit.
bottleneck : bool
Whether to use a bottleneck or simple block in units.
conv1_stride : bool
Whether to use stride in the first or the second convolution layer in units.
in_channels : int, default 3
Number of input channels.
in_size : tuple of two ints, default (224, 224)
Spatial size of the expected input image.
classes : int, default 1000
Number of classification classes. | 62599039d6c5a102081e32cb |
class Error(XC): <NEW_LINE> <INDENT> pass | This is the base class for exceptions that may be recoverable.
Packages should create subclasses of this. | 625990396fece00bbacccb51 |
class EventPageGroup(models.Model): <NEW_LINE> <INDENT> eventpage = ParentalKey( "events.EventPage", on_delete=models.CASCADE, related_name="related_groups" ) <NEW_LINE> group = models.ForeignKey( "core.Group", on_delete=models.CASCADE, related_name="event_pages" ) <NEW_LINE> panels = [ PageChooserPanel("group"), ] <NEW_LINE> class Meta: <NEW_LINE> <INDENT> unique_together = ("eventpage", "group") | model that saves the relation from EventPages to Groups, showing a PageChooserPanel | 625990391d351010ab8f4cc0 |
class Observable(metaclass=ABCMeta): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.observers = [] <NEW_LINE> <DEDENT> def register(self, observer): <NEW_LINE> <INDENT> self.observers.append(observer) <NEW_LINE> <DEDENT> def notify_observers(self, message): <NEW_LINE> <INDENT> for observer in self.observers: <NEW_LINE> <INDENT> observer.update(message) | Абстрактный наблюдаемый | 6259903921bff66bcd723e0e |
class CSOR(SFS): <NEW_LINE> <INDENT> DIVISION = FixedCharField(4, default='CSOR') <NEW_LINE> _training_pay = IntegerField() <NEW_LINE> _deployment_pay = IntegerField() <NEW_LINE> _section_call_sign = FixedCharField(3) <NEW_LINE> _kill_count = IntegerField(default=0) <NEW_LINE> def expire_training(self, training): <NEW_LINE> <INDENT> if training in self._trainings: <NEW_LINE> <INDENT> self._trainings.remove(training) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> print(f"{self._rank} {self._lname} was never trained on {training}") <NEW_LINE> <DEDENT> <DEDENT> def train(self, training): <NEW_LINE> <INDENT> self._trainings.append(self.validate_training(training)) <NEW_LINE> <DEDENT> def to_dict(self): <NEW_LINE> <INDENT> return dict( Service_Number=self._SIN, Rank=self._rank, Last_Name=self._lname, First_Name=self._fname, Division=self.DIVISION, Training_Pay=self._training_pay, Deployment_Pay=self._deployment_pay, Trainings=self._trainings, Call_Sign=self._section_call_sign, Kill_Count=self._kill_count ) <NEW_LINE> <DEDENT> def update_soldier_info(self, call_sign, kills, rank, lname, fname, tpay, dpay): <NEW_LINE> <INDENT> self._section_call_sign = call_sign <NEW_LINE> self._kill_count = kills <NEW_LINE> self._rank = rank <NEW_LINE> self._lname = lname <NEW_LINE> self._fname = fname <NEW_LINE> self._training_pay = tpay <NEW_LINE> self._deployment_pay = dpay | CSOR Class | 6259903994891a1f408b9fca |
class MockTest(DropUploadTestMixin, unittest.TestCase): <NEW_LINE> <INDENT> def test_errors(self): <NEW_LINE> <INDENT> self.basedir = "drop_upload.MockTest.test_errors" <NEW_LINE> self.set_up_grid() <NEW_LINE> errors_dir = os.path.join(self.basedir, "errors_dir") <NEW_LINE> os.mkdir(errors_dir) <NEW_LINE> client = self.g.clients[0] <NEW_LINE> d = client.create_dirnode() <NEW_LINE> def _made_upload_dir(n): <NEW_LINE> <INDENT> self.failUnless(IDirectoryNode.providedBy(n)) <NEW_LINE> upload_dircap = n.get_uri() <NEW_LINE> readonly_dircap = n.get_readonly_uri() <NEW_LINE> self.shouldFail(AssertionError, 'invalid local.directory', 'could not be represented', DropUploader, client, upload_dircap, '\xFF', inotify=fake_inotify) <NEW_LINE> self.shouldFail(AssertionError, 'nonexistent local.directory', 'there is no directory', DropUploader, client, upload_dircap, os.path.join(self.basedir, "Laputa"), inotify=fake_inotify) <NEW_LINE> fp = filepath.FilePath(self.basedir).child('NOT_A_DIR') <NEW_LINE> fp.touch() <NEW_LINE> self.shouldFail(AssertionError, 'non-directory local.directory', 'is not a directory', DropUploader, client, upload_dircap, fp.path, inotify=fake_inotify) <NEW_LINE> self.shouldFail(AssertionError, 'bad upload.dircap', 'does not refer to a directory', DropUploader, client, 'bad', errors_dir, inotify=fake_inotify) <NEW_LINE> self.shouldFail(AssertionError, 'non-directory upload.dircap', 'does not refer to a directory', DropUploader, client, 'URI:LIT:foo', errors_dir, inotify=fake_inotify) <NEW_LINE> self.shouldFail(AssertionError, 'readonly upload.dircap', 'is not a writecap to a directory', DropUploader, client, readonly_dircap, errors_dir, inotify=fake_inotify) <NEW_LINE> <DEDENT> d.addCallback(_made_upload_dir) <NEW_LINE> return d <NEW_LINE> <DEDENT> def test_drop_upload(self): <NEW_LINE> <INDENT> self.inotify = fake_inotify <NEW_LINE> self.basedir = "drop_upload.MockTest.test_drop_upload" <NEW_LINE> return self._test() <NEW_LINE> <DEDENT> def notify_close_write(self, path): <NEW_LINE> <INDENT> self.uploader._notifier.event(path, self.inotify.IN_CLOSE_WRITE) | This can run on any platform, and even if twisted.internet.inotify can't be imported. | 625990398da39b475be04395 |
class describe_token_map_result(object): <NEW_LINE> <INDENT> def __init__(self, success=None, ire=None,): <NEW_LINE> <INDENT> self.success = success <NEW_LINE> self.ire = ire <NEW_LINE> <DEDENT> def read(self, iprot): <NEW_LINE> <INDENT> if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: <NEW_LINE> <INDENT> iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec]) <NEW_LINE> return <NEW_LINE> <DEDENT> iprot.readStructBegin() <NEW_LINE> while True: <NEW_LINE> <INDENT> (fname, ftype, fid) = iprot.readFieldBegin() <NEW_LINE> if ftype == TType.STOP: <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> if fid == 0: <NEW_LINE> <INDENT> if ftype == TType.MAP: <NEW_LINE> <INDENT> self.success = {} <NEW_LINE> (_ktype374, _vtype375, _size373) = iprot.readMapBegin() <NEW_LINE> for _i377 in range(_size373): <NEW_LINE> <INDENT> _key378 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString() <NEW_LINE> _val379 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString() <NEW_LINE> self.success[_key378] = _val379 <NEW_LINE> <DEDENT> iprot.readMapEnd() <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> iprot.skip(ftype) <NEW_LINE> <DEDENT> <DEDENT> elif fid == 1: <NEW_LINE> <INDENT> if ftype == TType.STRUCT: <NEW_LINE> <INDENT> self.ire = InvalidRequestException() <NEW_LINE> self.ire.read(iprot) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> iprot.skip(ftype) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> iprot.skip(ftype) <NEW_LINE> <DEDENT> iprot.readFieldEnd() <NEW_LINE> <DEDENT> iprot.readStructEnd() <NEW_LINE> <DEDENT> def write(self, oprot): <NEW_LINE> <INDENT> if oprot._fast_encode is not None and self.thrift_spec is not None: <NEW_LINE> <INDENT> oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec])) <NEW_LINE> return <NEW_LINE> <DEDENT> oprot.writeStructBegin('describe_token_map_result') <NEW_LINE> if self.success is not None: <NEW_LINE> <INDENT> oprot.writeFieldBegin('success', TType.MAP, 0) <NEW_LINE> oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success)) <NEW_LINE> for kiter380, viter381 in self.success.items(): <NEW_LINE> <INDENT> oprot.writeString(kiter380.encode('utf-8') if sys.version_info[0] == 2 else kiter380) <NEW_LINE> oprot.writeString(viter381.encode('utf-8') if sys.version_info[0] == 2 else viter381) <NEW_LINE> <DEDENT> oprot.writeMapEnd() <NEW_LINE> oprot.writeFieldEnd() <NEW_LINE> <DEDENT> if self.ire is not None: <NEW_LINE> <INDENT> oprot.writeFieldBegin('ire', TType.STRUCT, 1) <NEW_LINE> self.ire.write(oprot) <NEW_LINE> oprot.writeFieldEnd() <NEW_LINE> <DEDENT> oprot.writeFieldStop() <NEW_LINE> oprot.writeStructEnd() <NEW_LINE> <DEDENT> def validate(self): <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> L = ['%s=%r' % (key, value) for key, value in self.__dict__.items()] <NEW_LINE> return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) <NEW_LINE> <DEDENT> def __eq__(self, other): <NEW_LINE> <INDENT> return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ <NEW_LINE> <DEDENT> def __ne__(self, other): <NEW_LINE> <INDENT> return not (self == other) | Attributes:
- success
- ire | 625990391f5feb6acb163d98 |
class SambaProtocolEntities(View): <NEW_LINE> <INDENT> samba_username = Input(id='log_userid') <NEW_LINE> samba_password = Input(id='log_password') <NEW_LINE> samba_confirm_password = Input(id='log_verify') | Samba Protocol fields on the shedule configuration page | 6259903907d97122c4217e43 |
class OcrdZipValidator(): <NEW_LINE> <INDENT> def __init__(self, resolver, path_to_zip): <NEW_LINE> <INDENT> self.resolver = resolver <NEW_LINE> self.path_to_zip = path_to_zip <NEW_LINE> self.report = ValidationReport() <NEW_LINE> self.profile_validator = Profile(OCRD_BAGIT_PROFILE_URL, profile=OCRD_BAGIT_PROFILE) <NEW_LINE> <DEDENT> def _validate_profile(self, bag): <NEW_LINE> <INDENT> if not self.profile_validator.validate(bag): <NEW_LINE> <INDENT> raise Exception(str(self.profile_validator.report)) <NEW_LINE> <DEDENT> <DEDENT> def _validate_bag(self, bag, **kwargs): <NEW_LINE> <INDENT> failed = None <NEW_LINE> try: <NEW_LINE> <INDENT> bag.validate(**kwargs) <NEW_LINE> <DEDENT> except BagValidationError as e: <NEW_LINE> <INDENT> failed = e <NEW_LINE> <DEDENT> if failed: <NEW_LINE> <INDENT> raise BagValidationError("%s" % failed) <NEW_LINE> <DEDENT> <DEDENT> def validate(self, skip_checksums=False, skip_bag=False, skip_unzip=False, skip_delete=False, processes=2): <NEW_LINE> <INDENT> if skip_unzip: <NEW_LINE> <INDENT> bagdir = self.path_to_zip <NEW_LINE> skip_delete = True <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.profile_validator.validate_serialization(self.path_to_zip) <NEW_LINE> bagdir = mkdtemp(prefix=TMP_BAGIT_PREFIX) <NEW_LINE> unzip_file_to_dir(self.path_to_zip, bagdir) <NEW_LINE> <DEDENT> try: <NEW_LINE> <INDENT> bag = Bag(bagdir) <NEW_LINE> self._validate_profile(bag) <NEW_LINE> if not skip_bag: <NEW_LINE> <INDENT> self._validate_bag(bag, fast=skip_checksums, processes=processes) <NEW_LINE> <DEDENT> <DEDENT> finally: <NEW_LINE> <INDENT> if not skip_delete: <NEW_LINE> <INDENT> rmtree(bagdir) <NEW_LINE> <DEDENT> <DEDENT> return self.report | Validate conformance with BagIt and OCR-D bagit profile.
See:
- https://ocr-d.github.io/ocrd_zip
- https://ocr-d.github.io/bagit-profile.json
- https://ocr-d.github.io/bagit-profile.yml | 6259903971ff763f4b5e8940 |
class WaveformStreamID(QPCore.QPPublicObject): <NEW_LINE> <INDENT> addElements = QPElement.QPElementList(( QPElement.QPElement('networkCode', 'networkCode', 'attribute', unicode, 'basic'), QPElement.QPElement('stationCode', 'stationCode', 'attribute', unicode, 'basic'), QPElement.QPElement('channelCode', 'channelCode', 'attribute', unicode, 'basic'), QPElement.QPElement('locationCode', 'locationCode', 'attribute', unicode, 'basic'), QPElement.QPElement('resourceURI', 'resourceURI', 'cdata', unicode, 'basic'), )) <NEW_LINE> def __init__(self, networkCode=None, stationCode=None, channelCode=None, locationCode=None, resourceURI=None, **kwargs ): <NEW_LINE> <INDENT> super(WaveformStreamID, self).__init__(**kwargs) <NEW_LINE> self.elements.extend(self.addElements) <NEW_LINE> self.networkCode = networkCode <NEW_LINE> self.stationCode = stationCode <NEW_LINE> self.channelCode = channelCode <NEW_LINE> self.locationCode = locationCode <NEW_LINE> self.resourceURI = resourceURI <NEW_LINE> self._initMultipleElements() | QuakePy: WaveformStreamID | 62599039baa26c4b54d5044e |
class Transmitter: <NEW_LINE> <INDENT> streaming = 1 <NEW_LINE> gcode=[] <NEW_LINE> i = 0 <NEW_LINE> port="COM3" <NEW_LINE> board=57600 <NEW_LINE> ser="" <NEW_LINE> def __init__(self, port="COM3",board=57600): <NEW_LINE> <INDENT> self.board=board <NEW_LINE> self.port=port <NEW_LINE> self.filename="" <NEW_LINE> self.gcode=[]; <NEW_LINE> self.streaming = 1 <NEW_LINE> self.i=0 <NEW_LINE> <DEDENT> def readHandShake(self): <NEW_LINE> <INDENT> while True: <NEW_LINE> <INDENT> line = self.ser.readline() <NEW_LINE> if line!="": <NEW_LINE> <INDENT> print(line) <NEW_LINE> if line.startswith("Y range is from"): <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> <DEDENT> def SendStartPos(self): <NEW_LINE> <INDENT> print("start") <NEW_LINE> self.ser.write('G90\nG20\nG00 X0.000 Y0.000 Z0.000\n') <NEW_LINE> <DEDENT> def openSerial(self): <NEW_LINE> <INDENT> self.ser = serial.Serial(self.port, self.board, timeout=1) <NEW_LINE> print(self.ser.name) <NEW_LINE> <DEDENT> def readGcode(self,file): <NEW_LINE> <INDENT> f = open(file, 'r') <NEW_LINE> self.gcode = f.readlines() <NEW_LINE> f.close() <NEW_LINE> <DEDENT> def readOK(self): <NEW_LINE> <INDENT> while True: <NEW_LINE> <INDENT> line = self.ser.readline() <NEW_LINE> if "ok" in line: <NEW_LINE> <INDENT> print(line.rstrip()) <NEW_LINE> return 1 <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def sendGCode(self): <NEW_LINE> <INDENT> if self.i>=len(self.gcode): <NEW_LINE> <INDENT> return 0 <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> print(self.gcode[self.i].rstrip()) <NEW_LINE> if len(self.gcode[self.i].strip())>0: <NEW_LINE> <INDENT> self.ser.write(self.gcode[self.i]) <NEW_LINE> return 1 <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return 2 <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def Transmit(self,file): <NEW_LINE> <INDENT> self.readGcode(file) <NEW_LINE> self.openSerial() <NEW_LINE> self.streaming=self.readHandShake() <NEW_LINE> self.streaming=1 <NEW_LINE> while self.streaming==1: <NEW_LINE> <INDENT> r=self.sendGCode() <NEW_LINE> if r==1: <NEW_LINE> <INDENT> self.readOK() <NEW_LINE> <DEDENT> if r==2: <NEW_LINE> <INDENT> r=1 <NEW_LINE> <DEDENT> self.streaming=r <NEW_LINE> self.i=self.i+1 <NEW_LINE> <DEDENT> print("trans") <NEW_LINE> self.SendStartPos() <NEW_LINE> self.readOK() <NEW_LINE> self.ser.close() | A class to ranmit the data to the dvd plotter | 6259903923e79379d538d6a7 |
class TestValidateBoolTests: <NEW_LINE> <INDENT> def test_bool(self): <NEW_LINE> <INDENT> assert not config._validate_bool(False) <NEW_LINE> assert config._validate_bool(True) <NEW_LINE> <DEDENT> def test_other(self): <NEW_LINE> <INDENT> with pytest.raises(ValueError) as exc: <NEW_LINE> <INDENT> config._validate_bool({'not a': 'bool'}) <NEW_LINE> <DEDENT> assert str(exc.value) == "\"{'not a': 'bool'}\" is not a bool or a string." <NEW_LINE> <DEDENT> def test_string_falsey(self): <NEW_LINE> <INDENT> for s in ('f', 'false', 'n', 'no', 'off', '0'): <NEW_LINE> <INDENT> assert not config._validate_bool(s) <NEW_LINE> <DEDENT> <DEDENT> def test_string_other(self): <NEW_LINE> <INDENT> with pytest.raises(ValueError) as exc: <NEW_LINE> <INDENT> config._validate_bool('oops typo') <NEW_LINE> <DEDENT> assert str(exc.value) == '"oops typo" cannot be interpreted as a boolean value.' <NEW_LINE> <DEDENT> def test_string_truthy(self): <NEW_LINE> <INDENT> for s in ('t', 'true', 'y', 'yes', 'on', '1'): <NEW_LINE> <INDENT> assert config._validate_bool(s) | This class contains tests for the _validate_bool() function. | 6259903910dbd63aa1c71d7b |
class Sensor(models.Model): <NEW_LINE> <INDENT> TEMPERATURE = "T" <NEW_LINE> HUMIDITY = "Hu" <NEW_LINE> PRESSURE = "P" <NEW_LINE> SENSOR_TYPE_CHOICE = [ (TEMPERATURE, "Temperature"), (HUMIDITY, "Humidity"), (PRESSURE, "Pressure"), ] <NEW_LINE> name = models.CharField(max_length=150) <NEW_LINE> timestamp = models.DateTimeField() <NEW_LINE> measure = models.FloatField(blank=True, null=True) <NEW_LINE> sensor_type = models.CharField( max_length=2, choices=SENSOR_TYPE_CHOICE, default=TEMPERATURE, ) <NEW_LINE> device = models.ForeignKey(Device, on_delete=models.CASCADE) <NEW_LINE> def __str__(self): <NEW_LINE> <INDENT> return self.name | The sensor and its measurement | 62599039a4f1c619b294f75a |
class CTCP(BaseExtension): <NEW_LINE> <INDENT> DEFAULT_VERSION = "Powered by PyIRC v{}".format(VERSIONSTR) <NEW_LINE> def __init__(self, *args, **kwargs): <NEW_LINE> <INDENT> super().__init__(*args, **kwargs) <NEW_LINE> self.version = kwargs.get("ctcp_version", self.DEFAULT_VERSION) <NEW_LINE> <DEDENT> def ctcp(self, target, command, param=None): <NEW_LINE> <INDENT> ctcp = CTCPMessage("PRIVMSG", command.upper(), target, param) <NEW_LINE> line = ctcp.line <NEW_LINE> self.send(line.command, line.params) <NEW_LINE> <DEDENT> def nctcp(self, target, command, param=None): <NEW_LINE> <INDENT> ctcp = CTCPMessage("NOTICE", command.upper(), target, param) <NEW_LINE> line = ctcp.line <NEW_LINE> self.send(line.command, line.params) <NEW_LINE> <DEDENT> @event("commands", "PRIVMSG") <NEW_LINE> def ctcp_in(self, _, line): <NEW_LINE> <INDENT> ctcp = CTCPMessage.parse(line) <NEW_LINE> if not ctcp: <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> command = ctcp.command <NEW_LINE> self.call_event("commands_ctcp", command, ctcp, line) <NEW_LINE> <DEDENT> @event("commands", "NOTICE") <NEW_LINE> def nctcp_in(self, _, line): <NEW_LINE> <INDENT> ctcp = CTCPMessage.parse(line) <NEW_LINE> if not ctcp: <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> command = ctcp.command <NEW_LINE> self.call_event("commands_ctcp", command, ctcp, line) <NEW_LINE> <DEDENT> @event("commands_ctcp", "PING") <NEW_LINE> def c_ping(self, _, ctcp, line): <NEW_LINE> <INDENT> self.nctcp(ctcp.target, "PING", ctcp.param) <NEW_LINE> <DEDENT> @event("commands_ctcp", "VERSION") <NEW_LINE> def c_version(self, _, ctcp, line): <NEW_LINE> <INDENT> self.nctcp(ctcp.target, "VERSION", self.version) | Add CTCP dispatch functionaltiy.
Hooks may be added by having a commands_ctcp or commands_nctcp
mapping in your base class. | 62599039c432627299fa419f |
class CreateUser(Command): <NEW_LINE> <INDENT> def create_auth0_user(self, name, email, pwd): <NEW_LINE> <INDENT> return requests.post( AUTH0_API_URL, headers={ 'Authorization': 'Bearer {token}'.format(AUTH0_CREATE_USER_JWT), 'Content-Type': 'application/json'}, json={ 'username': name, 'email': email, 'password': pwd}) <NEW_LINE> <DEDENT> def create_app_user(self, name, email): <NEW_LINE> <INDENT> return User.objects.create( full_name=name, email=email) <NEW_LINE> <DEDENT> def run(self): <NEW_LINE> <INDENT> email = prompt('email') <NEW_LINE> full_name = prompt('full name') <NEW_LINE> password = prompt_pass('password') <NEW_LINE> if not User.objects.filter(email=email): <NEW_LINE> <INDENT> self.create_auth0_user(full_name, email, password) <NEW_LINE> user = self.create_app_user(full_name, email) <NEW_LINE> user_role = user_datastore.find_or_create_role('USER') <NEW_LINE> user_datastore.add_role_to_user(user, user_role) <NEW_LINE> user.update( inbox_email="{username}@{domain}".format( username=email.split('@')[0], domain=current_app.config.get('EMAIL_DOMAIN'))) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> print("User with email:", email, "already exists") | Creates a user for this app | 625990398a43f66fc4bf3334 |
class SigLenField(FieldLenField): <NEW_LINE> <INDENT> def getfield(self, pkt, s): <NEW_LINE> <INDENT> v = pkt.tls_session.tls_version <NEW_LINE> if v and v < 0x0300: <NEW_LINE> <INDENT> return s, None <NEW_LINE> <DEDENT> return super(SigLenField, self).getfield(pkt, s) <NEW_LINE> <DEDENT> def addfield(self, pkt, s, val): <NEW_LINE> <INDENT> v = pkt.tls_session.tls_version <NEW_LINE> if v and v < 0x0300: <NEW_LINE> <INDENT> return s <NEW_LINE> <DEDENT> return super(SigLenField, self).addfield(pkt, s, val) | There is a trick for SSLv2, which uses implicit lengths... | 6259903976d4e153a661db46 |
class AddProjectToClient(generics.CreateAPIView): <NEW_LINE> <INDENT> authentication_classes = (authentication.TokenAuthentication,) <NEW_LINE> permission_classes = (permissions.IsAuthenticated,) <NEW_LINE> serializer_class = EmpS <NEW_LINE> def post(self, request, *args, **kwargs): <NEW_LINE> <INDENT> client = self.kwargs['pk'] <NEW_LINE> project = Project.objects.get(pk=int(self.request.POST.get('project', None))) <NEW_LINE> client = Client.objects.get(pk=int(client)) <NEW_LINE> ProjectClient.objects.create(client=client, project=project) <NEW_LINE> return Response(status=200) <NEW_LINE> <DEDENT> def get_queryset(self): <NEW_LINE> <INDENT> ProjectClient.objects.all() | Add Project to Client | 6259903907d97122c4217e44 |
class PerformanceCounter(object): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self._count = 0 <NEW_LINE> self._jobs = 0 <NEW_LINE> self._lock = threading.Lock() <NEW_LINE> <DEDENT> def add(self, n): <NEW_LINE> <INDENT> with self._lock: <NEW_LINE> <INDENT> self._count += n <NEW_LINE> self._jobs += 1 <NEW_LINE> <DEDENT> <DEDENT> def split(self, precise=False): <NEW_LINE> <INDENT> return (self._count if precise else int(self._count)), self._jobs <NEW_LINE> <DEDENT> def reset(self, precise=False): <NEW_LINE> <INDENT> with self._lock: <NEW_LINE> <INDENT> c = self._count <NEW_LINE> j = self._jobs <NEW_LINE> self._count = 0 <NEW_LINE> self._jobs = 0 <NEW_LINE> return (c if precise else int(c)), j | This is a simple counter to record execution time and number of jobs. It's unique to each
poller instance, so does not need to be globally syncronised, just locally. | 62599039d164cc617582211b |
class TagCheckBox(QCheckBox): <NEW_LINE> <INDENT> def __init__(self, text, rightPanel): <NEW_LINE> <INDENT> QCheckBox.__init__(self, text) <NEW_LINE> self.rightPanel = rightPanel <NEW_LINE> self.stateChanged.connect(self.changeState) <NEW_LINE> <DEDENT> def changeState(self): <NEW_LINE> <INDENT> self.rightPanel.changeTags(self.text(), self.isChecked()) | Class for the Tag checkboxes that will go in the right panel.
This is only needed as a separate class to implement the changeState correctly. | 625990391d351010ab8f4cc2 |
class TypesUpdateTestCase(BaseTestGenerator): <NEW_LINE> <INDENT> scenarios = [ ('Update type under schema node', dict(url='/browser/type/obj/')) ] <NEW_LINE> def setUp(self): <NEW_LINE> <INDENT> self.db_name = parent_node_dict["database"][-1]["db_name"] <NEW_LINE> schema_info = parent_node_dict["schema"][-1] <NEW_LINE> self.server_id = schema_info["server_id"] <NEW_LINE> self.db_id = schema_info["db_id"] <NEW_LINE> db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) <NEW_LINE> if not db_con['data']["connected"]: <NEW_LINE> <INDENT> raise Exception("Could not connect to database to update a type.") <NEW_LINE> <DEDENT> self.schema_id = schema_info["schema_id"] <NEW_LINE> self.schema_name = schema_info["schema_name"] <NEW_LINE> schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) <NEW_LINE> if not schema_response: <NEW_LINE> <INDENT> raise Exception("Could not find the schema to update a type.") <NEW_LINE> <DEDENT> self.type_name = "test_type_put_%s" % (str(uuid.uuid4())[1:8]) <NEW_LINE> self.type_id = types_utils.create_type(self.server, self.db_name, self.schema_name, self.type_name ) <NEW_LINE> <DEDENT> def runTest(self): <NEW_LINE> <INDENT> type_response = types_utils.verify_type(self.server, self.db_name, self.type_name) <NEW_LINE> if not type_response: <NEW_LINE> <INDENT> raise Exception("Could not find the type to update.") <NEW_LINE> <DEDENT> data = {"id": self.type_id, "description": "this is test comment."} <NEW_LINE> response = self.tester.put( "{0}{1}/{2}/{3}/{4}/{5}".format(self.url, utils.SERVER_GROUP, self.server_id, self.db_id, self.schema_id, self.type_id ), data=json.dumps(data), follow_redirects=True) <NEW_LINE> self.assertEquals(response.status_code, 200) <NEW_LINE> <DEDENT> def tearDown(self): <NEW_LINE> <INDENT> database_utils.disconnect_database(self, self.server_id, self.db_id) | This class will update type under schema node. | 62599039507cdc57c63a5f42 |
class ChangeProposalAdmin(admin.ModelAdmin): <NEW_LINE> <INDENT> list_display = ['content_short', 'actiontype', 'contenttype', 'user', 'document', 'refitem'] | Model:
document = models.ForeignKey(Document) # Document to reference
user = models.ForeignKey(User) # Who proposed it
timestamp = models.DateTimeField(auto_now_add=True) # When
actiontype = models.IntegerField() # Type of change to make [all]
refitem = models.IntegerField() # Number what in the sequence to act on [all]
destination = models.IntegerField() # Destination of moved item, or of new item [move]
content = models.TextField() # Content for new item, or for changed item (blank=same on change) [change, add]
contenttype = models.IntegerField() # Type for new content, or of changed item (0=same on change) [change, add] | 625990390a366e3fb87ddb8e |
@dataclass(frozen=True) <NEW_LINE> class Await(UnlabeledStmt): <NEW_LINE> <INDENT> value: Expr <NEW_LINE> def render(self, indent: int = 0) -> Iterable[Line]: <NEW_LINE> <INDENT> yield Line(f"await {str(self.value)};", indent) <NEW_LINE> <DEDENT> def validate(self) -> None: <NEW_LINE> <INDENT> self.value.validate() | Await ::= [await | when] <Expr>; | 62599039b57a9660fecd2c24 |
class CurrencyField(models.DecimalField): <NEW_LINE> <INDENT> __metaclass__ = models.SubfieldBase <NEW_LINE> def to_python(self, value): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> return float(super(CurrencyField, self).to_python( value).quantize(Decimal("0.01"))) <NEW_LINE> <DEDENT> except AttributeError: <NEW_LINE> <INDENT> return None | Custom field for a proper working with currencies. Using Decimal is not
enough because it returns the value as a normal Python float, which
is problematic when doing a lot of operations. | 6259903907d97122c4217e46 |
class DaosAgentYamlParameters(YamlParameters): <NEW_LINE> <INDENT> def __init__(self, filename, common_yaml): <NEW_LINE> <INDENT> super(DaosAgentYamlParameters, self).__init__( "/run/agent_config/*", filename, None, common_yaml) <NEW_LINE> log_dir = os.environ.get("DAOS_TEST_LOG_DIR", "/tmp") <NEW_LINE> self.runtime_dir = BasicParameter(None, "/var/run/daos_agent") <NEW_LINE> self.log_file = LogParameter(log_dir, None, "daos_agent.log") <NEW_LINE> <DEDENT> def update_log_file(self, name): <NEW_LINE> <INDENT> if name is not None: <NEW_LINE> <INDENT> self.log_file.update(name, "agent_config.log_file") | Defines the daos_agent configuration yaml parameters. | 62599039b5575c28eb71359e |
class ActorFaultManager(object): <NEW_LINE> <INDENT> def __init__(self,parent,actorName,actorDef): <NEW_LINE> <INDENT> self.logger = logging.getLogger(__name__) <NEW_LINE> self.parent = parent <NEW_LINE> self.context = self.parent.context <NEW_LINE> self.actorName = actorName <NEW_LINE> self.proc = None <NEW_LINE> self.started = False <NEW_LINE> <DEDENT> def addClientDevice(self,_device): <NEW_LINE> <INDENT> appName = self.parent.appName <NEW_LINE> actorName = self.actorName <NEW_LINE> self.logger.info('actor.addClientDevice %s.%s' % (appName,actorName)) <NEW_LINE> <DEDENT> def startActor(self,proc): <NEW_LINE> <INDENT> self.proc = proc <NEW_LINE> self.started = True <NEW_LINE> <DEDENT> def stopActor(self,_proc): <NEW_LINE> <INDENT> if not self.started: return <NEW_LINE> self.started = False <NEW_LINE> <DEDENT> def cleanupActor(self): <NEW_LINE> <INDENT> pass | Fault manager for an actor | 62599039596a897236128e48 |
class ConfigurationFileRequest(object): <NEW_LINE> <INDENT> swagger_types = { 'path': 'str', 'last_read_hash': 'str' } <NEW_LINE> attribute_map = { 'path': 'path', 'last_read_hash': 'lastReadHash' } <NEW_LINE> def __init__(self, path=None, last_read_hash=None): <NEW_LINE> <INDENT> self._path = None <NEW_LINE> self._last_read_hash = None <NEW_LINE> self.discriminator = None <NEW_LINE> if path is not None: <NEW_LINE> <INDENT> self.path = path <NEW_LINE> <DEDENT> if last_read_hash is not None: <NEW_LINE> <INDENT> self.last_read_hash = last_read_hash <NEW_LINE> <DEDENT> <DEDENT> @property <NEW_LINE> def path(self): <NEW_LINE> <INDENT> return self._path <NEW_LINE> <DEDENT> @path.setter <NEW_LINE> def path(self, path): <NEW_LINE> <INDENT> self._path = path <NEW_LINE> <DEDENT> @property <NEW_LINE> def last_read_hash(self): <NEW_LINE> <INDENT> return self._last_read_hash <NEW_LINE> <DEDENT> @last_read_hash.setter <NEW_LINE> def last_read_hash(self, last_read_hash): <NEW_LINE> <INDENT> self._last_read_hash = last_read_hash <NEW_LINE> <DEDENT> def to_dict(self): <NEW_LINE> <INDENT> result = {} <NEW_LINE> for attr, _ in six.iteritems(self.swagger_types): <NEW_LINE> <INDENT> value = getattr(self, attr) <NEW_LINE> if isinstance(value, list): <NEW_LINE> <INDENT> result[attr] = list(map( lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value )) <NEW_LINE> <DEDENT> elif hasattr(value, "to_dict"): <NEW_LINE> <INDENT> result[attr] = value.to_dict() <NEW_LINE> <DEDENT> elif isinstance(value, dict): <NEW_LINE> <INDENT> result[attr] = dict(map( lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item, value.items() )) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> result[attr] = value <NEW_LINE> <DEDENT> <DEDENT> if issubclass(ConfigurationFileRequest, dict): <NEW_LINE> <INDENT> for key, value in self.items(): <NEW_LINE> <INDENT> result[key] = value <NEW_LINE> <DEDENT> <DEDENT> return result <NEW_LINE> <DEDENT> def to_str(self): <NEW_LINE> <INDENT> return pprint.pformat(self.to_dict()) <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return self.to_str() <NEW_LINE> <DEDENT> def __eq__(self, other): <NEW_LINE> <INDENT> if not isinstance(other, ConfigurationFileRequest): <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> return self.__dict__ == other.__dict__ <NEW_LINE> <DEDENT> def __ne__(self, other): <NEW_LINE> <INDENT> return not self == other | NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually. | 6259903991af0d3eaad3afdc |
class Chassis(base.APIBase): <NEW_LINE> <INDENT> uuid = wtypes.text <NEW_LINE> description = wtypes.text <NEW_LINE> extra = {wtypes.text: wtypes.text} <NEW_LINE> links = [link.Link] <NEW_LINE> def __init__(self, **kwargs): <NEW_LINE> <INDENT> self.fields = objects.Chassis.fields.keys() <NEW_LINE> for k in self.fields: <NEW_LINE> <INDENT> setattr(self, k, kwargs.get(k)) <NEW_LINE> <DEDENT> <DEDENT> @classmethod <NEW_LINE> def convert_with_links(cls, rpc_chassis): <NEW_LINE> <INDENT> chassis = Chassis.from_rpc_object(rpc_chassis) <NEW_LINE> chassis.links = [link.Link.make_link('self', pecan.request.host_url, 'chassis', chassis.uuid), link.Link.make_link('bookmark', pecan.request.host_url, 'chassis', chassis.uuid, bookmark=True) ] <NEW_LINE> return chassis | API representation of a chassis.
This class enforces type checking and value constraints, and converts
between the internal object model and the API representation of
a chassis. | 625990398da39b475be04399 |
class CourseComments(models.Model): <NEW_LINE> <INDENT> user = models.ForeignKey(UserProfile, verbose_name=u'用户') <NEW_LINE> course = models.ForeignKey(Course, verbose_name=u'课程') <NEW_LINE> comments = models.CharField(max_length=200, verbose_name=u'评论') <NEW_LINE> add_time = models.DateTimeField(default=datetime.now, verbose_name=u"添加时间") <NEW_LINE> class Meta: <NEW_LINE> <INDENT> verbose_name = u'课程评论' <NEW_LINE> verbose_name_plural = verbose_name <NEW_LINE> <DEDENT> def __unicode__(self): <NEW_LINE> <INDENT> return self.comments | 课程评论 | 6259903916aa5153ce401697 |
class SearchByAddressInputSet(InputSet): <NEW_LINE> <INDENT> def set_Address(self, value): <NEW_LINE> <INDENT> InputSet._set_input(self, 'Address', value) <NEW_LINE> <DEDENT> def set_BusinessType(self, value): <NEW_LINE> <INDENT> InputSet._set_input(self, 'BusinessType', value) <NEW_LINE> <DEDENT> def set_ConsumerKey(self, value): <NEW_LINE> <INDENT> InputSet._set_input(self, 'ConsumerKey', value) <NEW_LINE> <DEDENT> def set_ConsumerSecret(self, value): <NEW_LINE> <INDENT> InputSet._set_input(self, 'ConsumerSecret', value) <NEW_LINE> <DEDENT> def set_Range(self, value): <NEW_LINE> <INDENT> InputSet._set_input(self, 'Range', value) <NEW_LINE> <DEDENT> def set_ResponseFormat(self, value): <NEW_LINE> <INDENT> InputSet._set_input(self, 'ResponseFormat', value) <NEW_LINE> <DEDENT> def set_TokenSecret(self, value): <NEW_LINE> <INDENT> InputSet._set_input(self, 'TokenSecret', value) <NEW_LINE> <DEDENT> def set_Token(self, value): <NEW_LINE> <INDENT> InputSet._set_input(self, 'Token', value) <NEW_LINE> <DEDENT> def set_Units(self, value): <NEW_LINE> <INDENT> InputSet._set_input(self, 'Units', value) | An InputSet with methods appropriate for specifying the inputs to the SearchByAddress
Choreo. The InputSet object is used to specify input parameters when executing this Choreo. | 6259903966673b3332c3159f |
class BoundingBox(object): <NEW_LINE> <INDENT> def __init__(self, coordinates: Tuple[int, int, int, int], score: float, color: int): <NEW_LINE> <INDENT> self.coordinates = coordinates <NEW_LINE> self.score = score <NEW_LINE> self.color = color <NEW_LINE> assert color != 0, 'Bounding box should not be related to the background' | A class which represents bounding box.
| 62599039ec188e330fdf9a42 |
class TypedFileField(forms.FileField): <NEW_LINE> <INDENT> default_error_messages = { 'extension': _('File extension is not supported.'), 'mimetype': _('File mimetype is not supported.') } <NEW_LINE> def __init__(self, *args, **kwargs): <NEW_LINE> <INDENT> ext_whitelist = kwargs.pop('ext_whitelist', []) <NEW_LINE> type_whitelist = kwargs.pop('type_whitelist', []) <NEW_LINE> self.ext_whitelist = [i.lower() for i in ext_whitelist] <NEW_LINE> self.type_whitelist = [i.lower() for i in type_whitelist] <NEW_LINE> self.use_magic = kwargs.pop('use_magic', True) <NEW_LINE> super(TypedFileField, self).__init__(*args, **kwargs) <NEW_LINE> <DEDENT> def validate(self, value): <NEW_LINE> <INDENT> super(TypedFileField, self).validate(value) <NEW_LINE> if value in self.empty_values: <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> ext = pathlib.Path(value.name).name.split('.', 1)[-1] <NEW_LINE> if self.ext_whitelist and ext not in self.ext_whitelist: <NEW_LINE> <INDENT> raise forms.ValidationError(self.error_messages['extension']) <NEW_LINE> <DEDENT> if not self.type_whitelist: <NEW_LINE> <INDENT> return value <NEW_LINE> <DEDENT> if self.use_magic: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> mimetype = get_content_type(value) <NEW_LINE> <DEDENT> except Exception: <NEW_LINE> <INDENT> raise forms.ValidationError(self.error_messages['invalid']) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> mimetype = value.content_type <NEW_LINE> <DEDENT> except AttributeError: <NEW_LINE> <INDENT> raise forms.ValidationError(self.error_messages['invalid']) <NEW_LINE> <DEDENT> <DEDENT> if mimetype not in self.type_whitelist: <NEW_LINE> <INDENT> raise forms.ValidationError(self.error_messages['mimetype']) <NEW_LINE> <DEDENT> return value | Typed FileField which allows to make sure the uploaded file has
the appropriate type.
File type can be verified either by extension and/or mimetype.
This field accepts all the parameters as FileField, however in addition
it accepts some additional parameters as documented below.
Examples
--------
::
TypedFileField(ext_whitelist=['jpg', 'jpeg'],
type_whitelist=['image/jpeg'])
.. warning::
If ``use_magic`` is used, please make sure that ``python-magic``
is installed. This library does not require it by default.
Parameters
----------
ext_whitelist : list, optional
List of allowed file extensions. Note that each extension
should emit the first period. For example for filename
``'example.jpg'``, the allowed extension should be ``'jpg'``.
type_whitelist : list, optional
List of allowed file mimetypes.
use_magic : bool, optional
If ``type_whitelist`` is specified, this boolean determines
whether to use ``python-magic`` (based of top of ``libmagic``)
to determine the mimetypes of files instead of relying
on Django's ``UploadedFile.content_type``.
Django does not take any real care to determine any accurately
the mimetype so it is recommended to leave this parameter
as ``True`` which is the default value. | 62599039507cdc57c63a5f44 |
class MinefieldResponseNackPdu( MinefieldFamilyPdu ): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> super(MinefieldResponseNackPdu, self).__init__() <NEW_LINE> self.minefieldID = EntityID(); <NEW_LINE> self.requestingEntityID = EntityID(); <NEW_LINE> self.requestID = 0 <NEW_LINE> self.numberOfMissingPdus = 0 <NEW_LINE> self.missingPduSequenceNumbers = [] <NEW_LINE> self.pduType = 40 <NEW_LINE> <DEDENT> def serialize(self, outputStream): <NEW_LINE> <INDENT> super( MinefieldResponseNackPdu, self ).serialize(outputStream) <NEW_LINE> self.minefieldID.serialize(outputStream) <NEW_LINE> self.requestingEntityID.serialize(outputStream) <NEW_LINE> outputStream.write_unsigned_byte(self.requestID); <NEW_LINE> outputStream.write_unsigned_byte( len(self.missingPduSequenceNumbers)); <NEW_LINE> for anObj in self.missingPduSequenceNumbers: <NEW_LINE> <INDENT> anObj.serialize(outputStream) <NEW_LINE> <DEDENT> <DEDENT> def parse(self, inputStream): <NEW_LINE> <INDENT> super( MinefieldResponseNackPdu, self).parse(inputStream) <NEW_LINE> self.minefieldID.parse(inputStream) <NEW_LINE> self.requestingEntityID.parse(inputStream) <NEW_LINE> self.requestID = inputStream.read_unsigned_byte(); <NEW_LINE> self.numberOfMissingPdus = inputStream.read_unsigned_byte(); <NEW_LINE> for idx in range(0, self.numberOfMissingPdus): <NEW_LINE> <INDENT> element = null() <NEW_LINE> element.parse(inputStream) <NEW_LINE> self.missingPduSequenceNumbers.append(element) | proivde the means to request a retransmit of a minefield data pdu. Section 7.9.5 COMPLETE | 625990398a349b6b436873ee |
class _CppLintState(object): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.verbose_level = 1 <NEW_LINE> self.error_count = 0 <NEW_LINE> self.filters = _DEFAULT_FILTERS[:] <NEW_LINE> self._filters_backup = self.filters[:] <NEW_LINE> self.counting = 'total' <NEW_LINE> self.errors_by_category = {} <NEW_LINE> self.quiet = False <NEW_LINE> self.output_format = 'emacs' <NEW_LINE> <DEDENT> def SetOutputFormat(self, output_format): <NEW_LINE> <INDENT> self.output_format = output_format <NEW_LINE> <DEDENT> def SetQuiet(self, quiet): <NEW_LINE> <INDENT> last_quiet = self.quiet <NEW_LINE> self.quiet = quiet <NEW_LINE> return last_quiet <NEW_LINE> <DEDENT> def SetVerboseLevel(self, level): <NEW_LINE> <INDENT> last_verbose_level = self.verbose_level <NEW_LINE> self.verbose_level = level <NEW_LINE> return last_verbose_level <NEW_LINE> <DEDENT> def SetCountingStyle(self, counting_style): <NEW_LINE> <INDENT> self.counting = counting_style <NEW_LINE> <DEDENT> def SetFilters(self, filters): <NEW_LINE> <INDENT> self.filters = _DEFAULT_FILTERS[:] <NEW_LINE> self.AddFilters(filters) <NEW_LINE> <DEDENT> def AddFilters(self, filters): <NEW_LINE> <INDENT> for filt in filters.split(','): <NEW_LINE> <INDENT> clean_filt = filt.strip() <NEW_LINE> if clean_filt: <NEW_LINE> <INDENT> self.filters.append(clean_filt) <NEW_LINE> <DEDENT> <DEDENT> for filt in self.filters: <NEW_LINE> <INDENT> if not (filt.startswith('+') or filt.startswith('-')): <NEW_LINE> <INDENT> raise ValueError('Every filter in --filters must start with + or -' ' (%s does not)' % filt) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def BackupFilters(self): <NEW_LINE> <INDENT> self._filters_backup = self.filters[:] <NEW_LINE> <DEDENT> def RestoreFilters(self): <NEW_LINE> <INDENT> self.filters = self._filters_backup[:] <NEW_LINE> <DEDENT> def ResetErrorCounts(self): <NEW_LINE> <INDENT> self.error_count = 0 <NEW_LINE> self.errors_by_category = {} <NEW_LINE> <DEDENT> def IncrementErrorCount(self, category): <NEW_LINE> <INDENT> self.error_count += 1 <NEW_LINE> if self.counting in ('toplevel', 'detailed'): <NEW_LINE> <INDENT> if self.counting != 'detailed': <NEW_LINE> <INDENT> category = category.split('/')[0] <NEW_LINE> <DEDENT> if category not in self.errors_by_category: <NEW_LINE> <INDENT> self.errors_by_category[category] = 0 <NEW_LINE> <DEDENT> self.errors_by_category[category] += 1 <NEW_LINE> <DEDENT> <DEDENT> def PrintErrorCounts(self): <NEW_LINE> <INDENT> for category, count in iteritems(self.errors_by_category): <NEW_LINE> <INDENT> sys.stderr.write('Category \'%s\' errors found: %d\n' % (category, count)) <NEW_LINE> <DEDENT> sys.stdout.write('Total errors found: %d\n' % self.error_count) | Maintains module-wide state.. | 625990396fece00bbacccb57 |
class ComparisonTestFramework(Real_E_CoinTestFramework): <NEW_LINE> <INDENT> def set_test_params(self): <NEW_LINE> <INDENT> self.num_nodes = 2 <NEW_LINE> self.setup_clean_chain = True <NEW_LINE> <DEDENT> def add_options(self, parser): <NEW_LINE> <INDENT> parser.add_option("--testbinary", dest="testbinary", default=os.getenv("BITCOIND", "real_e_coind"), help="real_e_coind binary to test") <NEW_LINE> parser.add_option("--refbinary", dest="refbinary", default=os.getenv("BITCOIND", "real_e_coind"), help="real_e_coind binary to use for reference nodes (if any)") <NEW_LINE> <DEDENT> def setup_network(self): <NEW_LINE> <INDENT> extra_args = [['-whitelist=127.0.0.1']] * self.num_nodes <NEW_LINE> if hasattr(self, "extra_args"): <NEW_LINE> <INDENT> extra_args = self.extra_args <NEW_LINE> <DEDENT> self.add_nodes(self.num_nodes, extra_args, binary=[self.options.testbinary] + [self.options.refbinary] * (self.num_nodes - 1)) <NEW_LINE> self.start_nodes() | Test framework for doing p2p comparison testing
Sets up some real_e_coind binaries:
- 1 binary: test binary
- 2 binaries: 1 test binary, 1 ref binary
- n>2 binaries: 1 test binary, n-1 ref binaries | 6259903982261d6c5273079a |
class TestPagureInit: <NEW_LINE> <INDENT> def test_init(self): <NEW_LINE> <INDENT> url = "http://testing.url" <NEW_LINE> timeout = (5, 20) <NEW_LINE> requests_session = mock.Mock() <NEW_LINE> validator = Pagure(url, requests_session, timeout) <NEW_LINE> assert validator.url == url <NEW_LINE> assert validator.requests_session == requests_session <NEW_LINE> assert validator.timeout == timeout | Test class for `hotness.validators.Pagure.__init__` method. | 625990394e696a045264e6f7 |
class LongBinValidator(LongValidator): <NEW_LINE> <INDENT> def _format(self, value): <NEW_LINE> <INDENT> return self.locale.from_long(value, base=2) <NEW_LINE> <DEDENT> def _convert(self, text): <NEW_LINE> <INDENT> return self.locale.to_long(text, base=2) | A LongValidator which converts and displays as a binary string
and uses the given locale object to perform conversion. | 62599039d4950a0f3b111715 |
class _MetaIxTclApi(type): <NEW_LINE> <INDENT> def __new__(cls, clsname, clsbases, clsdict): <NEW_LINE> <INDENT> members = clsdict.get('__tcl_members__', list()) <NEW_LINE> command = clsdict.get('__tcl_command__', None) <NEW_LINE> for (n,m) in enumerate(members): <NEW_LINE> <INDENT> if not isinstance(m, TclMember): <NEW_LINE> <INDENT> raise RuntimeError('Element #%d of __tcl_members__ is not a ' 'TclMember' % (n+1,)) <NEW_LINE> <DEDENT> def fget(self, cmd=command, m=m): <NEW_LINE> <INDENT> self._ix_get(m) <NEW_LINE> val = self._api.call('%s cget -%s' % (cmd,m.name))[0] <NEW_LINE> return m.type(val) <NEW_LINE> <DEDENT> def fset(self, value, cmd=command, m=m): <NEW_LINE> <INDENT> val = self._api.call('%s config -%s %s' % (cmd,m.name,value)) <NEW_LINE> self._ix_set(m) <NEW_LINE> <DEDENT> attrname = m.attrname <NEW_LINE> if m.attrname is None: <NEW_LINE> <INDENT> attrname = translate_ix_member_name(m.name) <NEW_LINE> <DEDENT> if m.doc is not None: <NEW_LINE> <INDENT> fget.__doc__ = m.doc <NEW_LINE> <DEDENT> fget.__name__ = '_get_%s' % attrname <NEW_LINE> clsdict[fget.__name__] = fget <NEW_LINE> if not m.flags & FLAG_RDONLY: <NEW_LINE> <INDENT> fset.__name__ = '_set_%s' % attrname <NEW_LINE> clsdict[fset.__name__] = fset <NEW_LINE> p = property(fget=fget, fset=fset) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> p = property(fget=fget) <NEW_LINE> <DEDENT> clsdict[attrname] = p <NEW_LINE> <DEDENT> t = type.__new__(cls, clsname, clsbases, clsdict) <NEW_LINE> return t | Dynamically creates properties, which wraps the IxTclHAL API.
The `__tcl_members__` attribute is a list of tuples of one of the following
forms: TBD
If no attribute name is given, it is derived from the tclMemberName by
replacing every uppercase letter with the lowercase variant prepended with
a '_', eg. 'portMode' will be translated to 'port_mode'.
The generated methods assume that the class provides a method called '_ix_get'
which fetches the properties and stores them into the IxTclHal object. Eg.
for the 'port' command this would be 'port get <ch> <card> <port>'. | 625990391d351010ab8f4cc6 |
class LogsTableModel(QAbstractTableModel): <NEW_LINE> <INDENT> def __init__(self, parent=None, memory_handler=None): <NEW_LINE> <INDENT> super().__init__(parent) <NEW_LINE> self.records = [] <NEW_LINE> memory_handler.setTarget(self) <NEW_LINE> memory_handler.flush() <NEW_LINE> <DEDENT> def handle(self, record): <NEW_LINE> <INDENT> count = len(self.records) <NEW_LINE> self.beginInsertRows(QModelIndex(), count, count) <NEW_LINE> self.records.append(LogRecord( record.created, record.levelno, record.name, record.getMessage().splitlines()[0])) <NEW_LINE> self.endInsertRows() <NEW_LINE> <DEDENT> def columnCount(self, parent=None, *args, **kwargs): <NEW_LINE> <INDENT> return 4 <NEW_LINE> <DEDENT> def rowCount(self, parent=None, *args, **kwargs): <NEW_LINE> <INDENT> return len(self.records) <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def format_timestamp(record, format): <NEW_LINE> <INDENT> return datetime.fromtimestamp(record.time).strftime(format) <NEW_LINE> <DEDENT> def data(self, index, role=None): <NEW_LINE> <INDENT> row = index.row() <NEW_LINE> col = index.column() <NEW_LINE> record = self.records[row] <NEW_LINE> if role == Qt.DisplayRole: <NEW_LINE> <INDENT> if col == Column.timestamp: <NEW_LINE> <INDENT> return self.format_timestamp(record, DISPLAY_DATETIME_FORMAT) <NEW_LINE> <DEDENT> elif col == Column.level: <NEW_LINE> <INDENT> return logging.getLevelName(record.level) <NEW_LINE> <DEDENT> elif col == Column.module: <NEW_LINE> <INDENT> return record.module <NEW_LINE> <DEDENT> elif col == Column.message: <NEW_LINE> <INDENT> return record.message <NEW_LINE> <DEDENT> <DEDENT> elif role == Qt.ToolTipRole: <NEW_LINE> <INDENT> if col == Column.timestamp: <NEW_LINE> <INDENT> return self.format_timestamp(record, TOOLTIP_DATETIME_FORMAT) <NEW_LINE> <DEDENT> <DEDENT> elif role == Qt.BackgroundRole: <NEW_LINE> <INDENT> if record.level >= logging.ERROR: <NEW_LINE> <INDENT> return ERROR_BRUSH <NEW_LINE> <DEDENT> elif record.level >= logging.WARNING: <NEW_LINE> <INDENT> return WARNING_BRUSH <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def headerData(self, section, orientation, role=None): <NEW_LINE> <INDENT> if role == Qt.DisplayRole and orientation == Qt.Horizontal: <NEW_LINE> <INDENT> return ["Time", "Level", "Module", "Message"][section] | Table model that retrieves log records from Python logging module and
uses them as model data. | 62599039287bf620b6272d96 |
class UserLoginSerializer(JSONWebTokenSerializer): <NEW_LINE> <INDENT> def create(self, validated_data): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def update(self, instance, validated_data): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def validate(self, attrs): <NEW_LINE> <INDENT> credentials = { self.username_field: attrs.get(self.username_field), 'password': attrs.get('password') } <NEW_LINE> if all(credentials.values()): <NEW_LINE> <INDENT> user = authenticate(**credentials) <NEW_LINE> if user: <NEW_LINE> <INDENT> if not user.is_active: <NEW_LINE> <INDENT> raise serializers.ValidationError('账号已冻结，无法登陆') <NEW_LINE> <DEDENT> payload = jwt_payload_handler(user) <NEW_LINE> return { 'token': jwt_encode_handler(payload), 'user': user } <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> msg = _('Unable to log in with provided credentials.') <NEW_LINE> raise serializers.ValidationError(msg) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> msg = _('Must include "{username_field}" and "password".') <NEW_LINE> msg = msg.format(username_field=self.username_field) <NEW_LINE> raise serializers.ValidationError(msg) | 用户登陆获取JWT serializer | 625990399b70327d1c57ff2b |
class Ne(NpPairOperator): <NEW_LINE> <INDENT> def __init__(self, feature_left, feature_right): <NEW_LINE> <INDENT> super(Ne, self).__init__(feature_left, feature_right, "not_equal") | Not Equal Operator
Parameters
----------
feature_left : Expression
feature instance
feature_right : Expression
feature instance
Returns
----------
Feature:
bool series indicate `left != right` | 625990398da39b475be0439b |
class V1beta3_Capabilities(object): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.swaggerTypes = { 'add': 'list[v1beta3_CapabilityType]', 'drop': 'list[v1beta3_CapabilityType]' } <NEW_LINE> self.attributeMap = { 'add': 'add', 'drop': 'drop' } <NEW_LINE> self.add = None <NEW_LINE> self.drop = None | NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually. | 62599039ac7a0e7691f73694 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.