class SearchBase(BaseStatsModel): type_name = 'search' stats_class = SearchStats data_fields = ['search_engine', 'search_term'] search_engine = StringType(default='') search_term = StringType(default='')
class VMImport(Model): name = StringType(serialized_name='NAME', required=True) os = StringType(serialized_name='OS', required=True) launch_server = StringType(serialized_name='LAUNCH_SERVER', required=True) userid = IntType(serialized_name='USERID', required=True) product_specification_lcuuid = UUIDType( serialized_name='PRODUCT_SPECIFICATION_LCUUID', required=True) domain = UUIDType(required=True, serialized_name='DOMAIN')
class BackupChargeAdd(Model): """Backup Charge add structure """ name = StringType(required=True, serialized_name='NAME') userid = IntType(required=True, serialized_name='USERID') start_time = StringType(required=True, serialized_name='START_TIME') size = IntType(required=True, serialized_name='SIZE') domain = UUIDType(serialized_name='DOMAIN', required=True) charge_mode = IntType(required=True, serialized_name='CHARGE_MODE') price = IntType(required=True, serialized_name='PRICE')
class Parent(Model): id = StringType() gender = StringType() name = StringType() class Options: roles = { 'public': blacklist("id", "gender"), 'gender': blacklist("gender") }
class HostAdd(Model): """Host add model structure """ _instance_types = ['VM', 'NSP'] instance_types = string_enum(*_instance_types) instance_types_dict = dict(zip(_instance_types, [1, 3])) _hypervisor_types = ['XEN', 'VMWARE', 'KVM'] hypervisor_types = string_enum(*_hypervisor_types) hypervisor_types_dict = dict(zip(_hypervisor_types, [1, 2, 3])) _nic_types = ['GIGABIT', 'XGIGABIT'] nic_types = string_enum(*_nic_types) nic_types_dict = dict(zip(_nic_types, [1, 2])) ip = IPv4Type(required=True, serialized_name='IP') user_name = StringType(required=True, serialized_name='USER_NAME') user_passwd = StringType(required=True, serialized_name='USER_PASSWD') instance_type = StringType(required=True, serialized_name='INSTANCE_TYPE', choices=_instance_types) rack_name = StringType(required=True, serialized_name='RACK_NAME') hypervisor_type = StringType(required=True, serialized_name='HYPERVISOR_TYPE', choices=_hypervisor_types) nic_type = StringType(required=True, serialized_name='NIC_TYPE', choices=_nic_types) uplink_ip = IPv4Type(serialized_name='UPLINK_IP') uplink_netmask = IPv4Type(serialized_name='UPLINK_NETMASK') uplink_gateway = IPv4Type(serialized_name='UPLINK_GATEWAY') misc = StringType(serialized_name='MISC') brand = StringType(serialized_name='BRAND') model = StringType(serialized_name='MODEL') storage_link_ip = IPv4Type(serialized_name='STORAGE_LINK_IP')
class SourceBase(BaseStatsModel): use_indexes = False type_name = 'source' stats_class = SourceStats data_fields = ['source'] source = StringType(required=True)
class UrlBase(BaseStatsModel): type_name = 'url' stats_class = UrlStats data_fields = ['url', 'title', 'checksum'] index_fields = ['checksum'] url = URLType(required=True) title = StringType(default='') checksum = SHA1Type() def _add_checksum(self, query): query = query or {} if 'url' in query: query['checksum'] = get_checksum(query['url']) def validate_checksum(self, data, value): checksum = get_checksum(data['url']) data['checksum'] = checksum return checksum def find(self, query=None, *args, **kwargs): self._add_checksum(query) return super(UrlBase, self).find(query, *args, **kwargs) def find_one(self, query=None, *args, **kwargs): self._add_checksum(query) return super(UrlBase, self).find_one(query, *args, **kwargs)
class OutsideShares(BaseModel): collection_name = 'outside_shares' indexes = [{ 'index': [('site', 1), ('checksum', 1), ('source', 1)], 'args': { 'unique': True } }] site = IntType(required=True) url = URLType(required=True) checksum = SHA1Type() source = StringType(required=True) shares = IntType() data_fields = ['url', 'checksum', 'source'] def _add_checksum(self, query): query = query or {} if 'url' in query: query['checksum'] = get_checksum(query['url']) def validate_checksum(self, data, value): checksum = get_checksum(data['url']) data['checksum'] = checksum return checksum def find(self, query=None, *args, **kwargs): self._add_checksum(query) return super(OutsideShares, self).find(query, *args, **kwargs) def find_one(self, query=None, *args, **kwargs): self._add_checksum(query) return super(OutsideShares, self).find_one(query, *args, **kwargs) def get_totals(self, site_id, group_fields=None, limit=None): match = {'site': site_id} group = {'_id': {}, 'shares': {'$sum': '$shares'}} sort = {'shares': -1} if group_fields is None: group_fields = self.data_fields for field in group_fields: group['_id'][field] = '$%s' % field pipeline = [{'$match': match}, {'$group': group}, {'$sort': sort}] if limit is not None: pipeline.append({'$limit': limit}) result = list(self.collection.aggregate(pipeline)) return self._replace_id(result) def get_totals_without_group(self, site_id): totals = self.get_totals(site_id, group_fields=[]) if not totals: return {'shares': 0} return totals[0] def set_counter(self, site, url, source, value): checksum = get_checksum(url) query = dict(site=site, url=url, checksum=checksum, source=source) self.set(query, {'shares': value}, upsert=True)
class CountryBase(BaseStatsModel): use_indexes = False type_name = 'country' stats_class = CountryStats data_fields = ['country'] country = StringType(required=True)
class DomainBase(BaseStatsModel): use_indexes = False type_name = 'domain' stats_class = DomainStats data_fields = ['domain'] domain = StringType(default='')
def __new__(mcs, name, bases, attrs): all_attrs = {} for base in reversed(bases): all_attrs.update(dict(inspect.getmembers(base))) all_attrs.update(attrs) type_name = all_attrs['type_name'] stats_class = all_attrs['stats_class'] has_granularity = all_attrs['has_granularity'] if type_name: attrs['type'] = StringType(required=True, default=all_attrs['type_name']) if stats_class: attrs['totals'] = ModelType(stats_class) if has_granularity: attrs['values'] = DictType(ModelType(stats_class)) new_class = super(StatsModelMetaClass, mcs).__new__(mcs, name, bases, attrs) index_fields = getattr(new_class, 'index_fields', new_class.data_fields) indexes = deepcopy(new_class.indexes) index = indexes[0]['index'] # add specific fields to index for field in index_fields: index_entry = (field, 1) if index_entry not in index: index.append(index_entry) new_class.indexes = indexes return new_class
class Response(DashbaseResponse): request = ModelType(Request) # type: Request totalDocs = LongType() numDocs = LongType() numHits = LongType() numDocsProcessed = LongType() numHitsProcessed = LongType() latencyInMillis = LongType() timeProcessedTo = LongType(default=0) isTimedOut = BooleanType(default=False) startId = StringType() endId = StringType() error = StringType() debugMap = DictType(BaseType) hits = ListType(ModelType(Hit)) # type: list[Hit] aggregations = DictType(BaseType) schema = DictType(StringType)
class GrandParent(Parent): age = IntType() family_secret = StringType() class Options: roles = { 'grandchildren': whitelist("age"), 'public': blacklist("id", "family_secret") }
class PyagexecStorage(Model): pool_name = StringType(required=True, serialized_name='POOL_NAME') uuid = UUIDType(serialized_name='UUID') total_size = IntType(required=True, serialized_name='TOTAL_SIZE') used_size = IntType(required=True, serialized_name='USED_SIZE') def validate_used_size(self, data, value): if data['total_size'] < value or value < 0: raise ValidationError('0 <= used_size <= total_size') return value
class StorageAdd(Model): """Storage add model structure """ _backends = ['CEPH_RBD'] backends = string_enum(*_backends) backends_dict = dict(zip(_backends, [1])) _types = ['CAPACITY', 'PERFORMANCE'] types = string_enum(*_types) name = StringType(required=True, serialized_name='NAME') uuid = UUIDType(serialized_name='UUID') disk_total = IntType(required=True, serialized_name='DISK_TOTAL') disk_used = IntType(required=True, serialized_name='DISK_USED') backend = StringType(required=True, serialized_name='BACKEND', choices=_backends) hosts = ListType(IPv4Type, serialized_name='HOSTS', default=[]) type = StringType(required=True, serialized_name='TYPE', choices=_types) domain = UUIDType(serialized_name='DOMAIN', required=True)
class Request(Model): startTimeInMillis = LongType(serialize_when_none=False) endTimeInMillis = LongType(serialize_when_none=False) endGlobalId = LongType(serialize_when_none=False) startGlobalId = LongType(serialize_when_none=False) numResults = LongType(default=10) tableNames = ListType(StringType, default=["*"]) excludeTableNames = ListType(StringType, default=[]) query = DictType(BaseType, serialize_when_none=False) aggregations = DictType(BaseType, serialize_when_none=False) fields = ListType(StringType, default=[]) useApproximation = BooleanType(default=False) ctx = StringType(serialize_when_none=False) fetchSchema = BooleanType(default=False) timeoutMillis = LongType(default=0x7fffffff) disableHighlight = BooleanType(default=False) startId = StringType(serialize_when_none=False) endId = StringType(serialize_when_none=False) debugMode = LongType(serialize_when_none=False) def set_query(self, query=None): if not query: query = "*" self.query = {"queryType": "string", "queryStr": query}
class User(with_metaclass(ORMMeta, BaseModel, UserMixin)): _uniques = ['email'] firstname = StringType() lastname = StringType() email = StringType(required=True) password = StringType() active = BooleanType(default=True) confirmed_at = DateTimeType() last_login_at = DateTimeType(default=datetime.datetime.now) current_login_at = DateTimeType(default=datetime.datetime.now) registered_at = DateTimeType() last_login_ip = StringType() current_login_ip = StringType() login_count = IntType() sort_on = IntType() roles = ListType(ModelType(Role), default=[])
class Question(Model): question_id = StringType(required=True) type = StringType(default="text")
class Payload(Model): fields = DictType(ListType(StringType)) stored = StringType() entities = ListType(ModelType(Entity)) # type: Entity
class Child(Parent): bio = StringType()
class Parent(Model): name = StringType(required=True)
class User(Model): name = StringType(required=True) bio = StringType(required=True)
class Player(Model): name = StringType()
class User(Model): username = StringType()
class User(Model): username = StringType(deserialize_from='name')
class Parent(Model): id = StringType() name = StringType() class Options: roles = {'public': blacklist("id")}
class Player(Model): name = StringType(required=True)
class ClusterInfo(Model): metrics = ModelType(ClusterMetricInfo) # type: ClusterMetricInfo info = DictType(ListType(StringType()))
class ClusterOverviewResponse(DashbaseResponse): clusterPrefix = StringType() overview = DictType(ModelType(ClusterInfo)) # type: dict[str, ClusterInfo]
class User(Model): name = StringType(default=u'Doggy')