class UserSchema(Schema): id = fields.Integer(required=True) full_name = fields.String(required=True) email = fields.String(required=True) manager = fields.Boolean(required=True) editor = fields.Boolean(required=True) submitter = fields.Boolean(required=True) roles = fields.List(fields.Nested(RoleSchema), required=True)
class TrainArgsSchemaPro(Schema): class Meta: unknown = INCLUDE # supports extra parameters batch_size_per_device = fields.Integer( missing=64, description='Batch size for each GPU.', required=False) dataset = fields.Str( missing='synthetic_data', enum=['synthetic_data', 'imagenet', 'imagenet_mini', 'cifar10'], description='Dataset to perform training on. \ synthetic_data: randomly generated ImageNet-like \ images; imagenet_mini: 3% of the real ImageNet \ dataset', required=False) model = fields.Str(missing='resnet50 (ImageNet)', enum=[ 'googlenet (ImageNet)', 'inception3 (ImageNet)', 'mobilenet (ImageNet)', 'overfeat (ImageNet)', 'resnet50 (ImageNet)', 'resnet152 (ImageNet)', 'vgg16 (ImageNet)', 'vgg19 (ImageNet)', 'resnet56 (Cifar10)', 'resnet110 (Cifar10)', 'alexnet (ImageNet, Cifar10)' ], description='CNN model for training. N.B. Models only \ support specific data sets, given in brackets. \ synthetic_data can only be processed by ImageNet models.', required=False) num_gpus = fields.Integer(missing=1, description='Number of GPUs to train on \ (one node only). If set to zero, CPU is used.', required=False) num_epochs = fields.Float(missing=NUM_EPOCHS, description='Number of epochs to \ train on (float value, < 1.0 allowed).', required=False) optimizer = fields.Str(missing='sgd', enum=['sgd', 'momentum', 'rmsprop', 'adam'], description='Optimizer to use.', required=False) use_fp16 = fields.Boolean(missing=False, enum=[False, True], description='Use 16-bit floats for certain \ tensors instead of 32-bit floats. ', required=False) weight_decay = fields.Float(missing=4.0e-5, description='Weight decay factor for training', required=False) evaluation = fields.Boolean(missing=True, enum=[False, True], description='Perform evaluation after the \ benchmark in order to get accuracy results \ (only meaningful on real data sets!).', required=False) if_cleanup = fields.Boolean(missing=False, enum=[False, True], description='If to delete training and \ evaluation directories.', required=False)
class TagSchema(Schema): id = fields.Integer(required=True) code = fields.String(required=True) title = fields.String(required=True) color = fields.String() system = fields.Boolean() verbose_title = fields.String() is_used_in_revision = fields.Boolean() url = fields.String()
class DataDictResource(Resource): @api.doc("generate_patient_data_dict") @use_args({"as_file": fields.Boolean(missing=False)}) def get(self, args): """Provide Clinic Statistics""" patientDataDict_df = dataDictMaker( dateFormat="%d-%m-%Y", joinArrayBy=", ", calculateAgeAsStr=True, convertUUID=True, ) if args["as_file"]: # create an output stream output = BytesIO() with pd.ExcelWriter(output, engine="xlsxwriter") as writer: patientDataDict_df.to_excel(writer, sheet_name="DataDict") output.seek(0) return send_file( output, attachment_filename="data_dict.xlsx", as_attachment=True, ) else: table_data = { "colHeaders": list(patientDataDict_df.columns), "data": patientDataDict_df.values.tolist(), } return table_data, 200
class TrainArgsSchema(Schema): class Meta: unknown = INCLUDE # supports extra parameters train_epochs = fields.Integer( required=False, missing=10, description="Number of training epochs") batch_size = fields.Integer( missing=16, description='Global Batch size', required=False) num_gpus = fields.Integer( missing=1, validate=gpus_must_exist, description='Number of GPUs to use, if available (0 = CPU)', required=False) upload_back = fields.Boolean( missing=False, enum=[False, True], description='Either upload a trained graph back to the remote storage (True) or not (False, default)', required=False)
class OddsList(Resource): odds_args = { 'odds_name': fields.String(), 'odds_type': fields.String(), 'sport': fields.String(), 'per_page': fields.Integer(), 'page': fields.Integer(), 'filter_name': fields.String(), 'active': fields.Boolean(), } def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._default_response = { 'status': 'fail', 'message': 'Invalid payload.', } self._create_odds_schema = CreateOddsSchema() @use_args(odds_args) @json_response def get(self, query_params): return get_odds_by(**query_params), 200 @json_response def post(self): req = request.get_json() errors = self._create_odds_schema.validate(req) if errors: return self._default_response, 422 return create_entity(Odds(**req))
class ModelsApiPredict(Resource): @doc(description=dedent(""" Predict document categorization with a previously trained model **Parameters** - `max_result_categories` : the maximum number of categories in the results - `sort` : sort by the score of the most likely class - `ml_output` : type of the output in ['decision_function', 'probability'], only affects ML methods. - `nn_metric` : The similarity returned by nearest neighbor classifier in ['cosine', 'jaccard', 'cosine_norm', 'jaccard_norm']. - `min_score` : filter out results below a similarity threashold """)) @use_args({ 'max_result_categories': wfields.Int(missing=1), 'sort': wfields.Boolean(missing=False), 'ml_output': wfields.Str(missing='probability'), 'nn_metric': wfields.Str(missing='jaccard_norm'), 'min_score': wfields.Number(missing=-1) }) @marshal_with(CategorizationPredictSchema()) def get(self, mid, **args): sort = args.pop('sort') max_result_categories = args.pop('max_result_categories') min_score = args.pop("min_score") cat = _CategorizerWrapper(self._cache_dir, mid=mid) y_res, nn_res = cat.predict(**args) res = _CategorizerWrapper.to_dict( y_res, nn_res, cat.le.classes_, cat.fe.db.data, sort=sort, max_result_categories=max_result_categories, min_score=min_score) return res
class ServerInfoApi(Resource): @doc(description="Return FreeDiscovery server information " " (versions, etc).") @marshal_with( argmap2schema({ 'version': wfields.Nested({'number': wfields.Str()}), 'env': wfields.Nested({'python_version': wfields.Str()}), 'config': wfields.Nested({ 'cache_dir': wfields.Str(), 'debug': wfields.Boolean(), 'hostname': wfields.Str(), 'log_file': wfields.Str(), 'n_workers': wfields.Int(), 'port': wfields.Int(), 'server': wfields.Str() }) })) def get(self): out = {'version': {}, 'env': {}} out['version']['number'] = __version__ out['env']['python_version'] = sys.version out['config'] = self._fd_config return out
class AdminPayModeConfigView(AdminBaseView): """后台-商铺的支付方式设置""" @AdminBaseView.permission_required( [AdminBaseView.staff_permissions.ADMIN_CONFIG]) @use_args( { "key": fields.String( required=True, validate=[validate.OneOf(["weixin_jsapi", "on_delivery"])], comment="设置的字段名", ), "value": fields.Boolean(required=True, comment="设置的字段值"), }, location="json") def put(self, request, args): shop = self.current_shop config_info = {args.get("key"): args.get("value")} is_wx = "weixin_jsapi" in config_info.keys() # 未认证或者未开通线上支付时,还是可以点击关闭货到付款按钮 if is_wx and shop.cerify_active != ShopVerifyActive.YES: return self.send_fail(error_text="已认证的商铺才可申请开通在线支付,您的店铺暂未认证,请前往认证") if is_wx and shop.pay_active != ShopPayActive.YES: return self.send_fail(error_text="店铺未开通线上支付") some_config = update_some_config_by_shop_id(shop.id, config_info) # 最少需要保留一种支付方式 if not some_config.weixin_jsapi and not some_config.on_delivery: return self.send_fail(error_text="至少保留一种商城支付方式,否则客户无法支付") return self.send_success()
class AdminConfigMsgNotifyView(AdminBaseView): """后台-设置-消息通知-获取&修改店铺消息通知设置""" @AdminBaseView.permission_required( [AdminBaseView.staff_permissions.ADMIN_CONFIG]) def get(self, request): shop_id = self.current_shop.id msg_notify = get_msg_notify_by_shop_id(shop_id) msg_notify = MsgNotifySerializer(msg_notify).data return self.send_success(data=msg_notify) @AdminBaseView.permission_required( [AdminBaseView.staff_permissions.ADMIN_CONFIG]) @use_args( { "field": fields.String( required=True, validate=[validate.OneOf(msg_notify_field_list)], comment="更改的字段", ), "value": fields.Boolean(required=True, comment="更改的值"), }, location="json") def put(self, request, args): shop_id = self.current_shop.id msg_notify_info = {args.get("field"): args.get("value")} update_msg_notify_by_shop_id(shop_id, msg_notify_info) return self.send_success()
class EventSpanResource(ProtectedResource, GrampsJSONEncoder): """Event date span resource.""" @property def db_handle(self) -> DbReadBase: """Get the database instance.""" return get_db_handle() @use_args( { "as_age": fields.Boolean(missing=True), "locale": fields.Str(missing=None, validate=validate.Length(min=1, max=5)), "precision": fields.Integer(missing=2, validate=validate.Range(min=1, max=3)), }, location="query", ) def get(self, args: Dict, handle1: Handle, handle2: Handle) -> Response: """Get the time span between two event dates.""" try: event1 = self.db_handle.get_event_from_handle(handle1) event2 = self.db_handle.get_event_from_handle(handle2) except HandleError: abort(404) locale = get_locale_for_language(args["locale"], default=True) span = (Span(event1.date, event2.date).format(precision=args["precision"], as_age=args["as_age"], dlocale=locale).strip("()")) return self.response(200, {"span": str(span)})
class AdminDeliveryConfigMethodView(AdminBaseView): """后台-订单-开启/关闭配送或者自提""" @use_args( { "home_on": fields.Boolean(comment="配送模式是否开启"), "pick_on": fields.Boolean(comment="自提模式是否开启"), }, location="json" ) def put(self, request, args): if not args: return self.send_fail(error_text="请选择配送设置项目") success, msg = update_delivery_config(self.current_shop.id, args) if not success: return self.send_fail(error_text=msg) return self.send_success()
class PodcastDetailsSchema(Schema): id = fields.Int(required=True) name = fields.Str(required=True) description = fields.Str(required=True) created_at = fields.DateTime(required=True) image_url = fields.URL() rss_link = fields.URL() download_automatically = fields.Boolean(default=True) episodes_count = fields.Integer(default=0)
class EventInfoSchema(Schema): title = fields.String(required=True) url = fields.URL(schemes={'http', 'https'}, required=True) can_disconnect = fields.Boolean(required=True, default=True) service = fields.Nested( EventInfoServiceSchema, required=True, default=SERVICE_INFO, )
class PatientResource(Resource): @api.doc("get_patient") @use_args( { "patient_uuid": fields.UUID(location="view_args"), "only_dermographic": fields.Boolean( location="querystring", missing=False ), } ) def get(self, args, **kwargs): """Get patient with the UUID""" if args["only_dermographic"]: patient_schema = PatientSchema( many=False, exclude=PatientModel.relationship_keys ) else: patient_schema = PatientSchema(many=False) patient = PatientModel.query.filter_by(id=args["patient_uuid"]).first() return patient_schema.dump(patient), 200 @api.doc("modify_existing_patient") def patch(self, patient_uuid): """Modify patient with the UUID""" patient_schema = PatientSchema(many=False) patient_payload = parser.parse(PatientSchema, request) patient_payload = patient_schema.dump(patient_payload) patient = PatientModel.query.filter_by(id=patient_uuid).first() if patient: patient.update(**patient_payload) db.session.add(patient) db.session.commit() return patient_schema.dump(patient), 200 else: abort(404, "Patient not found.") @api.doc("delete_existing_patient") def delete(self, patient_uuid): """Delete patient with the UUID""" patient = PatientModel.query.filter_by(id=patient_uuid).first() if patient: patient.deleted = True db.session.add(patient) db.session.commit() return None, 204
class DatasetsApiElement(Resource): @use_args({'return_file_path': wfields.Boolean()}) @marshal_with(DatasetSchema()) def get(self, name, **args): from ..datasets import load_dataset res = load_dataset(name, self._cache_dir, verbose=True, load_ground_truth=True, verify_checksum=False, **args) return res
class TrainArgsSchema(Schema): class Meta: unknown = INCLUDE # support 'full_paths' parameter model_name = fields.Str( required=True, description="Name of the style image e.g. 'name.jpg' in nextcloud. This will also be the name of the model." ) upload_model = fields.Boolean( required=False, missing = 2, description="Upload model to nextcloud." ) epochs = fields.Int( required=False, missing = 2, description="Number of training epochs." ) learning_rate = fields.Float( required=False, missing = 0.003, description="Learning rate." ) batch_size = fields.Int( required=False, missing = 4, description="Batch size for training." ) content_weight = fields.Float( required=False, missing = 1e5, description="Weight for content-loss." ) style_weight = fields.Float( required=False, missing = 1e10, description="Number of iterations on the network to compute the gradients." ) size_train_img = fields.Int( required=False, missing = 256, description="Size of training images, default is 256 X 256" ) log_interval = fields.Int( required=False, missing = 200, description="Number of images after which the training loss is logged." )
class ComparisonGetParams(Schema): contributions = fields.DelimitedList(fields.String(), required=True, validate=validate.Length(min=2)) response_hash = fields.String() save_response = fields.Boolean() type = fields.String()
class MyRegisterView(RegisterView): post_args = { **RegisterView.post_args, 'active': fields.Boolean(required=True) } @use_kwargs(post_args) def post(self, **kwargs): """Register a user.""" return super(MyRegisterView, self).post(**kwargs)
class AdminDeliveryConfigPickView(AdminBaseView): """后台-订单-自提设置""" # 参数校验 def validate_time(self): try: datetime.datetime.strptime(self, "%H:%M") except Exception: return False return True @use_args( { "pick_service_amount": fields.Float(required=True, comment="自提模式服务费"), "pick_minimum_free_amount": fields.Float( required=True, comment="自提模式免服务费最小金额" ), "pick_today_on": fields.Boolean(required=True, comment="今天自提是否开启"), "pick_tomorrow_on": fields.Boolean(required=True, comment="明天自提是否开启"), "pick_periods": fields.Nested( { "from_time": fields.String( required=True, comment="自提起始时间", validate=validate_time ), "to_time": fields.String( required=True, comment="自提终止时间", validate=validate_time ), }, many=True, validate=[validate.Length(1)], unknown=True, comment="自提时段", ), }, location="json" ) def put(self, request, args): success, msg = update_delivery_config( self.current_shop.id, args, self.current_user.id ) if not success: return self.send_fail(error_text=msg) return self.send_success()
class AdminConfigReceiptBrcodeActiveView(AdminBaseView): """后台-设置-小票设置-打印订单号条码""" @AdminBaseView.permission_required( [AdminBaseView.staff_permissions.ADMIN_CONFIG]) @use_args( {"brcode_active": fields.Boolean(required=True, comment="打印单号条码")}, location="json") def put(self, request, args): args["brcode_active"] = int(args.get("brcode_active", 1)) shop_id = self.current_shop.id update_receipt_by_shop_id(shop_id, args) return self.send_success()
class FilterSchema(Schema): """Structure for a filter.""" function = fields.Str( required=False, missing="and", validate=validate.OneOf(["and", "or", "xor", "one"]), ) invert = fields.Boolean(required=False, missing=False) rules = fields.List(fields.Nested(RuleSchema), required=True, validate=validate.Length(min=1))
class RelationResource(ProtectedResource, GrampsJSONEncoder): """Relation resource.""" @property def db_handle(self) -> DbReadBase: """Get the database instance.""" return get_dbstate().db @use_args( { "depth": fields.Integer(), "all": fields.Boolean() }, location="query", ) def get(self, args: Dict, handle1: Handle, handle2: Handle) -> Response: """Get the relationship between two people.""" db_handle = self.db_handle person1 = get_person_by_handle(db_handle, handle1) if person1 is None: abort(404) person2 = get_person_by_handle(db_handle, handle2) if person2 is None: abort(404) calc = RelationshipCalculator() if "depth" in args: calc.set_depth(args["depth"]) if "all" in args and args["all"]: data = calc.get_all_relationships(db_handle, person1, person2) index = 0 result = [] while index < len(data[0]): result.append({ "relationship_string": data[0][index], "common_ancestors": data[1][index], }) index = index + 1 return self.response(200, result) data = calc.get_one_relationship(db_handle, person1, person2, extra_info=True) return self.response( 200, { "relationship_string": data[0], "distance_common_origin": data[1], "distance_common_other": data[2], }, )
class EventInfoSchema(Schema): title = fields.String(required=True) url = fields.URL(schemes={"http", "https"}, required=True) can_disconnect = fields.Boolean(required=True, default=True) service = fields.Nested( { "version": fields.String(), "name": fields.String() }, required=True, default=SERVICE_INFO, )
class UserConfigAutoArchiveController(Resource): put_body = {"auto_archive": fields.Boolean(data_key="autoArchive", required=True)} @jwt.requires_auth @use_args(put_body, location="json") def put(self, put_args): """Update user config option for gmail_auto_archive""" do_auto_archive = put_args["auto_archive"] user_config = user_manager.set_auto_archive_config(g.user, do_auto_archive) user_manager.commit_changes() if user_config: return responses.success(user_config.to_json()) return responses.error("Something went wrong")
def search_args(): """Defines and validates params for index""" return { "search": fields.String(missing=None), "team_id": fields.UUID(missing=None), "types": fields.String(load_from="type", missing="image"), "pipeline": fields.Integer(), "start_date": fields.DateTime(), "end_date": fields.DateTime(), "offset": fields.Integer(missing=0), "limit": fields.Integer(missing=12), "notify_clients": fields.Boolean(missing=False), }
def build_schema(self, model): # Get the full list of parent classes from model to object classes = inspect.getmro(model) starting_point = False # Iterate in reversed order to start from object for c in reversed(classes): # Skip all parentes up to StructuredNode and StructuredRel (included) if not starting_point: # Found the starting point, next class will be descended up to model if c == StructuredNode or c == StructuredRel: starting_point = True # skip all parent up to StructuredNode and StructuredRel INCLUDED continue # Iterate all class attributes to find neomodel properties for attribute in c.__dict__: prop = getattr(c, attribute) if not isinstance(prop, properties.Property): continue # self.fields can be None when the special value * is given in input if self.fields and attribute not in self.fields: continue # log.info("Including property {}.{}", model.__name__, attribute) if isinstance(prop, properties.StringProperty): if prop.choices is None: self.declared_fields[attribute] = fields.Str() else: self.declared_fields[attribute] = Neo4jChoice( prop.choices) elif isinstance(prop, properties.BooleanProperty): self.declared_fields[attribute] = fields.Boolean() elif isinstance(prop, properties.IntegerProperty): self.declared_fields[attribute] = fields.Integer() elif isinstance(prop, properties.EmailProperty): self.declared_fields[attribute] = fields.Email() elif isinstance(prop, properties.DateTimeProperty): self.declared_fields[attribute] = fields.AwareDateTime() elif isinstance(prop, properties.UniqueIdProperty): self.declared_fields[attribute] = fields.Str() else: # pragma: no cover log.error( "Unsupport neomodel property: {}, fallback to StringProperty", prop.__class__.__name__, ) self.declared_fields[attribute] = fields.Str()
class DefaultTypeResource(ProtectedResource, GrampsJSONEncoder): """Default type resource.""" @use_args( { "locale": fields.Boolean(missing=False), }, location="query", ) def get(self, args: Dict, datatype: str) -> Response: """Return a list of values for a default type.""" result = get_default_types(datatype, args["locale"]) if result is None: abort(404) return self.response(200, result)
class TachographGenerationScopeSchema(Schema): company_ids = fields.List(fields.Int(), required=True, validate=lambda l: len(l) > 0) user_ids = fields.List(fields.Int(), required=False) min_date = fields.Date(required=True) max_date = fields.Date(required=True) with_digital_signatures = fields.Boolean(required=False) @validates_schema def check_period_is_small_enough(self, data, **kwargs): if data["max_date"] - data["min_date"] > timedelta(days=60): raise ValidationError( "The requested period should be less than 60 days")
class DefaultTypesResource(ProtectedResource, GrampsJSONEncoder): """Default types resource.""" @use_args( { "locale": fields.Boolean(missing=False), }, location="query", ) def get(self, args: Dict) -> Response: """Return a list of available default types.""" result = {} for datatype in _DEFAULT_RECORD_TYPES: result.update( {datatype: get_default_types(datatype, args["locale"])}) return self.response(200, result)