code
stringlengths 4
4.48k
| docstring
stringlengths 1
6.45k
| _id
stringlengths 24
24
|
|---|---|---|
@command(file_cmds) <NEW_LINE> class file_mkdir(_PithosContainer): <NEW_LINE> <INDENT> @errors.Generic.all <NEW_LINE> @errors.Pithos.connection <NEW_LINE> @errors.Pithos.container <NEW_LINE> def _run(self, path): <NEW_LINE> <INDENT> self.client.create_directory(self.path) <NEW_LINE> <DEDENT> def main(self, path_or_url): <NEW_LINE> <INDENT> super(self.__class__, self)._run(path_or_url) <NEW_LINE> _assert_path(self, path_or_url) <NEW_LINE> self._run(self.path) | Create a directory object
Equivalent to
kamaki file create --content-type='application/directory' | 6259908c3346ee7daa33847b |
class RepChange(JSONModel): <NEW_LINE> <INDENT> transfer = ('user_id', 'post_id', 'post_type', 'title', 'positive_rep', 'negative_rep') <NEW_LINE> def _extend(self, json, site): <NEW_LINE> <INDENT> self.on_date = datetime.date.fromtimestamp(json.on_date) <NEW_LINE> if hasattr(json, 'positive_rep') and hasattr(json, 'negative_rep'): <NEW_LINE> <INDENT> self.score = json.positive_rep - json.negative_rep | Describes an event which causes a change in reputation. | 6259908ca8370b77170f2000 |
class L7HealthConfig(AbstractModel): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.Protocol = None <NEW_LINE> self.Domain = None <NEW_LINE> self.Enable = None <NEW_LINE> self.Interval = None <NEW_LINE> self.KickNum = None <NEW_LINE> self.AliveNum = None <NEW_LINE> self.Method = None <NEW_LINE> self.StatusCode = None <NEW_LINE> self.Url = None <NEW_LINE> <DEDENT> def _deserialize(self, params): <NEW_LINE> <INDENT> self.Protocol = params.get("Protocol") <NEW_LINE> self.Domain = params.get("Domain") <NEW_LINE> self.Enable = params.get("Enable") <NEW_LINE> self.Interval = params.get("Interval") <NEW_LINE> self.KickNum = params.get("KickNum") <NEW_LINE> self.AliveNum = params.get("AliveNum") <NEW_LINE> self.Method = params.get("Method") <NEW_LINE> self.StatusCode = params.get("StatusCode") <NEW_LINE> self.Url = params.get("Url") | 七层健康检查配置
| 6259908c167d2b6e312b83b2 |
@dataclass <NEW_LINE> class ContextWrapper: <NEW_LINE> <INDENT> scheduler: RPCScheduler <NEW_LINE> con: Console <NEW_LINE> json_output: bool | Wraps some objects which are accessible in each command. | 6259908c97e22403b383cb2c |
class Room(Base): <NEW_LINE> <INDENT> __tablename__ = 'rooms' <NEW_LINE> __code_prefix__ = 'R___' <NEW_LINE> id = Column(Integer, primary_key=True, autoincrement=True) <NEW_LINE> code = Column(String(36), primary_key=False, autoincrement=False, unique=True, nullable=False) <NEW_LINE> created_datetime = Column(DateTime(timezone=True), default=datetime.utcnow()) <NEW_LINE> modified_datetime = Column(DateTime(timezone=True), onupdate=datetime.utcnow()) <NEW_LINE> active = Column(Boolean, index=True, nullable=False, default=True) <NEW_LINE> access_token = Column(String(256), index=True, nullable=False, unique=True) <NEW_LINE> def __init__(self, users=None): <NEW_LINE> <INDENT> self.code = self.__code_prefix__ + uuid.uuid4().hex <NEW_LINE> self.access_token = ''.join(random.choices(string.ascii_uppercase + string.digits + string.ascii_lowercase, k=256)) <NEW_LINE> <DEDENT> def as_dict(self): <NEW_LINE> <INDENT> return_dict = dict() <NEW_LINE> return_dict['code']=self.code <NEW_LINE> return_dict['access_token']=self.access_token <NEW_LINE> return return_dict | model for room | 6259908c60cbc95b06365b82 |
class Avatar(models.Model): <NEW_LINE> <INDENT> owner = models.ForeignKey(User, on_delete=models.CASCADE) <NEW_LINE> image = models.ImageField(upload_to="uploads/avatars/") | - owner - User foreign key
- image - imagefield | 6259908cec188e330fdfa4e3 |
class AbstractStubClass(object): <NEW_LINE> <INDENT> @staticmethod <NEW_LINE> def client_list(request, offset=None, limit=None, client_ids=None, client_token_id=None, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def client_read(request, client_id, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def country_list(request, offset=None, limit=None, country_codes=None, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def country_read(request, country_code, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def invitation_send(request, invitation_id, language=None, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def purge_expired_invitations(request, cutoff_date=None, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def organisation_list(request, offset=None, limit=None, organisation_ids=None, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def organisation_create(request, body, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def organisation_delete(request, organisation_id, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def organisation_read(request, organisation_id, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def organisation_update(request, body, organisation_id, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def request_user_deletion(request, body, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def user_list(request, offset=None, limit=None, birth_date=None, country=None, date_joined=None, email=None, email_verified=None, first_name=None, gender=None, is_active=None, last_login=None, last_name=None, msisdn=None, msisdn_verified=None, nickname=None, organisation_id=None, updated_at=None, username=None, q=None, tfa_enabled=None, has_organisation=None, order_by=None, user_ids=None, site_ids=None, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def user_delete(request, user_id, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def user_read(request, user_id, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def user_update(request, body, user_id, *args, **kwargs): <NEW_LINE> <INDENT> raise NotImplementedError() | Implementations need to be derived from this class. | 6259908c55399d3f0562814a |
class IOServicesTestStubs(object): <NEW_LINE> <INDENT> _nbio_factory = None <NEW_LINE> _native_loop = None <NEW_LINE> _use_ssl = None <NEW_LINE> def start(self): <NEW_LINE> <INDENT> raise NotImplementedError <NEW_LINE> <DEDENT> def create_nbio(self): <NEW_LINE> <INDENT> nbio = self._nbio_factory() <NEW_LINE> self.addCleanup(nbio.close) <NEW_LINE> return nbio <NEW_LINE> <DEDENT> def _run_start(self, nbio_factory, native_loop, use_ssl=False): <NEW_LINE> <INDENT> self._nbio_factory = nbio_factory <NEW_LINE> self._native_loop = native_loop <NEW_LINE> self._use_ssl = use_ssl <NEW_LINE> self.start() <NEW_LINE> <DEDENT> @run_in_thread_with_timeout <NEW_LINE> def test_with_select_connection_io_services(self): <NEW_LINE> <INDENT> from pika.adapters.select_connection import IOLoop <NEW_LINE> from pika.adapters.utils.selector_ioloop_adapter import ( SelectorIOServicesAdapter) <NEW_LINE> native_loop = IOLoop() <NEW_LINE> self._run_start( nbio_factory=lambda: SelectorIOServicesAdapter(native_loop), native_loop=native_loop) <NEW_LINE> <DEDENT> @run_in_thread_with_timeout <NEW_LINE> def test_with_tornado_io_services(self): <NEW_LINE> <INDENT> from tornado.ioloop import IOLoop <NEW_LINE> from pika.adapters.utils.selector_ioloop_adapter import ( SelectorIOServicesAdapter) <NEW_LINE> native_loop = IOLoop() <NEW_LINE> self._run_start( nbio_factory=lambda: SelectorIOServicesAdapter(native_loop), native_loop=native_loop) <NEW_LINE> <DEDENT> @unittest.skipIf(sys.version_info < (3, 4), "Asyncio is available only with Python 3.4+") <NEW_LINE> @run_in_thread_with_timeout <NEW_LINE> def test_with_asyncio_io_services(self): <NEW_LINE> <INDENT> import asyncio <NEW_LINE> from pika.adapters.asyncio_connection import ( _AsyncioIOServicesAdapter) <NEW_LINE> native_loop = asyncio.new_event_loop() <NEW_LINE> self._run_start( nbio_factory=lambda: _AsyncioIOServicesAdapter(native_loop), native_loop=native_loop) | Provides a stub test method for each combination of parameters we wish to
test | 6259908c4c3428357761bef0 |
class TestMarketQuote(unittest.TestCase): <NEW_LINE> <INDENT> def setUp(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def tearDown(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def testMarketQuote(self): <NEW_LINE> <INDENT> pass | MarketQuote unit test stubs | 6259908c5fcc89381b266f78 |
class CorreiosWSServerErrorException(Exception): <NEW_LINE> <INDENT> content = "" <NEW_LINE> http_status_code = -1 <NEW_LINE> def __init__(self, http_status_code, content=None): <NEW_LINE> <INDENT> self.content = content <NEW_LINE> self.http_status_code = http_status_code <NEW_LINE> <DEDENT> def __repr__(self, *args, **kwargs): <NEW_LINE> <INDENT> return "<CorreiosWSServerErrorException: http_status_code:{0}> " "content={1}".format(self.http_status_code, self.content) | Classe para exceções de status diferentes de HTTP 200 recebidos do servidor dos Correios | 6259908c167d2b6e312b83b3 |
class data(data_paths): <NEW_LINE> <INDENT> def __init__(self, keyword, no=1, method='', color='sep'): <NEW_LINE> <INDENT> config = configparser.ConfigParser() <NEW_LINE> config_file = '../config/' + keyword + '.ini' <NEW_LINE> config.read(config_file) <NEW_LINE> print(config_file) <NEW_LINE> params = config['params'] <NEW_LINE> self.keyword = keyword <NEW_LINE> self.method = method <NEW_LINE> self.no = no <NEW_LINE> self.path = params.get('path') <NEW_LINE> self.subdir = params.get('subdir', '') <NEW_LINE> self.color = params.get('color', color) <NEW_LINE> self.sigma = params.getfloat('sigma', 5.) <NEW_LINE> self.threshold = params.getfloat('threshold', 1.3) <NEW_LINE> self.halo_sig = params.getfloat('halo_sig', None) <NEW_LINE> self.spots_radius = params.getfloat('spots_radius', None) <NEW_LINE> self.thresh_spots = params.getfloat('thresh_spots', None) <NEW_LINE> self.lower_thresh = params.getfloat('lower_thresh', None) <NEW_LINE> self.extract = params.getint('extract', 1) <NEW_LINE> self.branch_thresh = params.getint('branch_thresh', 100) <NEW_LINE> self.analyse_flow = params.getboolean('analyse_flow', False) <NEW_LINE> self.symm_setup = params.getboolean('symm_setup', True) <NEW_LINE> self.frame_int = params.getfloat('frame_int', 1.0) <NEW_LINE> self.pixel_scaling = params.getfloat('pixel_scaling', None) <NEW_LINE> self.first = params.getint('first', 1) <NEW_LINE> self.last = params.getint('last') <NEW_LINE> self.times = tuple(int(t) if t != 'None' else None for t in params.get('times', 'None None').split()) <NEW_LINE> self.positions = tuple(int(t) if t != 'None' else None for t in params.get('positions', 'None None').split()) <NEW_LINE> self.image_prefix = params.get('image_prefix', self.subdir + '_t') <NEW_LINE> self.texas = params.get('texas', None) <NEW_LINE> self.green = params.get('green', None) <NEW_LINE> self.bf = params.get('bf', None) <NEW_LINE> self.zeros = params.getint('zeros', 3) <NEW_LINE> super(data, self).__init__() <NEW_LINE> <DEDENT> def update(self): <NEW_LINE> <INDENT> super(data, self).__init__() | Class interpreting config files given as keyword and read as
'../config/' + keyword + '.ini' (relative path!)
calls super class constructor data_paths which handles filenames and
data structure | 6259908c4c3428357761bef2 |
class IntroDialog(QtWidgets.QDialog, Ui_dialog_instructions): <NEW_LINE> <INDENT> def __init__(self, parent=None): <NEW_LINE> <INDENT> QtWidgets.QDialog.__init__(self, parent) <NEW_LINE> self.setupUi(self) <NEW_LINE> self.button_browse.clicked.connect(self.get_directory) <NEW_LINE> index = 1 <NEW_LINE> filename = f"libet_output{index}.csv" <NEW_LINE> while os.path.isfile(filename): <NEW_LINE> <INDENT> index = index + 1 <NEW_LINE> filename = f"libet_output{index}.csv" <NEW_LINE> <DEDENT> self.textbox_file.setText(filename) <NEW_LINE> <DEDENT> def reject(self): <NEW_LINE> <INDENT> self.parent().close() <NEW_LINE> <DEDENT> def get_directory(self): <NEW_LINE> <INDENT> dialog = QtWidgets.QFileDialog() <NEW_LINE> foo_dir = dialog.getExistingDirectory(self, 'Select an output directory') <NEW_LINE> foo_dir = foo_dir + '/' <NEW_LINE> self.textbox_file.setText(foo_dir) | The intro instructions dialog box. Allows selecting the output file. | 6259908cdc8b845886d551f1 |
@combiner([DMIDecode, VW]) <NEW_LINE> class VirtWhat(object): <NEW_LINE> <INDENT> def __init__(self, dmi, vw): <NEW_LINE> <INDENT> self.is_virtual = self.is_physical = None <NEW_LINE> self.generic = '' <NEW_LINE> self.specifics = [] <NEW_LINE> if vw and not vw.errors: <NEW_LINE> <INDENT> self.is_physical = vw.is_physical <NEW_LINE> self.is_virtual = vw.is_virtual <NEW_LINE> self.generic = vw.generic <NEW_LINE> self.specifics = vw.specifics <NEW_LINE> <DEDENT> if (vw is None or vw.errors) and dmi: <NEW_LINE> <INDENT> sys_info = dmi.get("system_information", [{}])[0] <NEW_LINE> bios_info = dmi.get("bios_information", [{}])[0] <NEW_LINE> dmi_info = sys_info.values() + bios_info.values() <NEW_LINE> if dmi_info: <NEW_LINE> <INDENT> for dmi_v in dmi_info: <NEW_LINE> <INDENT> if not self.generic: <NEW_LINE> <INDENT> generic = [g for g, val in GENERIC_MAP.items() if any(v in dmi_v for v in val)] <NEW_LINE> self.generic = generic[0] if generic else '' <NEW_LINE> <DEDENT> self.specifics.extend([g for g, val in SPECIFIC_MAP.items() if any(v in dmi_v for v in val)]) <NEW_LINE> <DEDENT> self.is_virtual = True <NEW_LINE> self.is_physical = False <NEW_LINE> if self.generic == '': <NEW_LINE> <INDENT> self.generic = BAREMETAL <NEW_LINE> self.is_virtual = False <NEW_LINE> self.is_physical = True <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> <DEDENT> def __contains__(self, name): <NEW_LINE> <INDENT> return name in [self.generic] + self.specifics | A combiner for checking if this machine is virtual or physical by checking
``virt-what`` or ``dmidecode`` command.
Prefer ``virt-what`` to ``dmidecode``
Attributes:
is_virtual (bool): It's running in a virtual machine?
is_physical (bool): It's running in a physical machine?
generic (str): The type of the virtual machine. 'baremetal' if physical machine.
specifics (list): List of the specific information. | 6259908c167d2b6e312b83b4 |
class Account(models.Model): <NEW_LINE> <INDENT> username = models.CharField(blank=False, max_length=80) <NEW_LINE> persona = models.ForeignKey(Persona, models.CASCADE, related_name="accounts") <NEW_LINE> servicename = 'generic service' <NEW_LINE> def __str__(self): <NEW_LINE> <INDENT> return "%s: %s" % (self.servicename, self.username) | A simple, generic account encapsulating the information shared by all
types of accounts. | 6259908c99fddb7c1ca63bf9 |
class NameGenerator(object): <NEW_LINE> <INDENT> def __init__(self, mkv_order=1): <NEW_LINE> <INDENT> self.mkv = markov.Markov(order=mkv_order) <NEW_LINE> self.generated = set() <NEW_LINE> <DEDENT> def add_example_names(self, names, allow_originals=False): <NEW_LINE> <INDENT> for name in names: <NEW_LINE> <INDENT> self.mkv.add_seq(list(name)) <NEW_LINE> if not allow_originals: <NEW_LINE> <INDENT> self.generated.add(name) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def make_name(self, filter=None): <NEW_LINE> <INDENT> while True: <NEW_LINE> <INDENT> name = "".join(self.mkv.random_chain()) <NEW_LINE> if not name in self.generated: <NEW_LINE> <INDENT> if filter==None or filter(name): <NEW_LINE> <INDENT> self.generated.add(name) <NEW_LINE> return name <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> <DEDENT> def save(self, filename): <NEW_LINE> <INDENT> with open(filename,"wb") as file: <NEW_LINE> <INDENT> pickle.dump((self.mkv.order,self.mkv.graph),file) <NEW_LINE> <DEDENT> <DEDENT> @staticmethod <NEW_LINE> def load(filename): <NEW_LINE> <INDENT> ng = NameGenerator() <NEW_LINE> order,graph = None,None <NEW_LINE> with open(filename,"rb") as file: <NEW_LINE> <INDENT> order, graph = pickle.load(file) <NEW_LINE> <DEDENT> ng.mkv.order = order <NEW_LINE> ng.mkv.graph = graph <NEW_LINE> return ng <NEW_LINE> <DEDENT> @staticmethod <NEW_LINE> def from_list_file(filename, allow_originals=False, mkv_order=1): <NEW_LINE> <INDENT> ng = NameGenerator(mkv_order) <NEW_LINE> with open(filename,"r") as file: <NEW_LINE> <INDENT> ng.add_example_names(file, allow_originals) <NEW_LINE> <DEDENT> return ng | Class for generating names using markov chains. Maintains a
set of the names already generated to ensure the same one is
not generated twice. | 6259908c26068e7796d4e57b |
class wiki_files_wizard(osv.osv_memory): <NEW_LINE> <INDENT> _name = "wiki.files.wizard" <NEW_LINE> _description = "Wiki Files Wizard" <NEW_LINE> _columns = { 'file':fields.binary('File', required=True), 'filename': fields.char('File Name', size=256, required=True), 'result': fields.text('Result', readonly=True), 'state':fields.selection([ ('first','First'), ('done','Done'), ],'State'), } <NEW_LINE> _defaults = { 'state': lambda *a: 'first', } <NEW_LINE> def publish_image(self, cr, uid, ids, data, context=None): <NEW_LINE> <INDENT> if context is None: <NEW_LINE> <INDENT> context = {} <NEW_LINE> <DEDENT> form = self.browse(cr, uid, ids[0]) <NEW_LINE> wiki_files_conf_id = self.pool.get('wiki.files.conf').search(cr, uid, [('active', '=', 1)]) <NEW_LINE> if not wiki_files_conf_id: <NEW_LINE> <INDENT> raise osv.except_osv(_('Error'),_("Configure your Wiki Files!")) <NEW_LINE> <DEDENT> wiki_conf = self.pool.get('wiki.files.conf').browse(cr, uid, wiki_files_conf_id[0]) <NEW_LINE> images = ['jpg','gif','png'] <NEW_LINE> file_name = form.filename.split('.') <NEW_LINE> if len(file_name) == 0: <NEW_LINE> <INDENT> raise osv.except_osv(_('Error'),_("File name don't have extension.")) <NEW_LINE> <DEDENT> filename = slugify(unicode(file_name[0],'UTF-8')) <NEW_LINE> filename += "."+file_name[1].lower() <NEW_LINE> path = os.path.abspath( os.path.dirname(__file__) ) <NEW_LINE> path += '/tmp/' <NEW_LINE> fileurl = wiki_conf.ftpurl <NEW_LINE> if not fileurl[-1] == '/': <NEW_LINE> <INDENT> fileurl += '/' <NEW_LINE> <DEDENT> b64_file = form.file <NEW_LINE> full_path = os.path.join(path, filename) <NEW_LINE> ofile = open(full_path, 'w') <NEW_LINE> try: <NEW_LINE> <INDENT> ofile.write(base64.decodestring(b64_file)) <NEW_LINE> <DEDENT> finally: <NEW_LINE> <INDENT> ofile.close() <NEW_LINE> <DEDENT> ftp = FTP(wiki_conf.ftpip) <NEW_LINE> ftp.login(wiki_conf.ftpusername, wiki_conf.ftppassword) <NEW_LINE> ftp.cwd(wiki_conf.ftpdirectory) <NEW_LINE> f=file(full_path,'rb') <NEW_LINE> ftp.storbinary('STOR '+os.path.basename(full_path),f) <NEW_LINE> ftp.quit() <NEW_LINE> try: <NEW_LINE> <INDENT> os.remove(full_path) <NEW_LINE> <DEDENT> except: <NEW_LINE> <INDENT> raise osv.except_osv(_('Error'),_("File don't remove local server.")) <NEW_LINE> <DEDENT> for data in data['active_ids']: <NEW_LINE> <INDENT> values = { 'file': fileurl+filename, 'media_id': data, } <NEW_LINE> self.pool.get('wiki.media').create(cr, uid, values, context) <NEW_LINE> <DEDENT> if filename[-3:] in images: <NEW_LINE> <INDENT> result = 'img:%s%s' % (fileurl,filename) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> result = '[%s%s]' % (fileurl,filename) <NEW_LINE> <DEDENT> values = { 'state':'done', 'result': result, } <NEW_LINE> self.write(cr, uid, ids, values) | wiki files | 6259908c50812a4eaa6219e2 |
class SillyStudent(SimulatedStudent): <NEW_LINE> <INDENT> def solve_task(self, *args, **kwargs): <NEW_LINE> <INDENT> return True, 60 * 20 <NEW_LINE> <DEDENT> def report_flow(self, *args, **kwargs): <NEW_LINE> <INDENT> return FlowRating.DIFFICULT | Silly student solves any task in 1 hour and rate them as too difficult
| 6259908cadb09d7d5dc0c193 |
class OAuth2SessionIdProvider (webcookie.WebcookieSessionIdProvider, database.DatabaseConnection2): <NEW_LINE> <INDENT> key = 'oauth2' <NEW_LINE> def __init__(self, config): <NEW_LINE> <INDENT> database.DatabaseConnection2.__init__(self, config) <NEW_LINE> webcookie.WebcookieSessionIdProvider.__init__(self, config) <NEW_LINE> discovery_scopes = config.get("oauth2_discovery_scopes") <NEW_LINE> if discovery_scopes is not None: <NEW_LINE> <INDENT> accepted_scopes = self.accepted_scopes_to_set(config) <NEW_LINE> final_scopes = dict() <NEW_LINE> for key in discovery_scopes.keys(): <NEW_LINE> <INDENT> if discovery_scopes[key] in accepted_scopes: <NEW_LINE> <INDENT> final_scopes[key] = discovery_scopes[key] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> web.debug("'{s}' is configured as a discovery scope but not an accepted scope".format(s=discovery_scopes[key])) <NEW_LINE> <DEDENT> <DEDENT> self.discovery_info = {"oauth2_scopes" : final_scopes} <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.discovery_info = {} <NEW_LINE> <DEDENT> <DEDENT> def accepted_scopes_to_set(self, config): <NEW_LINE> <INDENT> scopes = set() <NEW_LINE> acs = config.get("oauth2_accepted_scopes") <NEW_LINE> if isinstance(acs, list): <NEW_LINE> <INDENT> for s in acs: <NEW_LINE> <INDENT> scope = s.get("scope") <NEW_LINE> if scope is not None: <NEW_LINE> <INDENT> scopes.add(scope) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> return scopes <NEW_LINE> <DEDENT> def get_discovery_info(self): <NEW_LINE> <INDENT> return(self.discovery_info) <NEW_LINE> <DEDENT> def get_request_sessionids(self, manager, context, db=None): <NEW_LINE> <INDENT> bearer_token = bearer_token_util.token_from_request() <NEW_LINE> if bearer_token != None: <NEW_LINE> <INDENT> m = hashlib.md5() <NEW_LINE> m.update(bearer_token.encode()) <NEW_LINE> return(["oauth2-hash:{hash}".format(hash=m.hexdigest())]) <NEW_LINE> <DEDENT> return webcookie.WebcookieSessionIdProvider.get_request_sessionids(self, manager, context, db) <NEW_LINE> <DEDENT> def create_unique_sessionids(self, manager, context, db=None): <NEW_LINE> <INDENT> context.session.keys = self.get_request_sessionids(manager, context, db) <NEW_LINE> if context.session.keys == None or len(context.session.keys) == 0: <NEW_LINE> <INDENT> webcookie.WebcookieSessionIdProvider.create_unique_sessionids(self, manager, context, db) | OAuth2SessionIdProvider implements session IDs based on HTTP cookies or OAuth2 Authorization headers | 6259908c7cff6e4e811b767c |
class TestMarketQuoteFill(unittest.TestCase): <NEW_LINE> <INDENT> def setUp(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def tearDown(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def testMarketQuoteFill(self): <NEW_LINE> <INDENT> pass | MarketQuoteFill unit test stubs | 6259908cbe7bc26dc9252c72 |
class EventProcessor: <NEW_LINE> <INDENT> @classmethod <NEW_LINE> async def run(cls): <NEW_LINE> <INDENT> file_path = input(constants.file_prompt) <NEW_LINE> if os.path.isfile(file_path): <NEW_LINE> <INDENT> print('Reading file...') <NEW_LINE> with open(file_path, 'r') as fd: <NEW_LINE> <INDENT> data = json.load(fd) <NEW_LINE> <DEDENT> await cls.apply_rules(data) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> print('Please provide a correct file path') <NEW_LINE> <DEDENT> <DEDENT> @classmethod <NEW_LINE> async def apply_rules(cls, data): <NEW_LINE> <INDENT> invalid_events = [] <NEW_LINE> await DbHelper.purge_table(constants.results_table) <NEW_LINE> for event in data: <NEW_LINE> <INDENT> event_rules = await DbHelper.get_rules(constants.rules_table, 'signal', event['signal'], 'value_type', event['value_type'].lower()) <NEW_LINE> if event_rules: <NEW_LINE> <INDENT> event_test = await cls.if_violates(event, event_rules) <NEW_LINE> if not event_test: <NEW_LINE> <INDENT> await DbHelper.insert(constants.results_table, event) <NEW_LINE> invalid_events.append(event) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> if invalid_events: <NEW_LINE> <INDENT> print('Invalid Data') <NEW_LINE> print(invalid_events) <NEW_LINE> <DEDENT> <DEDENT> @classmethod <NEW_LINE> async def if_violates(cls, event, event_rules): <NEW_LINE> <INDENT> for rule in event_rules: <NEW_LINE> <INDENT> comparator = getattr(Operations, constants.rules[rule['value_type']][rule['rule']]) <NEW_LINE> result = await comparator(event, rule) <NEW_LINE> if not result: <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> <DEDENT> return True | Class for processing streaming events | 6259908c5fcc89381b266f7a |
class Rnn(EncoderNetwork): <NEW_LINE> <INDENT> @staticmethod <NEW_LINE> def get_module_id(): <NEW_LINE> <INDENT> return 'rnn' <NEW_LINE> <DEDENT> def __init__(self, args): <NEW_LINE> <INDENT> super().__init__(args) <NEW_LINE> self.rnn_cell = None <NEW_LINE> <DEDENT> def build(self): <NEW_LINE> <INDENT> self.rnn_cell = tfutils.get_rnn_cell(self.args, "deco_cell") <NEW_LINE> <DEDENT> def init_state(self): <NEW_LINE> <INDENT> return self.rnn_cell.zero_state(batch_size=self.args.batch_size, dtype=tf.float32) <NEW_LINE> <DEDENT> def get_cell(self, prev_keyboard, prev_state): <NEW_LINE> <INDENT> prev_state_enco, prev_state_deco = prev_state <NEW_LINE> axis = 1 <NEW_LINE> assert prev_keyboard.get_shape()[axis].value == music.NB_NOTES <NEW_LINE> inputs = tf.split(axis, music.NB_NOTES, prev_keyboard) <NEW_LINE> _, final_state = tf.nn.rnn( self.rnn_cell, inputs, initial_state=prev_state_deco ) <NEW_LINE> return final_state | Read each keyboard configuration note by note and encode it's configuration
| 6259908ca05bb46b3848bf42 |
class Rift: <NEW_LINE> <INDENT> def __init__(self, bot): <NEW_LINE> <INDENT> self.bot = bot <NEW_LINE> self.open_rifts = {} <NEW_LINE> <DEDENT> @commands.command(pass_context=True) <NEW_LINE> async def riftopen(self, ctx, channel): <NEW_LINE> <INDENT> author = ctx.message.author <NEW_LINE> author_channel = ctx.message.channel <NEW_LINE> def check(m): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> return channels[int(m.content)] <NEW_LINE> <DEDENT> except: <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> <DEDENT> channels = self.bot.get_all_channels() <NEW_LINE> channels = [c for c in channels if c.name.lower() == channel or c.id == channel] <NEW_LINE> channels = [c for c in channels if c.type == discord.ChannelType.text] <NEW_LINE> if not channels: <NEW_LINE> <INDENT> await self.bot.say("No channels found. Remember to type just " "the channel name, no `#`.") <NEW_LINE> return <NEW_LINE> <DEDENT> if len(channels) > 1: <NEW_LINE> <INDENT> msg = "Multiple results found.\nChoose a server:\n" <NEW_LINE> for i, channel in enumerate(channels): <NEW_LINE> <INDENT> msg += "{} - {} ({})\n".format(i, channel.server, channel.id) <NEW_LINE> <DEDENT> for page in pagify(msg): <NEW_LINE> <INDENT> await self.bot.say(page) <NEW_LINE> <DEDENT> choice = await self.bot.wait_for_message(author=author, timeout=30, check=check, channel=author_channel) <NEW_LINE> if choice is None: <NEW_LINE> <INDENT> await self.bot.say("You haven't chosen anything.") <NEW_LINE> return <NEW_LINE> <DEDENT> channel = channels[int(choice.content)] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> channel = channels[0] <NEW_LINE> <DEDENT> rift = OpenRift(source=author_channel, destination=channel) <NEW_LINE> self.open_rifts[author] = rift <NEW_LINE> await self.bot.say("A rift has been opened! Everything you say " "will be relayed to that channel.\n" "Responses will be relayed here.\nType " "`exit` to quit.") <NEW_LINE> msg = "" <NEW_LINE> while msg == "" or msg is not None: <NEW_LINE> <INDENT> msg = await self.bot.wait_for_message(author=author, channel=author_channel) <NEW_LINE> if msg is not None and msg.content.lower() != "exit": <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> await self.bot.send_message(channel, msg.content) <NEW_LINE> <DEDENT> except: <NEW_LINE> <INDENT> await self.bot.say("Couldn't send your message.") <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> <DEDENT> del self.open_rifts[author] <NEW_LINE> await self.bot.say("Rift closed.") <NEW_LINE> <DEDENT> async def on_message(self, message): <NEW_LINE> <INDENT> if message.author == self.bot.user: <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> for k, v in self.open_rifts.items(): <NEW_LINE> <INDENT> if v.destination == message.channel: <NEW_LINE> <INDENT> msg = "{}: {}".format(message.author, message.content) <NEW_LINE> msg = escape(msg, mass_mentions=True) <NEW_LINE> await self.bot.send_message(v.source, msg) | Communicate with other servers/channels! | 6259908cdc8b845886d551f3 |
class GameSprite(pygame.sprite.Sprite): <NEW_LINE> <INDENT> def __init__(self, image_name, speed=1): <NEW_LINE> <INDENT> super().__init__() <NEW_LINE> self.image = pygame.image.load(image_name) <NEW_LINE> self.speed = speed <NEW_LINE> self.rect = self.image.get_rect() <NEW_LINE> <DEDENT> def update(self): <NEW_LINE> <INDENT> self.rect.y += self.speed | 飞机精灵 | 6259908c283ffb24f3cf54db |
class HomeKitGarageDoorCover(HomeKitEntity, CoverDevice): <NEW_LINE> <INDENT> def __init__(self, accessory, discovery_info): <NEW_LINE> <INDENT> super().__init__(accessory, discovery_info) <NEW_LINE> self._state = None <NEW_LINE> self._obstruction_detected = None <NEW_LINE> self.lock_state = None <NEW_LINE> <DEDENT> @property <NEW_LINE> def device_class(self): <NEW_LINE> <INDENT> return "garage" <NEW_LINE> <DEDENT> def get_characteristic_types(self): <NEW_LINE> <INDENT> return [ CharacteristicsTypes.DOOR_STATE_CURRENT, CharacteristicsTypes.DOOR_STATE_TARGET, CharacteristicsTypes.OBSTRUCTION_DETECTED, ] <NEW_LINE> <DEDENT> def _update_door_state_current(self, value): <NEW_LINE> <INDENT> self._state = CURRENT_GARAGE_STATE_MAP[value] <NEW_LINE> <DEDENT> def _update_obstruction_detected(self, value): <NEW_LINE> <INDENT> self._obstruction_detected = value <NEW_LINE> <DEDENT> @property <NEW_LINE> def supported_features(self): <NEW_LINE> <INDENT> return SUPPORT_OPEN | SUPPORT_CLOSE <NEW_LINE> <DEDENT> @property <NEW_LINE> def is_closed(self): <NEW_LINE> <INDENT> return self._state == STATE_CLOSED <NEW_LINE> <DEDENT> @property <NEW_LINE> def is_closing(self): <NEW_LINE> <INDENT> return self._state == STATE_CLOSING <NEW_LINE> <DEDENT> @property <NEW_LINE> def is_opening(self): <NEW_LINE> <INDENT> return self._state == STATE_OPENING <NEW_LINE> <DEDENT> async def async_open_cover(self, **kwargs): <NEW_LINE> <INDENT> await self.set_door_state(STATE_OPEN) <NEW_LINE> <DEDENT> async def async_close_cover(self, **kwargs): <NEW_LINE> <INDENT> await self.set_door_state(STATE_CLOSED) <NEW_LINE> <DEDENT> async def set_door_state(self, state): <NEW_LINE> <INDENT> characteristics = [ { "aid": self._aid, "iid": self._chars["door-state.target"], "value": TARGET_GARAGE_STATE_MAP[state], } ] <NEW_LINE> await self._accessory.put_characteristics(characteristics) <NEW_LINE> <DEDENT> @property <NEW_LINE> def device_state_attributes(self): <NEW_LINE> <INDENT> if self._obstruction_detected is None: <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> return {"obstruction-detected": self._obstruction_detected} | Representation of a HomeKit Garage Door. | 6259908c7cff6e4e811b767e |
class MultilineInfo(SimpleAckReply): <NEW_LINE> <INDENT> def __init__(self, line): <NEW_LINE> <INDENT> super().__init__(line) <NEW_LINE> self.lines = [] <NEW_LINE> <DEDENT> def __repr__(self): <NEW_LINE> <INDENT> return "<%s:%s (+%d)>" % (self.__class__.__name__, repr(self.line), len(self.lines)) | Reply starts with ``=``: Multi-line. | 6259908cd8ef3951e32c8c7b |
class B(A): <NEW_LINE> <INDENT> pass | Class B.
Attributes
----------
{A.Attributes}
Examples
--------
>>> b = B()
>>> b.x
1 | 6259908c167d2b6e312b83b6 |
class ListTeamLogsResponse(object): <NEW_LINE> <INDENT> swagger_types = { 'request_id': 'str', 'took': 'float', 'data': 'TeamLog' } <NEW_LINE> attribute_map = { 'request_id': 'requestId', 'took': 'took', 'data': 'data' } <NEW_LINE> def __init__(self, request_id=None, took=0.0, data=None): <NEW_LINE> <INDENT> self._request_id = None <NEW_LINE> self._took = None <NEW_LINE> self._data = None <NEW_LINE> self.discriminator = None <NEW_LINE> self.request_id = request_id <NEW_LINE> self.took = took <NEW_LINE> if data is not None: <NEW_LINE> <INDENT> self.data = data <NEW_LINE> <DEDENT> <DEDENT> @property <NEW_LINE> def request_id(self): <NEW_LINE> <INDENT> return self._request_id <NEW_LINE> <DEDENT> @request_id.setter <NEW_LINE> def request_id(self, request_id): <NEW_LINE> <INDENT> if request_id is None: <NEW_LINE> <INDENT> raise ValueError("Invalid value for `request_id`, must not be `None`") <NEW_LINE> <DEDENT> self._request_id = request_id <NEW_LINE> <DEDENT> @property <NEW_LINE> def took(self): <NEW_LINE> <INDENT> return self._took <NEW_LINE> <DEDENT> @took.setter <NEW_LINE> def took(self, took): <NEW_LINE> <INDENT> if took is None: <NEW_LINE> <INDENT> raise ValueError("Invalid value for `took`, must not be `None`") <NEW_LINE> <DEDENT> self._took = took <NEW_LINE> <DEDENT> @property <NEW_LINE> def data(self): <NEW_LINE> <INDENT> return self._data <NEW_LINE> <DEDENT> @data.setter <NEW_LINE> def data(self, data): <NEW_LINE> <INDENT> self._data = data <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> 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, ListTeamLogsResponse): <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. | 6259908cad47b63b2c5a948e |
class ColorByChain(ColorFromPalette): <NEW_LINE> <INDENT> def guiCallback(self): <NEW_LINE> <INDENT> nodes = self.vf.getSelection() <NEW_LINE> if not nodes: <NEW_LINE> <INDENT> return 'Error' <NEW_LINE> <DEDENT> val = self.showForm('default', scrolledFrame = 1, width= 500, height = 200, force=1) <NEW_LINE> if val: <NEW_LINE> <INDENT> geomsToColor = val['geomsToColor'] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> geomsToColor = None <NEW_LINE> return <NEW_LINE> <DEDENT> if val['Carbons']: <NEW_LINE> <INDENT> nodes = nodes.findType(Atom).get('C*') <NEW_LINE> del val['Carbons'] <NEW_LINE> <DEDENT> self.doitWrapper(nodes, geomsToColor, redraw=1) <NEW_LINE> <DEDENT> def onAddObjectToViewer(self, obj): <NEW_LINE> <INDENT> for c in obj.chains: <NEW_LINE> <INDENT> c.number = self.vf.Mols.chains.index(c) <NEW_LINE> <DEDENT> if 'color' not in self.vf.commands : <NEW_LINE> <INDENT> self.vf.loadCommand('colorCommands', 'color', 'Pmv', topCommand=0) <NEW_LINE> <DEDENT> self.cleanup() <NEW_LINE> <DEDENT> def onAddCmdToViewer(self): <NEW_LINE> <INDENT> if self.vf.hasGui: <NEW_LINE> <INDENT> self.carbons = Tkinter.IntVar() <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.carbons = Checkbutton() <NEW_LINE> <DEDENT> self.carbons.set(0) <NEW_LINE> if self.vf.hasGui: <NEW_LINE> <INDENT> paletteClass = ColorPaletteFunction <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> paletteClass = ColorPaletteFunctionNG <NEW_LINE> <DEDENT> from mglutil.util.defaultPalettes import MolColors, Rainbow, RainbowSortedKey <NEW_LINE> c = 'Color palette chain number' <NEW_LINE> self.palette = paletteClass( 'MolColors', MolColors, readonly=0, info=c, lookupFunction = lambda x, length = len(RainbowSortedKey): x.number%length, sortedkeys = RainbowSortedKey) <NEW_LINE> if 'color' not in self.vf.commands : <NEW_LINE> <INDENT> self.vf.loadCommand('colorCommands', 'color', 'Pmv', topCommand=0) <NEW_LINE> <DEDENT> self.undoCmdsString= self.vf.color.name <NEW_LINE> <DEDENT> def getColors(self, nodes): <NEW_LINE> <INDENT> if not nodes: return <NEW_LINE> colors = self.palette.lookup(nodes.findType(Chain)) <NEW_LINE> return colors <NEW_LINE> <DEDENT> def buildFormDescr(self, formName): <NEW_LINE> <INDENT> idf = ColorFromPalette.buildFormDescr(self, formName) <NEW_LINE> idf.insert(2, {'widgetType':Tkinter.Checkbutton, 'name':'Carbons', 'defaultValue':0, 'wcfg':{'text':'Carbons Only', 'indicatoron':0,'height':1,'pady':5,'padx':5, 'variable':self.carbons}, 'gridcfg':{'row':-1,'sticky':'we'}}) <NEW_LINE> return idf | The colorByChain command allows the user to color the given geometries representing the given nodes by chain. A different color is assigned to each chain.
Package : Pmv
Module : colorCommands
Class : ColorByChain
Command : colorByChain
Synopsis:
None <- colorByChain(nodes, geomsToColor='all', **kw)
nodes --- any set of MolKit nodes describing molecular components
geomsToColor --- list of the name of geometries to color default is 'all'
Keywords --- color, chain
| 6259908c71ff763f4b5e93eb |
class CalibrationlessReconstructor(ReconstructorBase): <NEW_LINE> <INDENT> def __init__(self, fourier_op, linear_op=None, gradient_formulation="synthesis", n_jobs=1, verbose=0, **kwargs): <NEW_LINE> <INDENT> if linear_op is None: <NEW_LINE> <INDENT> linear_op = WaveletN( wavelet_name="sym8", nb_scale=3, dim=len(fourier_op.shape), n_coils=fourier_op.n_coils, n_jobs=n_jobs, verbose=bool(verbose >= 30), ) <NEW_LINE> <DEDENT> if fourier_op.n_coils != linear_op.n_coils: <NEW_LINE> <INDENT> raise ValueError("The value of n_coils for fourier and wavelet " "operation must be same for " "calibrationless reconstruction!") <NEW_LINE> <DEDENT> if gradient_formulation == 'analysis': <NEW_LINE> <INDENT> grad_class = GradAnalysis <NEW_LINE> <DEDENT> elif gradient_formulation == 'synthesis': <NEW_LINE> <INDENT> grad_class = GradSynthesis <NEW_LINE> <DEDENT> super().__init__( fourier_op=fourier_op, linear_op=linear_op, gradient_formulation=gradient_formulation, grad_class=grad_class, verbose=verbose, **kwargs, ) | Calibrationless reconstruction implementation.
Notes
-----
For the Analysis case, finds the solution for x of:
..math:: (1/2) * sum(||F x_l - y_l||^2_2, n_coils) +
mu * H(W x_l)
For the Synthesis case, finds the solution of:
..math:: (1/2) * sum(||F Wt alpha_l - y_l||^2_2, n_coils) +
mu * H(alpha_l)
Parameters
----------
fourier_op: instance of OperatorBase.
Defines the fourier operator F in the above equation.
linear_op: instance of OperatorBase, default None.
Defines the linear sparsifying operator W. This must operate on x and
have 2 functions, op(x) and adj_op(coeff) which implements the
operator and adjoint operator. For wavelets, this can be object of
class WaveletN or WaveletUD2 from mri.operators .
If None, sym8 wavelet with nb_scale=3 is chosen.
gradient_formulation: str between 'analysis' or 'synthesis',
default 'synthesis'
defines the formulation of the image model which defines the gradient.
n_jobs : int, default 1
The number of cores to be used for faster reconstruction
verbose: int, optional default 0
Verbosity levels
1 => Print basic debug information
5 => Print all initialization information
20 => Calculate cost at the end of each iteration.
30 => Print the debug information of operators if defined by class
NOTE - High verbosity (>20) levels are computationally intensive.
**kwargs : Extra keyword arguments
for gradient initialization:
Please refer to mri.operators.gradient.base for information
regularizer_op: operator, (optional default None)
Defines the regularization operator for the regularization
function H. If None, the regularization chosen is Identity and
the optimization turns to gradient descent.
See Also
--------
ReconstructorBase : parent class | 6259908c26068e7796d4e580 |
class ContentTypeRestrictedFileField(models.FileField): <NEW_LINE> <INDENT> def __init__(self, *args, **kwargs): <NEW_LINE> <INDENT> self.content_types = kwargs.pop("content_types") <NEW_LINE> self.max_upload_size = kwargs.pop("max_upload_size") <NEW_LINE> super(ContentTypeRestrictedFileField, self).__init__(*args, **kwargs) <NEW_LINE> <DEDENT> def clean(self, *args, **kwargs): <NEW_LINE> <INDENT> data = super(ContentTypeRestrictedFileField, self).clean(*args, **kwargs) <NEW_LINE> file = data.file <NEW_LINE> try: <NEW_LINE> <INDENT> content_type = file.content_type <NEW_LINE> if content_type in self.content_types: <NEW_LINE> <INDENT> if file._size > self.max_upload_size: <NEW_LINE> <INDENT> raise forms.ValidationError('O tamanho do arquivo não deve ultrapassar %s, o arquivo enviado possui %s. Por favor, corrija este erro.' % (filesizeformat(self.max_upload_size), filesizeformat(file._size))) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> raise forms.ValidationError('Tipo de arquivo não suportado.') <NEW_LINE> <DEDENT> <DEDENT> except AttributeError: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> return data | Same as FileField, but you can specify:
* content_types - list containing allowed content_types. Example: ['application/pdf', 'image/jpeg']
* max_upload_size - a number indicating the maximum file size allowed for upload.
2.5MB - 2621440
5MB - 5242880
10MB - 10485760
20MB - 20971520
50MB - 5242880
100MB 104857600
250MB - 214958080
500MB - 429916160 | 6259908c656771135c48ae50 |
class TopicManager(object): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.namespaces = Namespace() <NEW_LINE> self.logger = logging.getLogger(__name__) <NEW_LINE> <DEDENT> def registerTopic(self, name, msgType = None): <NEW_LINE> <INDENT> parts = name.split("/") <NEW_LINE> namespace = self.namespaces <NEW_LINE> self.logger.debug(str(parts)) <NEW_LINE> if (len(parts) >= 1): <NEW_LINE> <INDENT> for n in range(1, len(parts) - 1): <NEW_LINE> <INDENT> if parts[n] not in namespace.__dict__: <NEW_LINE> <INDENT> namespace.__dict__[parts[n]] = Namespace() <NEW_LINE> <DEDENT> namespace = namespace.__dict__[parts[n]] <NEW_LINE> <DEDENT> <DEDENT> namespace.__dict__[parts[len(parts) - 1]] = genMethodInvocator(name) | This class is responsbile for handling topic creation and namespace registration | 6259908c4a966d76dd5f0b24 |
class logger(object): <NEW_LINE> <INDENT> thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') <NEW_LINE> __repr__ = _swig_repr <NEW_LINE> def __init__(self, *args, **kwargs): <NEW_LINE> <INDENT> this = _runtime_swig.new_logger(*args, **kwargs) <NEW_LINE> try: self.this.append(this) <NEW_LINE> except: self.this = this <NEW_LINE> <DEDENT> def set_level(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_set_level(self, *args, **kwargs) <NEW_LINE> <DEDENT> def get_level(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_get_level(self, *args, **kwargs) <NEW_LINE> <DEDENT> def debug(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_debug(self, *args, **kwargs) <NEW_LINE> <DEDENT> def info(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_info(self, *args, **kwargs) <NEW_LINE> <DEDENT> def notice(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_notice(self, *args, **kwargs) <NEW_LINE> <DEDENT> def warn(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_warn(self, *args, **kwargs) <NEW_LINE> <DEDENT> def error(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_error(self, *args, **kwargs) <NEW_LINE> <DEDENT> def crit(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_crit(self, *args, **kwargs) <NEW_LINE> <DEDENT> def alert(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_alert(self, *args, **kwargs) <NEW_LINE> <DEDENT> def fatal(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_fatal(self, *args, **kwargs) <NEW_LINE> <DEDENT> def emerg(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_emerg(self, *args, **kwargs) <NEW_LINE> <DEDENT> def errorIF(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_errorIF(self, *args, **kwargs) <NEW_LINE> <DEDENT> def log_assert(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_log_assert(self, *args, **kwargs) <NEW_LINE> <DEDENT> def add_console_appender(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_add_console_appender(self, *args, **kwargs) <NEW_LINE> <DEDENT> def add_file_appender(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_add_file_appender(self, *args, **kwargs) <NEW_LINE> <DEDENT> def add_rollingfile_appender(self, *args, **kwargs): <NEW_LINE> <INDENT> return _runtime_swig.logger_add_rollingfile_appender(self, *args, **kwargs) <NEW_LINE> <DEDENT> __swig_destroy__ = _runtime_swig.delete_logger <NEW_LINE> __del__ = lambda self : None; | Proxy of C++ gr::logger class | 6259908c091ae35668706883 |
class PCCcdb(Component): <NEW_LINE> <INDENT> name = "pcccdb" <NEW_LINE> cmd = "sh -x ./tools/wdbtools/seekglobal.sh " | docstring for PCCcdb | 6259908caad79263cf4303f2 |
class LookupError(Exception): <NEW_LINE> <INDENT> pass | | Base class for lookup errors.
|
| Method resolution order:
| LookupError
| Exception
| BaseException
| object
|
| Methods defined here:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from BaseException:
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setattr__(self, name, value, /)
| Implement setattr(self, name, value).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
| 6259908c4527f215b58eb7bf |
class NodeStore: <NEW_LINE> <INDENT> def __init__(self, nodes): <NEW_LINE> <INDENT> self.nodes = nodes <NEW_LINE> <DEDENT> def getNode(self, nodeIdentifier): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> return defer.succeed(self.nodes[nodeIdentifier]) <NEW_LINE> <DEDENT> except KeyError: <NEW_LINE> <INDENT> return defer.fail(error.NodeNotFound()) | I just store nodes to pose as an L{IStorage} implementation. | 6259908c5fcc89381b266f7d |
class TestSuiteRunner(object): <NEW_LINE> <INDENT> def __init__(self, verbosity = 1): <NEW_LINE> <INDENT> self.verbosity = verbosity <NEW_LINE> <DEDENT> def setup_test_environment(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def teardown_test_environment(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> def run_tests(self, modules): <NEW_LINE> <INDENT> self.setup_test_environment() <NEW_LINE> suite = self.build_suite(modules) <NEW_LINE> self.run_suite(suite) <NEW_LINE> <DEDENT> def close_tests(self, result): <NEW_LINE> <INDENT> self.teardown_test_environment() <NEW_LINE> return self.suite_result(suite, result) <NEW_LINE> <DEDENT> def build_suite(self, modules): <NEW_LINE> <INDENT> loader = TestLoader() <NEW_LINE> return loader.loadTestsFromModules(modules) <NEW_LINE> <DEDENT> def run_suite(self, suite): <NEW_LINE> <INDENT> return TextTestRunner(verbosity = self.verbosity).run(suite) <NEW_LINE> <DEDENT> def suite_result(self, suite, result, **kwargs): <NEW_LINE> <INDENT> return len(result.failures) + len(result.errors) | A suite runner with twisted if available. | 6259908c3346ee7daa338481 |
class SharingPermissions(SigmaObject): <NEW_LINE> <INDENT> def __init__(self, mapid=None, global_permissions=None): <NEW_LINE> <INDENT> self.mapid = mapid <NEW_LINE> self.shared_with = {} <NEW_LINE> if global_permissions is None: <NEW_LINE> <INDENT> self.permissions = {"global": "private"} <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.permissions = global_permissions <NEW_LINE> <DEDENT> <DEDENT> def share(self, user): <NEW_LINE> <INDENT> self.shared_with[user] = "all" <NEW_LINE> <DEDENT> def unshare(self, user): <NEW_LINE> <INDENT> self.shared_with.pop(user) <NEW_LINE> <DEDENT> def update(self, permissions): <NEW_LINE> <INDENT> self.permissions = permissions <NEW_LINE> <DEDENT> def __getitem__(self, permissiontype): <NEW_LINE> <INDENT> return self.permissions[permissiontype] | Holding sharing permisions for a users' map.
Currently only public/private is beeing used. | 6259908cd486a94d0ba2dbf3 |
class MatchFirst(ParseExpression): <NEW_LINE> <INDENT> def __init__( self, exprs, savelist = False ): <NEW_LINE> <INDENT> super(MatchFirst,self).__init__(exprs, savelist) <NEW_LINE> if self.exprs: <NEW_LINE> <INDENT> self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.mayReturnEmpty = True <NEW_LINE> <DEDENT> <DEDENT> def parseImpl( self, instring, loc, doActions=True ): <NEW_LINE> <INDENT> maxExcLoc = -1 <NEW_LINE> maxException = None <NEW_LINE> for e in self.exprs: <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> ret = e._parse( instring, loc, doActions ) <NEW_LINE> return ret <NEW_LINE> <DEDENT> except ParseException as err: <NEW_LINE> <INDENT> if err.loc > maxExcLoc: <NEW_LINE> <INDENT> maxException = err <NEW_LINE> maxExcLoc = err.loc <NEW_LINE> <DEDENT> <DEDENT> except IndexError: <NEW_LINE> <INDENT> if len(instring) > maxExcLoc: <NEW_LINE> <INDENT> maxException = ParseException(instring,len(instring),e.errmsg,self) <NEW_LINE> maxExcLoc = len(instring) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> if maxException is not None: <NEW_LINE> <INDENT> maxException.msg = self.errmsg <NEW_LINE> raise maxException <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise ParseException(instring, loc, "no defined alternatives to match", self) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def __ior__(self, other ): <NEW_LINE> <INDENT> if isinstance( other, str ): <NEW_LINE> <INDENT> other = ParserElement._literalStringClass( other ) <NEW_LINE> <DEDENT> return self.append( other ) <NEW_LINE> <DEDENT> def __str__( self ): <NEW_LINE> <INDENT> if hasattr(self,"name"): <NEW_LINE> <INDENT> return self.name <NEW_LINE> <DEDENT> if self.strRepr is None: <NEW_LINE> <INDENT> self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}" <NEW_LINE> <DEDENT> return self.strRepr <NEW_LINE> <DEDENT> def checkRecursion( self, parseElementList ): <NEW_LINE> <INDENT> subRecCheckList = parseElementList[:] + [ self ] <NEW_LINE> for e in self.exprs: <NEW_LINE> <INDENT> e.checkRecursion( subRecCheckList ) | Requires that at least one C{ParseExpression} is found.
If two expressions match, the first one listed is the one that will match.
May be constructed using the C{'|'} operator.
Example::
# construct MatchFirst using '|' operator
# watch the order of expressions to match
number = Word(nums) | Combine(Word(nums) + '.' + Word(nums))
print(number.searchString("123 3.1416 789")) # Fail! -> [['123'], ['3'], ['1416'], ['789']]
# put more selective expression first
number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums)
print(number.searchString("123 3.1416 789")) # Better -> [['123'], ['3.1416'], ['789']] | 6259908c099cdd3c63676219 |
class StateProcessor(object): <NEW_LINE> <INDENT> def __init__(self,shape=[210, 160, 3],output_shape=[84,84]): <NEW_LINE> <INDENT> self.shape = shape <NEW_LINE> self.output_shape = output_shape[:2] <NEW_LINE> with tf.variable_scope("state_processor"): <NEW_LINE> <INDENT> self.input_state = tf.placeholder(shape=self.shape, dtype=tf.uint8) <NEW_LINE> self.output = tf.image.rgb_to_grayscale(self.input_state) <NEW_LINE> self.output = tf.image.crop_to_bounding_box(self.output, 34, 0, 160, 160) <NEW_LINE> self.output = tf.image.resize_images( self.output, self.output_shape, method=tf.image.ResizeMethod.NEAREST_NEIGHBOR) <NEW_LINE> self.output = tf.squeeze(self.output) <NEW_LINE> <DEDENT> <DEDENT> def process(self, sess, state): <NEW_LINE> <INDENT> return sess.run(self.output, { self.input_state: state }) | Processes a raw Atari iamges. Resizes it and converts it to grayscale.
图片的预处理。 | 6259908cad47b63b2c5a9492 |
class InviteView(APIView): <NEW_LINE> <INDENT> permission_classes = (IsAuthenticated,) <NEW_LINE> def get(self, request): <NEW_LINE> <INDENT> user = request.user <NEW_LINE> current_time = timezone.localtime(timezone.now()) <NEW_LINE> accessible_time = current_time - datetime.timedelta(days=20) <NEW_LINE> no_obj = Notification.objects.filter(to_user=request.user, is_delete=False, created_at__gt=accessible_time).order_by( '-created_at') <NEW_LINE> del_notifactions_count(user.id) <NEW_LINE> return js_resp_paging(no_obj, request, InviteSerializer) | OK
2018/2/28
邀请消息
XXX邀请 你 加入 url
XXX与 你 合唱了 URL
api/ve/notification/invited/ GET type标识消息类型 2：邀请消息，1：加入合唱消息 | 6259908c60cbc95b06365b88 |
@override_settings(ROOT_URLCONF=TestUrlConf) <NEW_LINE> class APITests(TestCase): <NEW_LINE> <INDENT> def setUp(self): <NEW_LINE> <INDENT> self.client = APIClient() <NEW_LINE> <DEDENT> def test_list_misc_types(self): <NEW_LINE> <INDENT> MiscType.objects.create(name='Test Documents') <NEW_LINE> MiscType.objects.create(name='ABC Documents') <NEW_LINE> path = reverse('misctype-list') <NEW_LINE> request = self.client.get(path) <NEW_LINE> self.assertEqual(request.status_code, status.HTTP_200_OK) <NEW_LINE> self.assertEqual(len(request.data), 3) <NEW_LINE> self.assertEqual(request.data[0]['name'], 'ABC Documents') <NEW_LINE> <DEDENT> def test_list_misc_documents(self): <NEW_LINE> <INDENT> MiscDocument.objects.create(title='Public Document', public=True) <NEW_LINE> MiscDocument.objects.create(title='Private Document') <NEW_LINE> path = reverse('misc-documents-list') <NEW_LINE> request_public = self.client.get(path) <NEW_LINE> self.assertEqual(request_public.status_code, status.HTTP_200_OK) <NEW_LINE> self.assertEqual(len(request_public.data['results']), 1) <NEW_LINE> self.assertEqual( request_public.data['results'][0]['title'], 'Public Document') <NEW_LINE> self.client.force_authenticate( User.objects.get_or_create(username='testuser')[0]) <NEW_LINE> request_private = self.client.get(path) <NEW_LINE> self.assertEqual(request_private.status_code, status.HTTP_200_OK) <NEW_LINE> self.assertEqual(len(request_private.data['results']), 2) <NEW_LINE> self.assertEqual( request_private.data['results'][0]['title'], 'Private Document') | Test miscellaneous documents API | 6259908caad79263cf4303f4 |
class SBANd(SCPINode, SCPISet): <NEW_LINE> <INDENT> __slots__ = () <NEW_LINE> _cmd = "SBANd" <NEW_LINE> args = ["AUTO", "LOWer", "UPPer"] | DIGital:MODopt:SBANd
Arguments: AUTO, LOWer, UPPer | 6259908c26068e7796d4e584 |
class CinderIntegrationComponent(object): <NEW_LINE> <INDENT> def getCinderIntegrationKeys(self): <NEW_LINE> <INDENT> methodname = { 'OpenStackInfrastructurePool': 'getPoolIntegrationKeys', 'OpenStackInfrastructureVolume': 'getVolumeIntegrationKeys', 'OpenStackInfrastructureVolSnapshot': 'getSnapshotIntegrationKeys', 'OpenStackInfrastructureBackup': 'getBackupIntegrationKeys' }.get(self.meta_type, None) <NEW_LINE> if not methodname: <NEW_LINE> <INDENT> return [] <NEW_LINE> <DEDENT> keys = [] <NEW_LINE> for plugin_name, plugin in zope.component.getUtilitiesFor(ICinderImplementationPlugin): <NEW_LINE> <INDENT> getKeys = getattr(plugin, methodname) <NEW_LINE> try: <NEW_LINE> <INDENT> for key in getKeys(self): <NEW_LINE> <INDENT> if not key.startswith(plugin_name + ":"): <NEW_LINE> <INDENT> log.error("Key '%s' for plugin %s does not contain the proper prefix, and is being ignored.", key, plugin_name) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> keys.append(key) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> except Exception: <NEW_LINE> <INDENT> log.exception("Exception in %s" % getKeys) <NEW_LINE> raise <NEW_LINE> <DEDENT> <DEDENT> return keys <NEW_LINE> <DEDENT> def implementation_components(self): <NEW_LINE> <INDENT> keys = self.getCinderIntegrationKeys() <NEW_LINE> if not keys: <NEW_LINE> <INDENT> return [] <NEW_LINE> <DEDENT> catalog = get_cinder_implementation_catalog(self.dmd) <NEW_LINE> implementationcomponents = [] <NEW_LINE> for brain in catalog(getCinderIntegrationKeys=keys): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> obj = brain.getObject() <NEW_LINE> <DEDENT> except Exception: <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> implementationcomponents.append(obj) <NEW_LINE> <DEDENT> <DEDENT> return implementationcomponents <NEW_LINE> <DEDENT> def index_object(self, idxs=None): <NEW_LINE> <INDENT> from .OpenstackComponent import OpenstackComponent <NEW_LINE> super(OpenstackComponent, self).index_object(idxs=idxs) <NEW_LINE> catalog = get_cinder_core_catalog(self.dmd) <NEW_LINE> catalog.catalog_object(self, self.getPrimaryId()) <NEW_LINE> <DEDENT> def unindex_object(self): <NEW_LINE> <INDENT> from .OpenstackComponent import OpenstackComponent <NEW_LINE> super(OpenstackComponent, self).unindex_object() <NEW_LINE> catalog = get_cinder_core_catalog(self.dmd) <NEW_LINE> catalog.uncatalog_object(self.getPrimaryId()) <NEW_LINE> <DEDENT> def getDefaultGraphDefs(self, drange=None): <NEW_LINE> <INDENT> from .OpenstackComponent import OpenstackComponent <NEW_LINE> graphs = super(OpenstackComponent, self).getDefaultGraphDefs(drange=drange) <NEW_LINE> for component in self.implementation_components(): <NEW_LINE> <INDENT> for graphdef in component.getDefaultGraphDefs(drange=drange): <NEW_LINE> <INDENT> graphs.append(graphdef) <NEW_LINE> <DEDENT> <DEDENT> return graphs <NEW_LINE> <DEDENT> def getGraphObjects(self, drange=None): <NEW_LINE> <INDENT> from .OpenstackComponent import OpenstackComponent <NEW_LINE> graphs = super(OpenstackComponent, self).getGraphObjects() <NEW_LINE> for component in self.implementation_components(): <NEW_LINE> <INDENT> graphs.extend(component.getGraphObjects()) <NEW_LINE> <DEDENT> return graphs | Mixin for model classes that have Cinder integrations. | 6259908c4a966d76dd5f0b28 |
class DescribeIpSetRequest(JDCloudRequest): <NEW_LINE> <INDENT> def __init__(self, parameters, header=None, version="v1"): <NEW_LINE> <INDENT> super(DescribeIpSetRequest, self).__init__( '/regions/{regionId}/instances/{instanceId}/ipSets/{ipSetId}', 'GET', header, version) <NEW_LINE> self.parameters = parameters | 查询实例的 IP 库 | 6259908ce1aae11d1e7cf636 |
class BugBecameQuestionEvent: <NEW_LINE> <INDENT> implements(IBugBecameQuestionEvent) <NEW_LINE> def __init__(self, bug, question, user): <NEW_LINE> <INDENT> self.bug = bug <NEW_LINE> self.question = question <NEW_LINE> self.user = user | See `IBugBecameQuestionEvent`. | 6259908c5fcc89381b266f7f |
class AesCbcPkcs7Decoder(object): <NEW_LINE> <INDENT> @staticmethod <NEW_LINE> def uint32_bigendian_decode(bb): return tuple((b4[3] | (b4[2] << 8) | (b4[1] << 16) | (b4[0] << 24)) for b4 in iter_blocks(bb, 4, errors="strict")) <NEW_LINE> @staticmethod <NEW_LINE> def uint32_bigendian_encode(u32b): return bytes(b for u32 in u32b for b in ((u32 >> 24) & 0xFF, (u32 >> 16) & 0xFF, (u32 >> 8) & 0xFF, u32 & 0xFF)) <NEW_LINE> def copy(self): return self.__class__(**{k: v for k, v in self.__dict__.items()}) <NEW_LINE> def __init__(self, key, iv, *, cast=bytes, cache=(), last_unciphered=b""): <NEW_LINE> <INDENT> self.key = key <NEW_LINE> self.iv = iv <NEW_LINE> self.cast = cast <NEW_LINE> self.cache = cache <NEW_LINE> self.last_unciphered = last_unciphered <NEW_LINE> <DEDENT> def transcode(self, iterable=None, *, stream=False): <NEW_LINE> <INDENT> if iterable is None: iterable = () <NEW_LINE> aes = Aes(self.key) <NEW_LINE> def it(): <NEW_LINE> <INDENT> iv = self.iv <NEW_LINE> unciphered = self.last_unciphered <NEW_LINE> for block in iter_blocks(iter_chain(self.cache, iterable), 16, errors="truncate" if stream else "strict"): <NEW_LINE> <INDENT> if unciphered: <NEW_LINE> <INDENT> yield from unciphered <NEW_LINE> unciphered = b"" <NEW_LINE> <DEDENT> if len(block) != 16: <NEW_LINE> <INDENT> self.last_unciphered = unciphered <NEW_LINE> self.cache = tuple(block) <NEW_LINE> self.iv = iv <NEW_LINE> return <NEW_LINE> <DEDENT> block = self.uint32_bigendian_decode(block) <NEW_LINE> out = aes.decrypt(block) <NEW_LINE> for i in range(4): out[i] = out[i] ^ iv[i] <NEW_LINE> unciphered = self.uint32_bigendian_encode(out) <NEW_LINE> iv = block <NEW_LINE> <DEDENT> if stream: <NEW_LINE> <INDENT> self.last_unciphered = unciphered <NEW_LINE> self.cache = () <NEW_LINE> self.iv = iv <NEW_LINE> return <NEW_LINE> <DEDENT> n = unciphered[-1] <NEW_LINE> if n > 16 or n == 0: <NEW_LINE> <INDENT> raise ValueError("invalid padding") <NEW_LINE> <DEDENT> for i in range(2, n + 1): <NEW_LINE> <INDENT> if unciphered[-i] != n: <NEW_LINE> <INDENT> raise ValueError("invalid padding") <NEW_LINE> <DEDENT> <DEDENT> if n != 16: <NEW_LINE> <INDENT> yield from unciphered[:-n] <NEW_LINE> <DEDENT> self.last_unciphered = b"" <NEW_LINE> self.cache = () <NEW_LINE> self.iv = iv <NEW_LINE> <DEDENT> return it() if self.cast is None else self.cast(it()) <NEW_LINE> <DEDENT> decode = transcode | AesCbcPkcs7Decoder(key, iv, **opt)
Decodes/decrypts from AES CBC with PKCS#7 padding.
key => [uint32]*4
=> [uint32]*6
=> [uint32]*8
iv => [uint32]*4
opt:
cast => bytes : (default) cast the returned transcoded values to bytes.
=> None : do not cast, returns transcoded byte iterator instead.
cache : internal use only.
last_unciphered: internal use only.
Interfaces:
- copyable (ie. `copy()`)
- transcoder (ie. `transcode(iterable=None, *, stream=False)`) | 6259908c4527f215b58eb7c1 |
class UserConfig(AppConfig): <NEW_LINE> <INDENT> name = 'user' | Class to configure user | 6259908c7cff6e4e811b7686 |
class SQLiteDB(DB): <NEW_LINE> <INDENT> def __init__(self, dbname, echo=False, extensions=None, functions=None, pragmas=None): <NEW_LINE> <INDENT> self._extensions = extensions <NEW_LINE> self._functions = functions <NEW_LINE> self._pragmas = [] if not pragmas else pragmas <NEW_LINE> super(SQLiteDB, self).__init__( dbname=dbname, dbtype="sqlite", echo=echo) <NEW_LINE> <DEDENT> def _on_connect(self, conn, _): <NEW_LINE> <INDENT> conn.isolation_level = None <NEW_LINE> conn.enable_load_extension(True) <NEW_LINE> if isinstance(self._extensions, list): <NEW_LINE> <INDENT> for ext in self._extensions: <NEW_LINE> <INDENT> conn.load_extension(ext) <NEW_LINE> <DEDENT> <DEDENT> for pragma in self._pragmas: <NEW_LINE> <INDENT> conn.execute("PRAGMA {}={};".format(pragma[0], pragma[1])) <NEW_LINE> <DEDENT> if isinstance(self._functions, list): <NEW_LINE> <INDENT> for func in self._functions: <NEW_LINE> <INDENT> utils.make_sqlite_function(conn, func) <NEW_LINE> <DEDENT> <DEDENT> return <NEW_LINE> <DEDENT> @property <NEW_LINE> def databases(self): <NEW_LINE> <INDENT> r = self.con.execute("PRAGMA database_list;") <NEW_LINE> columns = r.keys() <NEW_LINE> df = pd.DataFrame([], columns=columns) <NEW_LINE> for row in r: <NEW_LINE> <INDENT> df = df.append(pd.DataFrame([row], columns=columns)) <NEW_LINE> <DEDENT> return df.reset_index(drop=True) <NEW_LINE> <DEDENT> def attach_db(self, db_path, name=None): <NEW_LINE> <INDENT> db_path = db_path.replace("\\", "/") <NEW_LINE> if not os.path.exists(db_path): <NEW_LINE> <INDENT> raise AttributeError("Database path does not exist") <NEW_LINE> <DEDENT> if name is None: <NEW_LINE> <INDENT> name = os.path.basename(db_path).split(".")[0] <NEW_LINE> <DEDENT> return self.sql("ATTACH :file AS :name;", {"file": db_path, "name": name}) <NEW_LINE> <DEDENT> def detach_db(self, name): <NEW_LINE> <INDENT> return self.sql("DETACH DATABASE :name;", {"name": name}) <NEW_LINE> <DEDENT> def create_index(self, table_name, column_name): <NEW_LINE> <INDENT> s = "CREATE INDEX idx_{{ tbl }}_{{ col }} ON {{ tbl }} ({{ col }});" <NEW_LINE> data = {"tbl": table_name, "col": column_name} <NEW_LINE> return self.sql(s, data) <NEW_LINE> <DEDENT> def create_table_as(self, table_name, sql, **kwargs): <NEW_LINE> <INDENT> df = self.sql(sql) <NEW_LINE> self.load_dataframe(df, table_name, **kwargs) <NEW_LINE> return <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return "SQLite[SQLite] > {dbname}".format(dbname=self.dbname) | Utility for exploring and querying an SQLite database.
Parameters
----------
dbname: str
Path to SQLite database or ":memory:" for in-memory database
echo: bool
Whether or not to repeat queries and messages back to user
extensions: list
List of extensions to load on connection | 6259908c283ffb24f3cf54e4 |
class Label( collections.namedtuple('Label', ['index'])): <NEW_LINE> <INDENT> def __str__(self): <NEW_LINE> <INDENT> return 'L%d' % self.index | A label heading off a basic block. | 6259908c71ff763f4b5e93f1 |
class ClassNotFound(Exception): <NEW_LINE> <INDENT> def __init__(self, type_: str) -> None: <NEW_LINE> <INDENT> self.type_ = type_ <NEW_LINE> <DEDENT> def get_HTTP(self) -> HydraError: <NEW_LINE> <INDENT> description = f"The class {self.type_} is not a valid/defined RDFClass" <NEW_LINE> return HydraError(code=400, title="Invalid class", desc=description) | Error when the RDFClass is not found. | 6259908ca05bb46b3848bf47 |
class UserSearchView(models.Model): <NEW_LINE> <INDENT> profile_id = models.IntegerField(primary_key = True) <NEW_LINE> username = models.CharField(max_length = 30) <NEW_LINE> kennitala = models.CharField(max_length = 11) <NEW_LINE> fullname = models.CharField(max_length = 600) <NEW_LINE> fullname_sans_middlename = models.CharField(max_length = 600) <NEW_LINE> first_name = models.CharField(max_length = 600) <NEW_LINE> middlenames = models.CharField(max_length = 600) <NEW_LINE> last_name = models.CharField(max_length = 600) <NEW_LINE> address = models.CharField(max_length = 255) <NEW_LINE> phone = models.CharField(max_length = 7) <NEW_LINE> gsm = models.CharField(max_length = 7) <NEW_LINE> objects = UserSearchViewManager() <NEW_LINE> def get_profile(self): <NEW_LINE> <INDENT> return ProfileModel.objects.get(id = self.profile_id) <NEW_LINE> <DEDENT> profile = property(get_profile) <NEW_LINE> class Meta: <NEW_LINE> <INDENT> db_table = "phonebook_usersearchview" | Note to self: ForeignKeys to not work when using database views | 6259908c97e22403b383cb3c |
class BaseGMM(ABC): <NEW_LINE> <INDENT> def __init__(self, components, dimensions, epochs=100, w=1e-6, tol=1e-9, restarts=5, device=None): <NEW_LINE> <INDENT> self.k = components <NEW_LINE> self.d = dimensions <NEW_LINE> self.epochs = epochs <NEW_LINE> self.w = w <NEW_LINE> self.tol = tol <NEW_LINE> self.restarts = restarts <NEW_LINE> if not device: <NEW_LINE> <INDENT> self.device = torch.device('cpu') <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.device = device <NEW_LINE> <DEDENT> self.weights = torch.empty(self.k, device=self.device) <NEW_LINE> self.means = torch.empty(self.k, self.d, device=self.device) <NEW_LINE> self.covars = torch.empty(self.k, self.d, self.d, device=self.device) <NEW_LINE> self.chol_covars = torch.empty( self.k, self.d, self.d, device=self.device ) <NEW_LINE> <DEDENT> def _kmeans_init(self, X, max_iters=50, tol=1e-9): <NEW_LINE> <INDENT> return k_means(X, self.k, max_iters, tol, self.device)[0] <NEW_LINE> <DEDENT> def fit(self, data): <NEW_LINE> <INDENT> n_inf = torch.tensor(float('-inf'), device=self.device) <NEW_LINE> best_log_prob = torch.tensor(float('-inf'), device=self.device) <NEW_LINE> for j in range(self.restarts): <NEW_LINE> <INDENT> expectations = self._init_expectations(data) <NEW_LINE> self._m_step(data, expectations) <NEW_LINE> prev_log_prob = torch.tensor(float('-inf'), device=self.device) <NEW_LINE> for i in range(self.epochs): <NEW_LINE> <INDENT> log_prob, expectations = self._e_step(data) <NEW_LINE> if log_prob == n_inf: <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> self._m_step(data, expectations) <NEW_LINE> if torch.abs(log_prob - prev_log_prob) < self.tol: <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> prev_log_prob = log_prob <NEW_LINE> <DEDENT> if log_prob > best_log_prob: <NEW_LINE> <INDENT> best_params = ( self.weights.clone().detach(), self.means.clone().detach(), self.covars.clone().detach(), self.chol_covars.clone().detach() ) <NEW_LINE> best_log_prob = log_prob <NEW_LINE> <DEDENT> <DEDENT> if best_log_prob == n_inf: <NEW_LINE> <INDENT> raise ValueError('Could not fit model. Try increasing w?') <NEW_LINE> <DEDENT> self.weights, self.means, self.covars, self.chol_covars = best_params <NEW_LINE> print(self.weights.device) <NEW_LINE> <DEDENT> def predict(self, X): <NEW_LINE> <INDENT> return torch.exp(self._e_step(X)[1]) <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def _init_expectations(self, data): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def _e_step(self, data): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def _m_step(self, data, expectations): <NEW_LINE> <INDENT> pass | ABC for GMMs fitted with EM-type methods. | 6259908c283ffb24f3cf54e5 |
class EWSingleSourceSP(ABC): <NEW_LINE> <INDENT> def __init__(self, graph, s): <NEW_LINE> <INDENT> self.reset(graph, s) <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def path_to(self, v): <NEW_LINE> <INDENT> if v == self.s: <NEW_LINE> <INDENT> return [v], [None], 0 <NEW_LINE> <DEDENT> if self._edge_to[v] is None: <NEW_LINE> <INDENT> return None, None, float('inf') <NEW_LINE> <DEDENT> pths = [v] <NEW_LINE> edges = [] <NEW_LINE> dist = self._dist[v] <NEW_LINE> while self._edge_to[v] is not None: <NEW_LINE> <INDENT> e = self._edge_to[v] <NEW_LINE> w = e.other(v) <NEW_LINE> assert w != v, "Algorithm error, as self loop should not be in the path." <NEW_LINE> edges.append(e) <NEW_LINE> pths.append(w) <NEW_LINE> v = w <NEW_LINE> <DEDENT> pths = list(reversed(pths)) <NEW_LINE> edges = list(reversed(edges)) <NEW_LINE> return pths, edges, dist <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def dist_to(self, v): <NEW_LINE> <INDENT> return self._dist[v] <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def reset(self, graph, s): <NEW_LINE> <INDENT> pass | Parent class for single source shortest pass on edge weighted graph. | 6259908cbe7bc26dc9252c78 |
class Pseudo(OrderedEnum): <NEW_LINE> <INDENT> SINGLETON = 1 | This is a pseudo feature, that can be used instead of any real feature. | 6259908cadb09d7d5dc0c19f |
class UnableToAcquireCommitLockError(StorageError, UnableToAcquireLockError): <NEW_LINE> <INDENT> pass | The commit lock cannot be acquired due to a timeout.
This means some other transaction had the lock we needed. Retrying
the transaction may succeed.
However, for historical reasons, this exception is not a ``TransientError``. | 6259908c283ffb24f3cf54e6 |
class PasswordResetAPIView(views.APIView): <NEW_LINE> <INDENT> permission_classes = (permissions.AllowAny, ) <NEW_LINE> serializer_class = serializers.PasswordResetSerializer <NEW_LINE> def post(self, request): <NEW_LINE> <INDENT> user_profile = self.get_user_profile(request.data.get('email')) <NEW_LINE> if user_profile: <NEW_LINE> <INDENT> user_profile.send_password_reset_email( site=get_current_site(request) ) <NEW_LINE> return Response(status=status.HTTP_200_OK) <NEW_LINE> <DEDENT> return Response(status=status.HTTP_200_OK) <NEW_LINE> <DEDENT> def get_user_profile(self, email): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> user_profile = UserProfile.objects.get(user__email=email) <NEW_LINE> <DEDENT> except: <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> return user_profile | Endpoint to send email to user with password reset link. | 6259908c099cdd3c6367621c |
class theme(object): <NEW_LINE> <INDENT> _settings = sublime.load_settings('Base File.sublime-settings') <NEW_LINE> _prefix = 'Colorized-' <NEW_LINE> class __metaclass__(type): <NEW_LINE> <INDENT> @property <NEW_LINE> def abspath(cls): <NEW_LINE> <INDENT> theme_path = cls._settings.get('color_scheme') or "" <NEW_LINE> if theme_path.startswith('Packages'): <NEW_LINE> <INDENT> theme_path = join(SUBLIME_PATH, theme_path) <NEW_LINE> <DEDENT> return normpath(theme_path) <NEW_LINE> <DEDENT> @property <NEW_LINE> def relpath(cls): <NEW_LINE> <INDENT> return relpath(cls.abspath, SUBLIME_PATH) <NEW_LINE> <DEDENT> @property <NEW_LINE> def dirname(cls): <NEW_LINE> <INDENT> return dirname(cls.abspath) <NEW_LINE> <DEDENT> @property <NEW_LINE> def name(cls): <NEW_LINE> <INDENT> return basename(cls.abspath) <NEW_LINE> <DEDENT> @property <NEW_LINE> def is_colorized(cls): <NEW_LINE> <INDENT> if cls.name.startswith(cls._prefix): <NEW_LINE> <INDENT> return True <NEW_LINE> <DEDENT> <DEDENT> def set(cls, theme): <NEW_LINE> <INDENT> cls._settings.set('color_scheme', theme) <NEW_LINE> <DEDENT> @property <NEW_LINE> def colorized_path(cls): <NEW_LINE> <INDENT> return join(cls.dirname, cls.colorized_name) <NEW_LINE> <DEDENT> @property <NEW_LINE> def uncolorized_path(cls): <NEW_LINE> <INDENT> return join(cls.dirname, cls.uncolorized_name) <NEW_LINE> <DEDENT> @property <NEW_LINE> def uncolorized_name(cls): <NEW_LINE> <INDENT> if cls.is_colorized: <NEW_LINE> <INDENT> s = re.search(cls._prefix + "(\d+-)?(?P<Name>.*)", cls.name) <NEW_LINE> theme_name = s.group('Name') <NEW_LINE> return theme_name <NEW_LINE> <DEDENT> return cls.name <NEW_LINE> <DEDENT> @property <NEW_LINE> def colorized_name(cls): <NEW_LINE> <INDENT> r = str(randint(1, 10 ** 15)) + '-' <NEW_LINE> return cls._prefix + r + cls.uncolorized_name <NEW_LINE> <DEDENT> def on_select_new_theme(cls, callback): <NEW_LINE> <INDENT> cls._settings.add_on_change('color_scheme', callback) | Global object represents ST color scheme | 6259908cdc8b845886d551ff |
class DownloadBill(WeixinBase): <NEW_LINE> <INDENT> api_url = "https://api.mch.weixin.qq.com/pay/downloadbill" <NEW_LINE> using_cert = False <NEW_LINE> is_xml = True <NEW_LINE> error_code = {"return_code": "FAIL"} <NEW_LINE> def __init__(self, bill_date_str, bill_type=None, **kwargs): <NEW_LINE> <INDENT> super(DownloadBill, self).__init__() <NEW_LINE> if bill_type not in ["SUCCESS", "REFUND", "REVOKED", "ALL"]: <NEW_LINE> <INDENT> raise AttributeError(u"not supported bill_type") <NEW_LINE> <DEDENT> self.bill_type = bill_type or "ALL" <NEW_LINE> self.post_data = { "appid": wx_conf.app_id, "mch_id": wx_conf.mch_id, "nonce_str": com.create_nonce_str(), "bill_date": bill_date_str, "bill_type": self.bill_type } <NEW_LINE> self.post_data = self.load_kwargs(self.post_data, ["device_info"], kwargs) <NEW_LINE> self.post_data["sign"] = create_sign(self.post_data, key=wx_conf.key) | 对账单接口 | 6259908c5fdd1c0f98e5fbbe |
class Character: <NEW_LINE> <INDENT> CharacterList = {None:None} <NEW_LINE> SNList = {None:None} <NEW_LINE> def __init__(self, name, SN, HP, SP, MP, baseAtk, baseDef, atkMulti, defMulti): <NEW_LINE> <INDENT> self.CharacterList.update({SN:self}) <NEW_LINE> self.SNList.update({name:SN}) <NEW_LINE> HP = int(HP) <NEW_LINE> SP = float(SP) <NEW_LINE> MP = int(MP) <NEW_LINE> baseAtk = int(baseAtk) <NEW_LINE> baseDef = int(baseDef) <NEW_LINE> self.name = name <NEW_LINE> self.health = HealthSystemClass(HP) <NEW_LINE> self.spirit = SpiritSystemClass(MP) <NEW_LINE> self.strength = StrengthSystemClass(SP) <NEW_LINE> self.storage = StorageSystemClass() <NEW_LINE> self.baseAttack = baseAtk <NEW_LINE> self.baseDefense = baseDef <NEW_LINE> self.attackMulti = atkMulti <NEW_LINE> self.defenseMulti = defMulti <NEW_LINE> self.alive = True <NEW_LINE> self.defending = False <NEW_LINE> <DEDENT> def getBaseAttack(self): <NEW_LINE> <INDENT> return self.baseAttack <NEW_LINE> <DEDENT> def getBaseDefense(self): <NEW_LINE> <INDENT> return self.baseDefense <NEW_LINE> <DEDENT> def getAttackMulti(self): <NEW_LINE> <INDENT> return self.attackMulti <NEW_LINE> <DEDENT> def getDefenseMulti(self): <NEW_LINE> <INDENT> return self.defenseMulti <NEW_LINE> <DEDENT> def isDefending(self): <NEW_LINE> <INDENT> return self.defending <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return self.name <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def retrieveCharacter(cls, SN): <NEW_LINE> <INDENT> return cls.CharacterList[SN] | The meta class for character managing | 6259908ce1aae11d1e7cf638 |
class Writer(with_metaclass(ABCMeta)): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def display_message(self, message, headline=None, hyphenate=True): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def prompt_user_yesno(self, *args, **kwargs): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def prompt_user_yesnocancel(self, *args, **kwargs): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def prompt_user_input(self, message="", validator=None, default=None): <NEW_LINE> <INDENT> pass <NEW_LINE> <DEDENT> @abstractmethod <NEW_LINE> def prompt_to_choose(self, message, values=None, allow_userinput=False): <NEW_LINE> <INDENT> pass | Writer connects the hardening scripts with user input: The user can be prompted for input,
which is than returned to the program. The output may be simply text-based (console) or
even web-based. | 6259908c4c3428357761bf02 |
@python_2_unicode_compatible <NEW_LINE> class Valuation(dict): <NEW_LINE> <INDENT> def __init__(self, xs): <NEW_LINE> <INDENT> super(Valuation, self).__init__() <NEW_LINE> for (sym, val) in xs: <NEW_LINE> <INDENT> if isinstance(val, string_types) or isinstance(val, bool): <NEW_LINE> <INDENT> self[sym] = val <NEW_LINE> <DEDENT> elif isinstance(val, set): <NEW_LINE> <INDENT> self[sym] = set2rel(val) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> msg = textwrap.fill("Error in initializing Valuation. " "Unrecognized value for symbol '%s':\n%s" % (sym, val), width=66) <NEW_LINE> raise ValueError(msg) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def __getitem__(self, key): <NEW_LINE> <INDENT> if key in self: <NEW_LINE> <INDENT> return dict.__getitem__(self, key) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise Undefined("Unknown expression: '%s'" % key) <NEW_LINE> <DEDENT> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return pformat(self) <NEW_LINE> <DEDENT> @property <NEW_LINE> def domain(self): <NEW_LINE> <INDENT> dom = [] <NEW_LINE> for val in self.values(): <NEW_LINE> <INDENT> if isinstance(val, string_types): <NEW_LINE> <INDENT> dom.append(val) <NEW_LINE> <DEDENT> elif not isinstance(val, bool): <NEW_LINE> <INDENT> dom.extend([elem for tuple_ in val for elem in tuple_ if elem is not None]) <NEW_LINE> <DEDENT> <DEDENT> return set(dom) <NEW_LINE> <DEDENT> @property <NEW_LINE> def symbols(self): <NEW_LINE> <INDENT> return sorted(self.keys()) | A dictionary which represents a model-theoretic Valuation of non-logical constants.
Keys are strings representing the constants to be interpreted, and values correspond
to individuals (represented as strings) and n-ary relations (represented as sets of tuples
of strings).
An instance of ``Valuation`` will raise a KeyError exception (i.e.,
just behave like a standard dictionary) if indexed with an expression that
is not in its list of symbols. | 6259908c283ffb24f3cf54e8 |
class Distribution(with_metaclass(abc.ABCMeta)): <NEW_LINE> <INDENT> @abc.abstractmethod <NEW_LINE> def sample(self, means, covs, stddevs, idxs): <NEW_LINE> <INDENT> raise NotImplementedError <NEW_LINE> <DEDENT> @abc.abstractmethod <NEW_LINE> def survival(self, loss_ratio, mean, stddev): <NEW_LINE> <INDENT> raise NotImplementedError | A Distribution class models continuous probability distribution of
random variables used to sample losses of a set of assets. It is
usually registered with a name (e.g. LN, BT, PM) by using
:class:`openquake.baselib.general.CallableDict` | 6259908c71ff763f4b5e93f5 |
class DatabaseDispatcher(dispatcher.Base): <NEW_LINE> <INDENT> def __init__(self, conf): <NEW_LINE> <INDENT> super(DatabaseDispatcher, self).__init__(conf) <NEW_LINE> self.storage_conn = storage.get_connection(conf) <NEW_LINE> <DEDENT> def record_metering_data(self, data): <NEW_LINE> <INDENT> if not isinstance(data, list): <NEW_LINE> <INDENT> data = [data] <NEW_LINE> <DEDENT> for meter in data: <NEW_LINE> <INDENT> LOG.debug(_( 'metering data %(counter_name)s ' 'for %(resource_id)s @ %(timestamp)s: %(counter_volume)s') % ({'counter_name': meter['counter_name'], 'resource_id': meter['resource_id'], 'timestamp': meter.get('timestamp', 'NO TIMESTAMP'), 'counter_volume': meter['counter_volume']})) <NEW_LINE> if publisher_rpc.verify_signature( meter, self.conf.publisher_rpc.metering_secret): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> if meter.get('timestamp'): <NEW_LINE> <INDENT> ts = timeutils.parse_isotime(meter['timestamp']) <NEW_LINE> meter['timestamp'] = timeutils.normalize_time(ts) <NEW_LINE> <DEDENT> self.storage_conn.record_metering_data(meter) <NEW_LINE> <DEDENT> except Exception as err: <NEW_LINE> <INDENT> LOG.exception(_('Failed to record metering data: %s'), err) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> LOG.warning(_( 'message signature invalid, discarding message: %r'), meter) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def record_events(self, events): <NEW_LINE> <INDENT> if not isinstance(events, list): <NEW_LINE> <INDENT> events = [events] <NEW_LINE> <DEDENT> return self.storage_conn.record_events(events) | Dispatcher class for recording metering data into database.
The dispatcher class which records each meter into a database configured
in ceilometer configuration file.
To enable this dispatcher, the following section needs to be present in
ceilometer.conf file
dispatchers = database | 6259908c5fdd1c0f98e5fbc0 |
class TensorProducts(TensorProductsCategory): <NEW_LINE> <INDENT> @cached_method <NEW_LINE> def extra_super_categories(self): <NEW_LINE> <INDENT> return [self.base_category()] <NEW_LINE> <DEDENT> class ParentMethods: <NEW_LINE> <INDENT> @cached_method <NEW_LINE> def cell_poset(self): <NEW_LINE> <INDENT> ret = self._sets[0].cell_poset() <NEW_LINE> for A in self._sets[1:]: <NEW_LINE> <INDENT> ret = ret.product(A.cell_poset()) <NEW_LINE> <DEDENT> return ret <NEW_LINE> <DEDENT> def cell_module_indices(self, mu): <NEW_LINE> <INDENT> from sage.categories.cartesian_product import cartesian_product <NEW_LINE> return cartesian_product([self._sets[i].cell_module_indices(x) for i,x in enumerate(mu)]) <NEW_LINE> <DEDENT> @lazy_attribute <NEW_LINE> def cellular_involution(self): <NEW_LINE> <INDENT> if self.cellular_basis() is self: <NEW_LINE> <INDENT> M = x.monomial_coefficients(copy=False) <NEW_LINE> return self._from_dict({(i[0], i[2], i[1]): M[i] for i in M}, remove_zeros=False) <NEW_LINE> <DEDENT> on_basis = lambda i: self._tensor_of_elements([ A.basis()[i[j]].cellular_involution() for j,A in enumerate(self._sets)]) <NEW_LINE> return self.module_morphism(on_basis, codomain=self) <NEW_LINE> <DEDENT> @cached_method <NEW_LINE> def _to_cellular_element(self, i): <NEW_LINE> <INDENT> C = [A.cellular_basis() for A in self._sets] <NEW_LINE> elts = [C[j](self._sets[j].basis()[ij]) for j,ij in enumerate(i)] <NEW_LINE> from sage.categories.tensor import tensor <NEW_LINE> T = tensor(C) <NEW_LINE> temp = T._tensor_of_elements(elts) <NEW_LINE> B = self.cellular_basis() <NEW_LINE> M = temp.monomial_coefficients(copy=False) <NEW_LINE> def convert_index(i): <NEW_LINE> <INDENT> mu = [] <NEW_LINE> s = [] <NEW_LINE> t = [] <NEW_LINE> for a,b,c in i: <NEW_LINE> <INDENT> mu.append(a) <NEW_LINE> s.append(b) <NEW_LINE> t.append(c) <NEW_LINE> <DEDENT> C = self.cell_module_indices(mu) <NEW_LINE> return (tuple(mu), C(s), C(t)) <NEW_LINE> <DEDENT> return B._from_dict({convert_index(i): M[i] for i in M}, remove_zeros=False) <NEW_LINE> <DEDENT> @cached_method <NEW_LINE> def _from_cellular_index(self, x): <NEW_LINE> <INDENT> elts = [A(A.cellular_basis().basis()[ (x[0][i], x[1][i], x[2][i]) ]) for i,A in enumerate(self._sets)] <NEW_LINE> return self._tensor_of_elements(elts) | The category of cellular algebras constructed by tensor
product of cellular algebras. | 6259908c60cbc95b06365b8c |
class UnversionedStatusDetails(object): <NEW_LINE> <INDENT> def __init__(self, causes=None, kind=None, retry_after_seconds=None, name=None, group=None): <NEW_LINE> <INDENT> self.swagger_types = { 'causes': 'list[UnversionedStatusCause]', 'kind': 'str', 'retry_after_seconds': 'int', 'name': 'str', 'group': 'str' } <NEW_LINE> self.attribute_map = { 'causes': 'causes', 'kind': 'kind', 'retry_after_seconds': 'retryAfterSeconds', 'name': 'name', 'group': 'group' } <NEW_LINE> self._causes = causes <NEW_LINE> self._kind = kind <NEW_LINE> self._retry_after_seconds = retry_after_seconds <NEW_LINE> self._name = name <NEW_LINE> self._group = group <NEW_LINE> <DEDENT> @property <NEW_LINE> def causes(self): <NEW_LINE> <INDENT> return self._causes <NEW_LINE> <DEDENT> @causes.setter <NEW_LINE> def causes(self, causes): <NEW_LINE> <INDENT> self._causes = causes <NEW_LINE> <DEDENT> @property <NEW_LINE> def kind(self): <NEW_LINE> <INDENT> return self._kind <NEW_LINE> <DEDENT> @kind.setter <NEW_LINE> def kind(self, kind): <NEW_LINE> <INDENT> self._kind = kind <NEW_LINE> <DEDENT> @property <NEW_LINE> def retry_after_seconds(self): <NEW_LINE> <INDENT> return self._retry_after_seconds <NEW_LINE> <DEDENT> @retry_after_seconds.setter <NEW_LINE> def retry_after_seconds(self, retry_after_seconds): <NEW_LINE> <INDENT> self._retry_after_seconds = retry_after_seconds <NEW_LINE> <DEDENT> @property <NEW_LINE> def name(self): <NEW_LINE> <INDENT> return self._name <NEW_LINE> <DEDENT> @name.setter <NEW_LINE> def name(self, name): <NEW_LINE> <INDENT> self._name = name <NEW_LINE> <DEDENT> @property <NEW_LINE> def group(self): <NEW_LINE> <INDENT> return self._group <NEW_LINE> <DEDENT> @group.setter <NEW_LINE> def group(self, group): <NEW_LINE> <INDENT> self._group = group <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> 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. | 6259908c8a349b6b43687ea9 |
class Code: <NEW_LINE> <INDENT> def __init__(self, code): <NEW_LINE> <INDENT> if type(code) == type([]): <NEW_LINE> <INDENT> self.code = '\n'.join(code) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.code = code <NEW_LINE> <DEDENT> self.includes = [] <NEW_LINE> self.variables = [] <NEW_LINE> <DEDENT> def prependCode(self, code): <NEW_LINE> <INDENT> if type(code) == type([]): <NEW_LINE> <INDENT> self.code = '\n'.join(code) + self.code <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.code = code + self.code <NEW_LINE> <DEDENT> <DEDENT> def appendCode(self, code): <NEW_LINE> <INDENT> if type(code) == type([]): <NEW_LINE> <INDENT> self.code += '\n'.join(code) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> self.code += code <NEW_LINE> <DEDENT> <DEDENT> def addInclude(self, include): <NEW_LINE> <INDENT> if type(include) == type(''): <NEW_LINE> <INDENT> if not include in self.includes: <NEW_LINE> <INDENT> self.includes.append(include) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> for i in include: <NEW_LINE> <INDENT> if not i in self.includes: <NEW_LINE> <INDENT> self.includes.append(i) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> <DEDENT> def addVariable(self, variable): <NEW_LINE> <INDENT> if not variable in self.variables: <NEW_LINE> <INDENT> self.variables.append(variable) <NEW_LINE> <DEDENT> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> codeStr = '' <NEW_LINE> if self.variables: <NEW_LINE> <INDENT> codeStr += '{\n' <NEW_LINE> for i in self.variables: <NEW_LINE> <INDENT> codeStr += str(i) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> if self.code: <NEW_LINE> <INDENT> codeStr += '\n' <NEW_LINE> <DEDENT> <DEDENT> codeStr += self.code.rstrip() + '\n' <NEW_LINE> if self.variables: <NEW_LINE> <INDENT> codeStr += '}\n' <NEW_LINE> <DEDENT> return codeStr <NEW_LINE> <DEDENT> def writeDeclaration(self, writer): <NEW_LINE> <INDENT> if self.variables: <NEW_LINE> <INDENT> writer.write('{\n') <NEW_LINE> for i in self.variables: <NEW_LINE> <INDENT> i.writeImplementation(writer) <NEW_LINE> <DEDENT> <DEDENT> else: <NEW_LINE> <INDENT> if self.code: <NEW_LINE> <INDENT> self.code += '\n' <NEW_LINE> <DEDENT> <DEDENT> writer.write(self.code.rstrip() + '\n') <NEW_LINE> if self.variables: <NEW_LINE> <INDENT> writer.write('}\n') <NEW_LINE> <DEDENT> <DEDENT> def writeImplementation(self, writer): <NEW_LINE> <INDENT> self.writeDeclaration(writer) <NEW_LINE> <DEDENT> def getIncludes(self): <NEW_LINE> <INDENT> import copy <NEW_LINE> VarIncludes = copy.copy(self.includes) <NEW_LINE> for i in self.variables: <NEW_LINE> <INDENT> for j in i.getIncludes(): <NEW_LINE> <INDENT> if not j in VarIncludes: <NEW_LINE> <INDENT> VarIncludes.append(j) <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> return VarIncludes | Custom code element. it allows to add custom code in any place.
This class is for example used to specify the behavior of a class method or
of a function | 6259908c7cff6e4e811b768c |
class UserNote(models.Model): <NEW_LINE> <INDENT> timestamp = models.DateTimeField(auto_now_add=True) <NEW_LINE> admin_user = models.ForeignKey("user.User", related_name="admin_notes", on_delete=models.CASCADE, null=True) <NEW_LINE> user = models.ForeignKey("user.User", related_name="notes", on_delete=models.CASCADE) <NEW_LINE> note = models.TextField() <NEW_LINE> def __str__(self): <NEW_LINE> <INDENT> timestamp = self.timestamp.strftime("%Y-%m-%d %H:%M:%S") <NEW_LINE> return f"{timestamp} - {self.admin_user}" | An internal model to track internal admin information, such as the reason
for disabling a user's account. | 6259908c091ae3566870688f |
class Monster(object): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> super(Base, self).__init__() | Holds all of the monsters within the RPG game. | 6259908cec188e330fdfa4f9 |
class tbxunit(lisa.LISAunit): <NEW_LINE> <INDENT> rootNode = "termEntry" <NEW_LINE> languageNode = "langSet" <NEW_LINE> textNode = "term" <NEW_LINE> def createlanguageNode(self, lang, text, purpose): <NEW_LINE> <INDENT> if isinstance(text, bytes): <NEW_LINE> <INDENT> text = text.decode("utf-8") <NEW_LINE> <DEDENT> langset = etree.Element(self.languageNode) <NEW_LINE> setXMLlang(langset, lang) <NEW_LINE> tig = etree.SubElement(langset, "tig") <NEW_LINE> term = etree.SubElement(tig, self.textNode) <NEW_LINE> term.text = text <NEW_LINE> return langset <NEW_LINE> <DEDENT> def getid(self): <NEW_LINE> <INDENT> return self.xmlelement.get("id") or self.source | A single term in the TBX file.
Provisional work is done to make several languages possible. | 6259908c4c3428357761bf06 |
class MultiPointArrayType(ArrayAttributeType): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> super().__init__(MultiPointType()) | Conversion class for MultiPoint[]. | 6259908c5fdd1c0f98e5fbc2 |
class ProductAdmin(admin.ModelAdmin): <NEW_LINE> <INDENT> form = CategoryAdminForm <NEW_LINE> fieldsets = ( (_('Content'), { 'fields': (('title', 'status'), 'slug', 'excerpt', 'content', 'categories')}), (_('Illustration'), { 'fields': ('image', 'get_thumbnail', 'image_caption'), 'classes': ('collapse', 'collapse-closed')}), (_('Publication'), { 'fields': ('start_publication', 'end_publication'), 'classes': ('collapse', 'collapse-closed')}), (None, {'fields': ('creation_date', 'last_update', 'owner')}) ) <NEW_LINE> readonly_fields = ['slug', 'get_thumbnail', 'creation_date', 'last_update'] <NEW_LINE> list_filter = ('status',) <NEW_LINE> list_display = ('title', 'get_categories', 'get_is_visible', 'get_thumbnail') <NEW_LINE> actions_on_top = True <NEW_LINE> def __init__(self, model, admin_site): <NEW_LINE> <INDENT> self.form.admin_site = admin_site <NEW_LINE> super(ProductAdmin, self).__init__(model, admin_site) <NEW_LINE> <DEDENT> def save_related(self, request, form, formsets, change): <NEW_LINE> <INDENT> super(ProductAdmin, self).save_related(request, form, formsets, change) <NEW_LINE> for category in form.instance.categories.all(): <NEW_LINE> <INDENT> parent = category.parent <NEW_LINE> while parent is not None: <NEW_LINE> <INDENT> form.instance.categories.add(parent) <NEW_LINE> parent = parent.parent <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def get_categories(self, product): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> return format_html_join( ', ', u'<a href="{}" target="blank">{}</a>', [(category.get_absolute_url(), category.title) for category in product.categories.all()]) <NEW_LINE> <DEDENT> except NoReverseMatch: <NEW_LINE> <INDENT> return ', '.join([conditional_escape(category.title) for category in product.categories.all()]) <NEW_LINE> <DEDENT> <DEDENT> get_categories.short_description = _('category(s)') <NEW_LINE> def get_is_visible(self, product): <NEW_LINE> <INDENT> return product.is_visible <NEW_LINE> <DEDENT> get_is_visible.boolean = True <NEW_LINE> get_is_visible.short_description = _('is visible') <NEW_LINE> def get_thumbnail(self, product): <NEW_LINE> <INDENT> if product.image: <NEW_LINE> <INDENT> return format_html('<a href="%s" target="_blank"><img src="%s" width=80/></a>' % (product.image.url, product.image.url)) <NEW_LINE> <DEDENT> return None <NEW_LINE> <DEDENT> get_thumbnail.short_description = _('thumbnail') | Admin for Product model. | 6259908cadb09d7d5dc0c1a5 |
class _Base (object): <NEW_LINE> <INDENT> Type = None <NEW_LINE> Name = None <NEW_LINE> Default = None <NEW_LINE> value = property() <NEW_LINE> length = property() <NEW_LINE> packed = property() <NEW_LINE> @classmethod <NEW_LINE> def unpack (cls, packed): <NEW_LINE> <INDENT> return cls(packed) <NEW_LINE> <DEDENT> def __init__ (self, value=None): <NEW_LINE> <INDENT> if value is None: <NEW_LINE> <INDENT> value = self.Default <NEW_LINE> <DEDENT> self._setValue(value) <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def is_critical (cls): <NEW_LINE> <INDENT> return cls.Type & 0x01 <NEW_LINE> <DEDENT> def is_default (self): <NEW_LINE> <INDENT> return self.Default == self.value <NEW_LINE> <DEDENT> def __str__ (self): <NEW_LINE> <INDENT> return '%s: %s' % (self.Name, self.value) | Base class for all CoAPy option classes.
| 6259908c167d2b6e312b83be |
class SoftwareTrigger(ivi.IviContainer): <NEW_LINE> <INDENT> def __init__(self, *args, **kwargs): <NEW_LINE> <INDENT> super(SoftwareTrigger, self).__init__(*args, **kwargs) <NEW_LINE> cls = 'IviPwrMeter' <NEW_LINE> grp = 'SoftwareTrigger' <NEW_LINE> ivi.add_group_capability(self, cls+grp) <NEW_LINE> <DEDENT> def send_software_trigger(self): <NEW_LINE> <INDENT> pass | Extension IVI methods for RF power meters supporting software triggering | 6259908c656771135c48ae57 |
class InitialTimeSignatureFeature(featuresModule.FeatureExtractor): <NEW_LINE> <INDENT> id = 'R31' <NEW_LINE> def __init__(self, dataOrStream=None, *arguments, **keywords): <NEW_LINE> <INDENT> featuresModule.FeatureExtractor.__init__(self, dataOrStream=dataOrStream, *arguments, **keywords) <NEW_LINE> self.name = 'Initial Time Signature' <NEW_LINE> self.description = ('A feature array with two elements. ' + 'The first is the numerator of the first occurring time signature ' + 'and the second is the denominator of the first occurring time ' + 'signature. Both are set to 0 if no time signature is present.') <NEW_LINE> self.isSequential = True <NEW_LINE> self.dimensions = 2 <NEW_LINE> <DEDENT> def _process(self): <NEW_LINE> <INDENT> elements = self.data['flat.getElementsByClass.TimeSignature'] <NEW_LINE> if len(elements) < 1: <NEW_LINE> <INDENT> return <NEW_LINE> <DEDENT> ts = elements[0] <NEW_LINE> environLocal.printDebug(['found ts', ts]) <NEW_LINE> self._feature.vector[0] = elements[0].numerator <NEW_LINE> self._feature.vector[1] = elements[0].denominator | A feature array with two elements. The first is the numerator of the first occurring
time signature and the second is the denominator of the first occurring time signature.
Both are set to 0 if no time signature is present.
>>> s1 = stream.Stream()
>>> s1.append(meter.TimeSignature('3/4'))
>>> fe = features.jSymbolic.InitialTimeSignatureFeature(s1)
>>> fe.extract().vector
[3, 4] | 6259908c3617ad0b5ee07d9e |
class ContrastiveLoss(nn.Module): <NEW_LINE> <INDENT> def __init__(self, margin=2.0, pos_weight=0.5): <NEW_LINE> <INDENT> super(ContrastiveLoss, self).__init__() <NEW_LINE> self.pos_weight = pos_weight <NEW_LINE> self.margin = margin <NEW_LINE> <DEDENT> def forward(self, distance, label): <NEW_LINE> <INDENT> contrastive_loss = torch.mean((1 - self.pos_weight) * label * torch.pow(distance, 2) + self.pos_weight * (1 - label) * torch.pow(torch.clamp(self.margin - distance, min=0.0), 2)) <NEW_LINE> return contrastive_loss | Contrastive loss function.
Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
Loss is proportional to square distance when inputs are of the same type, and proportional to
the square of margin - distance when the classes are different. Margin is a user-specifiable
hyperparameter. | 6259908cad47b63b2c5a949e |
class lexicalConceptualResourceImageInfoType_model(SchemaModel): <NEW_LINE> <INDENT> class Meta: <NEW_LINE> <INDENT> verbose_name = "Lexical conceptual resource image" <NEW_LINE> <DEDENT> __schema_name__ = 'lexicalConceptualResourceImageInfoType' <NEW_LINE> __schema_fields__ = ( ( u'mediaType', u'mediaType', REQUIRED ), ( u'modalityInfo', u'modalityinfotype_model_set', RECOMMENDED ), ( u'lingualityInfo', u'lingualityInfo', OPTIONAL ), ( u'languageInfo', u'languageinfotype_model_set', OPTIONAL ), ( u'sizeInfo', u'sizeinfotype_model_set', RECOMMENDED ), ( u'imageContentInfo', u'imageContentInfo', RECOMMENDED ), ( u'imageFormatInfo', u'imageformatinfotype_model_set', RECOMMENDED ), ( u'domainInfo', u'domaininfotype_model_set', OPTIONAL ), ( u'geographicCoverageInfo', u'geographiccoverageinfotype_model_set', OPTIONAL ), ( u'timeCoverageInfo', u'timecoverageinfotype_model_set', OPTIONAL ), ) <NEW_LINE> __schema_classes__ = { u'domainInfo': "domainInfoType_model", u'geographicCoverageInfo': "geographicCoverageInfoType_model", u'imageContentInfo': "imageContentInfoType_model", u'imageFormatInfo': "imageFormatInfoType_model", u'languageInfo': "languageInfoType_model", u'lingualityInfo': "lingualityInfoType_model", u'modalityInfo': "modalityInfoType_model", u'sizeInfo': "sizeInfoType_model", u'timeCoverageInfo': "timeCoverageInfoType_model", } <NEW_LINE> mediaType = XmlCharField( verbose_name='Media', help_text='Specifies the media type of the resource and basically ' 'corresponds to the physical medium of the content representation.' ' Each media type is described through a distinctive set of featur' 'es. A resource may consist of parts attributed to different types' ' of media. A tool/service may take as input/output more than one ' 'different media types.', default="image", editable=False, max_length=1000, ) <NEW_LINE> lingualityInfo = models.OneToOneField("lingualityInfoType_model", verbose_name='Linguality', help_text='Groups information on the number of languages of the re' 'source part and of the way they are combined to each other', blank=True, null=True, on_delete=models.SET_NULL, ) <NEW_LINE> imageContentInfo = models.OneToOneField("imageContentInfoType_model", verbose_name='Image content', help_text='Groups together information on the contents of the imag' 'e part of a resource', blank=True, null=True, on_delete=models.SET_NULL, ) <NEW_LINE> def __unicode__(self): <NEW_LINE> <INDENT> _unicode = u'<{} id="{}">'.format(self.__schema_name__, self.id) <NEW_LINE> return _unicode | Groups information on the image part of the lexical/conceptual
resource | 6259908caad79263cf430400 |
class SatTable(Table): <NEW_LINE> <INDENT> no_rows_message = ( ".//td/span[contains(@data-block, 'no-rows-message') or " "contains(@data-block, 'no-search-results-message')]" ) <NEW_LINE> tbody_row = Text('./tbody/tr') <NEW_LINE> pagination = SatTablePagination() <NEW_LINE> @property <NEW_LINE> def has_rows(self): <NEW_LINE> <INDENT> try: <NEW_LINE> <INDENT> no_rows = self.browser.element(self.no_rows_message) <NEW_LINE> <DEDENT> except NoSuchElementException: <NEW_LINE> <INDENT> no_rows = False <NEW_LINE> <DEDENT> if no_rows or not self.tbody_row.is_displayed: <NEW_LINE> <INDENT> return False <NEW_LINE> <DEDENT> return True <NEW_LINE> <DEDENT> def read(self): <NEW_LINE> <INDENT> if not self.has_rows: <NEW_LINE> <INDENT> self.logger.debug(f'Table {self.locator} is empty') <NEW_LINE> return [] <NEW_LINE> <DEDENT> if self.pagination.is_displayed: <NEW_LINE> <INDENT> return self._read_all() <NEW_LINE> <DEDENT> return super().read() <NEW_LINE> <DEDENT> def _read_all(self): <NEW_LINE> <INDENT> table_rows = [] <NEW_LINE> page_number = 1 <NEW_LINE> if self.pagination.current_page != page_number: <NEW_LINE> <INDENT> self.pagination.first_page() <NEW_LINE> wait_for( lambda: self.pagination.current_page == page_number, timeout=30, delay=1, logger=self.logger, ) <NEW_LINE> <DEDENT> while page_number <= self.pagination.total_pages: <NEW_LINE> <INDENT> page_table_rows = super().read() <NEW_LINE> table_rows.extend(page_table_rows) <NEW_LINE> if page_number == self.pagination.total_pages: <NEW_LINE> <INDENT> break <NEW_LINE> <DEDENT> self.pagination.next_page() <NEW_LINE> page_number += 1 <NEW_LINE> wait_for( lambda: self.pagination.current_page == page_number, timeout=30, delay=1, logger=self.logger, ) <NEW_LINE> <DEDENT> return table_rows | Satellite version of table.
Includes a paginator sub-widget. If found, then the paginator is used to read all entries from
the table.
If the table is empty, there might be only one column with an appropriate message in the table
body, or it may have no columns or rows at all. This subclass handles both possibilities.
Example html representation::
<table bst-table="table" ...>
<thead>
<tr class="ng-scope">
<th class="row-select"><input type="checkbox" ...></th>
<th ng-click="table.sortBy(column)" ...>
<span ...><span ...>Column Name</span></span><i ...></i></th>
<th ng-click="table.sortBy(column)" ...>
<span ...><span ...>Column Name</span></span><i ...></i></th>
</tr>
</thead>
<tbody>
<tr id="noRowsTr"><td colspan="9">
<span data-block="no-rows-message" ...>
<span class="ng-scope">Table is empty</span></span>
</td></tr>
</tbody>
</table>
Locator example::
.//table | 6259908c099cdd3c63676220 |
class _NothingCLIInputs(NamedTuple): <NEW_LINE> <INDENT> title: str <NEW_LINE> description: str = "" <NEW_LINE> filename: str = "" <NEW_LINE> destination: str = "" <NEW_LINE> edit: str = "" | The prompts a user can respond to for `not new` in order | 6259908cdc8b845886d55207 |
class KeyValueAction(argparse.Action): <NEW_LINE> <INDENT> def __call__(self, parser, namespace, values, option_string=None): <NEW_LINE> <INDENT> values = [value.split('=') for value in values] <NEW_LINE> if not all(len(val) == 2 for val in values): <NEW_LINE> <INDENT> parser.error(("values for " + self.dest + " must be in key=value format\n")) <NEW_LINE> <DEDENT> setattr(namespace, self.dest, {val[0]: val[1] for val in values}) | Action which splits key=value arguments into a dict. | 6259908c99fddb7c1ca63c04 |
class RecursionDetected(RuntimeError): <NEW_LINE> <INDENT> pass | function has been detected to be recursing | 6259908caad79263cf430401 |
class DeleteCallBackRequest(AbstractModel): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> self.BizAppId = None <NEW_LINE> self.CallId = None <NEW_LINE> self.CancelFlag = None <NEW_LINE> <DEDENT> def _deserialize(self, params): <NEW_LINE> <INDENT> self.BizAppId = params.get("BizAppId") <NEW_LINE> self.CallId = params.get("CallId") <NEW_LINE> self.CancelFlag = params.get("CancelFlag") <NEW_LINE> memeber_set = set(params.keys()) <NEW_LINE> for name, value in vars(self).items(): <NEW_LINE> <INDENT> if name in memeber_set: <NEW_LINE> <INDENT> memeber_set.remove(name) <NEW_LINE> <DEDENT> <DEDENT> if len(memeber_set) > 0: <NEW_LINE> <INDENT> warnings.warn("%s fileds are useless." % ",".join(memeber_set)) | DeleteCallBack请求参数结构体
| 6259908cbe7bc26dc9252c7d |
class Main(base.Module): <NEW_LINE> <INDENT> parameters = { "iface": "wlan0mon", "count": 10, } <NEW_LINE> completions = list(parameters.keys()) <NEW_LINE> def do_execute(self, line): <NEW_LINE> <INDENT> process_list = [] <NEW_LINE> try: <NEW_LINE> <INDENT> for _ in range(int(self.parameters['count'])): <NEW_LINE> <INDENT> name = get_fake_name() <NEW_LINE> mac = get_fake_mac() <NEW_LINE> p = Thread(target=SpawnAP, args=(name, mac, self.parameters['iface'])) <NEW_LINE> process_list.append(p) <NEW_LINE> p.start() <NEW_LINE> self.cp.success(text=f"Access point name : {name} - MAC {mac} started.") <NEW_LINE> <DEDENT> self.cp.info("Press Ctrl+C for stop ...") <NEW_LINE> input("") <NEW_LINE> <DEDENT> except KeyboardInterrupt: <NEW_LINE> <INDENT> self.cp.warning("\nKilling all access points, please wait ...") <NEW_LINE> self.cp.success("Done.") <NEW_LINE> <DEDENT> <DEDENT> def complete_set(self, text, line, begidx, endidx): <NEW_LINE> <INDENT> mline = line.partition(' ')[2] <NEW_LINE> offs = len(mline) - len(text) <NEW_LINE> return [s[offs:] for s in self.completions if s.startswith(mline)] | Spamming Fake access points | 6259908c8a349b6b43687eaf |
class FollowedLabelAPIView(CustomAPIView): <NEW_LINE> <INDENT> def get(self, request, user_slug): <NEW_LINE> <INDENT> user = UserProfile.objects.filter(slug=user_slug).first() <NEW_LINE> if not user: <NEW_LINE> <INDENT> return self.error('用户不存在', 404) <NEW_LINE> <DEDENT> follows = Label.objects.filter(labelfollow__user_id=user.uid) <NEW_LINE> serializer_context = {'uid': user.uid} <NEW_LINE> data = self.paginate_data(request, follows, UserPageLabelSerializer, serializer_context=serializer_context) <NEW_LINE> return self.success(data) | 关注的标签 | 6259908c7cff6e4e811b7692 |
class Selector(pg.sprite.Sprite): <NEW_LINE> <INDENT> def __init__(self, width): <NEW_LINE> <INDENT> super(Selector, self).__init__() <NEW_LINE> self.image = pg.Surface((550,width)) <NEW_LINE> self.rect = self.image.get_rect() <NEW_LINE> self.image.fill(c.g) | asdsad | 6259908cf9cc0f698b1c60f3 |
class AccountStateResponse(Model): <NEW_LINE> <INDENT> def __init__(self, balance: float=None, unrealized_pl: float=None, equity: float=None, am_data: List[List[List[str]]]=None): <NEW_LINE> <INDENT> self.swagger_types = { 'balance': float, 'unrealized_pl': float, 'equity': float, 'am_data': List[List[List[str]]] } <NEW_LINE> self.attribute_map = { 'balance': 'balance', 'unrealized_pl': 'unrealizedPl', 'equity': 'equity', 'am_data': 'amData' } <NEW_LINE> self._balance = balance <NEW_LINE> self._unrealized_pl = unrealized_pl <NEW_LINE> self._equity = equity <NEW_LINE> self._am_data = am_data <NEW_LINE> <DEDENT> @classmethod <NEW_LINE> def from_dict(cls, dikt) -> 'AccountStateResponse': <NEW_LINE> <INDENT> return util.deserialize_model(dikt, cls) <NEW_LINE> <DEDENT> @property <NEW_LINE> def balance(self) -> float: <NEW_LINE> <INDENT> return self._balance <NEW_LINE> <DEDENT> @balance.setter <NEW_LINE> def balance(self, balance: float): <NEW_LINE> <INDENT> if balance is None: <NEW_LINE> <INDENT> raise ValueError("Invalid value for `balance`, must not be `None`") <NEW_LINE> <DEDENT> self._balance = balance <NEW_LINE> <DEDENT> @property <NEW_LINE> def unrealized_pl(self) -> float: <NEW_LINE> <INDENT> return self._unrealized_pl <NEW_LINE> <DEDENT> @unrealized_pl.setter <NEW_LINE> def unrealized_pl(self, unrealized_pl: float): <NEW_LINE> <INDENT> if unrealized_pl is None: <NEW_LINE> <INDENT> raise ValueError("Invalid value for `unrealized_pl`, must not be `None`") <NEW_LINE> <DEDENT> self._unrealized_pl = unrealized_pl <NEW_LINE> <DEDENT> @property <NEW_LINE> def equity(self) -> float: <NEW_LINE> <INDENT> return self._equity <NEW_LINE> <DEDENT> @equity.setter <NEW_LINE> def equity(self, equity: float): <NEW_LINE> <INDENT> self._equity = equity <NEW_LINE> <DEDENT> @property <NEW_LINE> def am_data(self) -> List[List[List[str]]]: <NEW_LINE> <INDENT> return self._am_data <NEW_LINE> <DEDENT> @am_data.setter <NEW_LINE> def am_data(self, am_data: List[List[List[str]]]): <NEW_LINE> <INDENT> self._am_data = am_data | NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually. | 6259908de1aae11d1e7cf63d |
class TokenMap(object): <NEW_LINE> <INDENT> token_class = None <NEW_LINE> token_to_host_owner = None <NEW_LINE> tokens_to_hosts_by_ks = None <NEW_LINE> ring = None <NEW_LINE> _metadata = None <NEW_LINE> def __init__(self, token_class, token_to_host_owner, all_tokens, metadata): <NEW_LINE> <INDENT> self.token_class = token_class <NEW_LINE> self.ring = all_tokens <NEW_LINE> self.token_to_host_owner = token_to_host_owner <NEW_LINE> self.tokens_to_hosts_by_ks = {} <NEW_LINE> self._metadata = metadata <NEW_LINE> self._rebuild_lock = RLock() <NEW_LINE> <DEDENT> def rebuild_keyspace(self, keyspace, build_if_absent=False): <NEW_LINE> <INDENT> with self._rebuild_lock: <NEW_LINE> <INDENT> current = self.tokens_to_hosts_by_ks.get(keyspace, None) <NEW_LINE> if (build_if_absent and current is None) or (not build_if_absent and current is not None): <NEW_LINE> <INDENT> replica_map = self.replica_map_for_keyspace(self._metadata.keyspaces[keyspace]) <NEW_LINE> self.tokens_to_hosts_by_ks[keyspace] = replica_map <NEW_LINE> <DEDENT> <DEDENT> <DEDENT> def replica_map_for_keyspace(self, ks_metadata): <NEW_LINE> <INDENT> strategy = ks_metadata.replication_strategy <NEW_LINE> if strategy: <NEW_LINE> <INDENT> return strategy.make_token_replica_map(self.token_to_host_owner, self.ring) <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return None <NEW_LINE> <DEDENT> <DEDENT> def remove_keyspace(self, keyspace): <NEW_LINE> <INDENT> self.tokens_to_hosts_by_ks.pop(keyspace, None) <NEW_LINE> <DEDENT> def get_replicas(self, keyspace, token): <NEW_LINE> <INDENT> tokens_to_hosts = self.tokens_to_hosts_by_ks.get(keyspace, None) <NEW_LINE> if tokens_to_hosts is None: <NEW_LINE> <INDENT> self.rebuild_keyspace(keyspace, build_if_absent=True) <NEW_LINE> tokens_to_hosts = self.tokens_to_hosts_by_ks.get(keyspace, None) <NEW_LINE> <DEDENT> if tokens_to_hosts: <NEW_LINE> <INDENT> point = bisect_right(self.ring, token) <NEW_LINE> if point == len(self.ring): <NEW_LINE> <INDENT> return tokens_to_hosts[self.ring[0]] <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> return tokens_to_hosts[self.ring[point]] <NEW_LINE> <DEDENT> <DEDENT> return [] | Information about the layout of the ring. | 6259908d283ffb24f3cf54f1 |
class UserRole: <NEW_LINE> <INDENT> COORDINATOR, RESIDENT, VOLUNTEER = '1', '2', '3' <NEW_LINE> ROLES = [ (COORDINATOR, "Coordinator"), (RESIDENT, "Resident"), (VOLUNTEER, "Volunteer") ] | Constants used in the User class. | 6259908dfff4ab517ebcf468 |
class NonPositiveTypedValueFormat(TypedValueFormat): <NEW_LINE> <INDENT> def check_value(self, value): <NEW_LINE> <INDENT> TypedValueFormat.check_value(self, value) <NEW_LINE> if value > 0: <NEW_LINE> <INDENT> raise ValueFormatError(u"%s should not be positive" % value) | Checks that the value is a non-positive number. | 6259908ddc8b845886d5520b |
class NonMacroCall(Token): <NEW_LINE> <INDENT> pattern = _anything_up_to(r'|'.join([ MacroCallStart.pattern, MacroArgument.pattern, SharpComment.delimiter, ])) | Matches anything up to a MacroArgument or MacroCallStart. | 6259908de1aae11d1e7cf63e |
class TitForTat(Strategy): <NEW_LINE> <INDENT> @Strategy.default(COOP) <NEW_LINE> def decide(self, rs): <NEW_LINE> <INDENT> return rs | Plays what the opponent played last time. | 6259908d3346ee7daa33848b |
class LogarithmicStep(Step): <NEW_LINE> <INDENT> def __init__(self, alpha=1, beta=1): <NEW_LINE> <INDENT> gamma = lambda n : 1 / (np.log(n + 2) ** alpha) <NEW_LINE> eta = lambda n : 1 / (np.log(n + 2) ** beta) <NEW_LINE> super().__init__(gamma, eta) <NEW_LINE> self.alpha = alpha <NEW_LINE> self.beta = beta <NEW_LINE> <DEDENT> def __str__(self): <NEW_LINE> <INDENT> return ("logarithmic steps with alpha=%.2f, beta=%.2f"%(self.alpha, self.beta)) | The logarithmic coefficient with 1/(log(n)^alpha) for gamma and 1/(log(n)^beta) for eta on step n. | 6259908d099cdd3c63676223 |
class LeNet5(nn.Module): <NEW_LINE> <INDENT> def __init__(self): <NEW_LINE> <INDENT> super(LeNet5, self).__init__() <NEW_LINE> self.convnet = nn.Sequential(OrderedDict([ ('c1', nn.Conv2d(1, 6, kernel_size=(5, 5))), ('tanh1', nn.Tanh()), ('s2', nn.MaxPool2d(kernel_size=(2, 2), stride=2)), ('c3', nn.Conv2d(6, 16, kernel_size=(5, 5))), ('tanh3', nn.Tanh()), ('s4', nn.MaxPool2d(kernel_size=(2, 2), stride=2)), ('c5', nn.Conv2d(16, 120, kernel_size=(5, 5))), ('tanh5', nn.Tanh()) ])) <NEW_LINE> self.fc = nn.Sequential(OrderedDict([ ('f6', nn.Linear(120, 84)), ('tanh6', nn.Tanh()), ('f7', nn.Linear(84, 10)), ('sig7', nn.LogSoftmax(dim=-1)) ])) <NEW_LINE> <DEDENT> def forward(self, img): <NEW_LINE> <INDENT> output = self.convnet(img) <NEW_LINE> output = output.view(img.size(0), -1) <NEW_LINE> output = self.fc(output) <NEW_LINE> return output <NEW_LINE> <DEDENT> def extract_features(self, img): <NEW_LINE> <INDENT> output = self.convnet(img) <NEW_LINE> output = output.view(img.size(0), -1) <NEW_LINE> output = self.fc[1](self.fc[0](output)) <NEW_LINE> return output | Input - 1x32x32
C1 - 6@28x28 (5x5 kernel)
tanh
S2 - 6@14x14 (2x2 kernel, stride 2) Subsampling
C3 - 16@10x10 (5x5 kernel, complicated shit)
tanh
S4 - 16@5x5 (2x2 kernel, stride 2) Subsampling
C5 - 120@1x1 (5x5 kernel)
F6 - 84
tanh
F7 - 10 (Output) | 6259908dd486a94d0ba2dc07 |
class GIL_837: <NEW_LINE> <INDENT> pass | Glitter Moth | 6259908d091ae35668706899 |
class DenseNet(chainer.Chain): <NEW_LINE> <INDENT> def __init__(self, depth=40, growth_rate=12, in_channels=16, dropout_ratio=0.2, n_class=10): <NEW_LINE> <INDENT> assert (depth - 4) % 3 == 0 <NEW_LINE> n_layers = int((depth - 4) / 3) <NEW_LINE> n_ch = [in_channels + growth_rate * n_layers * i for i in range(4)] <NEW_LINE> dropout_ratio = dropout_ratio if dropout_ratio > 0 else None <NEW_LINE> super(DenseNet, self).__init__( conv0=L.Convolution2D(3, n_ch[0], 3, pad=1), dense1=DenseBlock( n_ch[0], n_layers, growth_rate, dropout_ratio), trans1=TransitionLayer(n_ch[1], n_ch[1], dropout_ratio), dense2=DenseBlock( n_ch[1], n_layers, growth_rate, dropout_ratio), trans2=TransitionLayer(n_ch[2], n_ch[2], dropout_ratio), dense3=DenseBlock( n_ch[2], n_layers, growth_rate, dropout_ratio), norm4=L.BatchNormalization(n_ch[3]), fc4=L.Linear(n_ch[3], n_class), ) <NEW_LINE> <DEDENT> def __call__(self, x): <NEW_LINE> <INDENT> h = self.conv0(x) <NEW_LINE> h = self.dense1(h) <NEW_LINE> h = self.trans1(h) <NEW_LINE> h = self.dense2(h) <NEW_LINE> h = self.trans2(h) <NEW_LINE> h = self.dense3(h) <NEW_LINE> h = F.relu(self.norm4(h)) <NEW_LINE> h = F.average_pooling_2d(h, 8) <NEW_LINE> h = self.fc4(h) <NEW_LINE> return h | Densely Connected Convolutional Networks
see: https://arxiv.org/abs/1608.06993 | 6259908d50812a4eaa6219f0 |
class EnrollmentDecisionTask(HostedBaseTask): <NEW_LINE> <INDENT> def __init__(self, account=1, creator=1, type=1, data=None): <NEW_LINE> <INDENT> tqconn = HostedTaskQueue() <NEW_LINE> jdata = json.loads(data) <NEW_LINE> tags = [] <NEW_LINE> tags.append("creator=" + str(creator)) <NEW_LINE> tags.append("deviceId=" + jdata['Device']['Udid']) <NEW_LINE> tags.append("owner=" + jdata['User']['Email']) <NEW_LINE> tags.append("type=" + str(type)) <NEW_LINE> tags.append("status=1") <NEW_LINE> tags.append("restServiceFlag=1") <NEW_LINE> payload_base64 = base64.b64encode(data) <NEW_LINE> result = tqconn.do_add(tqname='enrollment', namespace='mobile', account=account, payload=payload_base64, tags=tags) <NEW_LINE> if result.code == 200 or result.code == 201: <NEW_LINE> <INDENT> logger.info('Notification REST Service - Add enrollment decision task success!') <NEW_LINE> <DEDENT> else: <NEW_LINE> <INDENT> raise ServerInternalException('Add enrollment decision task failed!') | class EnrollmentDicisionTask
This class implements the task information and operations for enrollment decision task queue
Attributes:
None
Notes:
All sections in the basetask list as follows:
owner, priority, enqueue_timestamp, account, name, tags, http_last_modified, task_retries, payload_base64
tags and payload_base64 would be parsed in the subclass. | 6259908d4a966d76dd5f0b3a |
class TabbedEditorFactory(object): <NEW_LINE> <INDENT> def getFileExtensions(self): <NEW_LINE> <INDENT> raise NotImplementedError("All subclasses of TabbedEditorFactory have to override the 'getFileExtensions' method") <NEW_LINE> <DEDENT> def canEditFile(self, filePath): <NEW_LINE> <INDENT> raise NotImplementedError("All subclasses of TabbedEditorFactory have to override the 'canEditFile' method") <NEW_LINE> <DEDENT> def create(self, filePath): <NEW_LINE> <INDENT> raise NotImplementedError("All subclasses of TabbedEditorFactory have to override the 'create' method") | Constructs instances of TabbedEditor (multiple instances of one TabbedEditor
can coexist - user editing 2 layouts for example - with the ability to switch
from one to another) | 6259908dec188e330fdfa503 |
class GlueMixin: <NEW_LINE> <INDENT> @classmethod <NEW_LINE> def get_glue_preds(cls, pred_dict: Dict): <NEW_LINE> <INDENT> indexes = [] <NEW_LINE> predictions = [] <NEW_LINE> for pred, guid in zip(list(pred_dict["preds"]), list(pred_dict["guids"])): <NEW_LINE> <INDENT> indexes.append(int(guid.split("-")[1])) <NEW_LINE> predictions.append(str(cls.LABELS[pred]).lower()) <NEW_LINE> <DEDENT> return (indexes, predictions) | Mixin for :class:`jiant.tasks.core.Task`s in the `GLUE<https://gluebenchmark.com/>`_
benchmark. | 6259908d5fcc89381b266f88 |
class Activity(db.Model): <NEW_LINE> <INDENT> __tablename__ = 'activities' <NEW_LINE> id = db.Column(db.Integer, primary_key=True) <NEW_LINE> name = db.Column(db.String(100), unique=True) <NEW_LINE> artists = db.relationship('Artist', backref='activity', lazy='dynamic') <NEW_LINE> def __repr__(self): <NEW_LINE> <INDENT> return '{}'.format(self.name) | An activity, such as cycling or driving. | 6259908daad79263cf430407 |
class GenericConversion(AbstractBasicConversion): <NEW_LINE> <INDENT> def __init__(self, **kwargs): <NEW_LINE> <INDENT> super().__init__(**kwargs) | Generic conversion class that can be used in cases that the actual asset type is not important or not supported yet in ESDL | 6259908df9cc0f698b1c60f6 |
class Archive(FBOTableEntry): <NEW_LINE> <INDENT> fields = re.split( r"\s+", "date solicitation_number award_number agency office location archive_date ntype") <NEW_LINE> def migrations(self): <NEW_LINE> <INDENT> return (("011_%s_table.sql" % self.record_type, self.sql_table(), "DROP TABLE %s;" % self.record_type),) | Model of a Archive | 6259908de1aae11d1e7cf640 |
Subsets and Splits