def post(self, request, app_name, env_name, app_path): action = request.data['action'] if action == 'rename': env_path = _get_existent_env_path(app_path, env_name) new_env_name = request.data['name'] check_name(new_env_name) new_env_path = _get_absent_env_path(app_path, new_env_name) stop_patsaks(get_id(request.dev_name, app_name, env_name)) write_file(new_env_path, new_env_name) schema_prefix = get_id(request.dev_name, app_name) + ':' execute_sql( 'SELECT ak.rename_schema(%s, %s)', (schema_prefix + env_name.lower(), schema_prefix + new_env_name.lower())) os.remove(env_path) return HttpResponse() if action == 'eval': request.lock.release() request.lock = None if env_name == _RELEASE_ENV_NAME: env_name = None response = send_to_ecilop( 'EVAL ' + get_id(request.dev_name, app_name, env_name), request.data['expr']) assert response status = response[0] result = response[1:] assert status in ('E', 'F', 'S') if status == 'E': raise Error(result, status=NOT_FOUND) return {'ok': status == 'S', 'result': result} raise Error('Unknown action: "%s"' % action)
def post(self, request, app_name, env_name, app_path): action = request.data['action'] if action == 'rename': env_path = _get_existent_env_path(app_path, env_name) new_env_name = request.data['name'] check_name(new_env_name) new_env_path = _get_absent_env_path(app_path, new_env_name) stop_patsaks(get_id(request.dev_name, app_name, env_name)) write_file(new_env_path, new_env_name) schema_prefix = get_id(request.dev_name, app_name) + ':' execute_sql('SELECT ak.rename_schema(%s, %s)', (schema_prefix + env_name.lower(), schema_prefix + new_env_name.lower())) os.remove(env_path) return HttpResponse() if action == 'eval': request.lock.release() request.lock = None if env_name == _RELEASE_ENV_NAME: env_name = None response = send_to_ecilop( 'EVAL ' + get_id(request.dev_name, app_name, env_name), request.data['expr']) assert response status = response[0] result = response[1:] assert status in ('E', 'F', 'S') if status == 'E': raise Error(result, status=NOT_FOUND) return {'ok': status == 'S', 'result': result} raise Error('Unknown action: "%s"' % action)
def __init__(self, node, tree): """ Constructor Keyword arguments: node -- XML node defining this event tree -- currently evaluted communication structure tree Resets the 'abstract' flag for every component beeing contained here. """ self.name = node.get('name') utils.check_name(self.name) bootloader = node.find('bootloader') if bootloader != None: bootloader = bootloader.attrib self.bootloader = bootloader self.description = xml_utils.get_description(node) self.components = utils.SingleAssignDictionary("component") self.events = EventContainer() self.subscriptions = {} self.indexReady = False for node in node.findall('component'): component_name = node.get('name') try: component = tree.components[component_name] component.abstract = False self.components[component_name] = component except KeyError: raise ParserException("Unknown component '%s' in container '%s'." % (component_name, self.name))
def __init__(self, node, tree): """ Constructor Keyword arguments: node -- XML node defining this event tree -- currently evaluted communication structure tree Resets the 'abstract' flag for every component beeing contained here. """ self.name = node.get('name') utils.check_name(self.name) bootloader = node.find('bootloader') if bootloader != None: bootloader = bootloader.attrib self.bootloader = bootloader self.description = xml_utils.get_description(node) self.components = utils.SingleAssignDictionary("component") self.events = EventContainer() self.subscriptions = {} self.indexReady = False for node in node.findall('component'): component_name = node.get('name') try: component = tree.components[component_name] component.abstract = False self.components[component_name] = component except KeyError: raise ParserException( "Unknown component '%s' in container '%s'." % (component_name, self.name))
def post(self, request, app_name, app_path): env_name = request.data['name'] check_name(env_name) env_path = _get_absent_env_path(app_path, env_name) execute_sql(CREATE_SCHEMA_SQL, (get_id(request.dev_name, app_name, env_name), )) write_file(env_path, env_name) return HttpResponse(status=CREATED)
def post(self, request, app_name, app_path): env_name = request.data['name'] check_name(env_name) env_path = _get_absent_env_path(app_path, env_name) execute_sql( CREATE_SCHEMA_SQL, (get_id(request.dev_name, app_name, env_name),)) write_file(env_path, env_name) return HttpResponse(status=CREATED)
def __init__(self, node, tree): self.name = node.get('name') utils.check_name(self.name) self.description = xml_utils.get_description(node) self.id = xml_utils.get_identifier(node) self.parameterType = self.__get_type(node, "parameterType", tree) self.returnType = self.__get_type(node, "returnType", tree)
def __init__(self, node): self.node = node self.name = node.get('name') utils.check_name(self.name) self.description = None self.id = None self.extends = None self.abstract = True self.__flattened = None self.actions = utils.SingleAssignDictionary("action") self.events = EventContainer()
def role_create(auth_info, **kwargs): if auth_info['code'] == 1: return json.dumps(auth_info) username = auth_info['username'] if '1' not in auth_info['r_id']: return json.dumps({'code': 1, 'errmsg': 'you not admin,no power'}) try: data = request.get_json()['params'] if not data.has_key('p_id'): return json.dumps({'code': 1, 'errmsg': 'must hava p_id'}) if not app.config['cursor'].if_id_exist('power', data['p_id'].split(',')): return json.dumps({'code': 1, 'errmsg': 'p_id not exist'}) if not utils.check_name(data['name']): return json.dumps({ 'code': 1, 'errmsg': 'name must be string or int' }) app.config['cursor'].execute_insert_sql('role', data) utils.write_log('api').info(username, "create role %s scucess" % data['name']) return json.dumps({ 'code': 0, 'result': 'create role %s scucess' % data['name'] }) except: utils.write_log('api').error( username, "create role error: %s" % traceback.format_exc()) return json.dumps({'code': 1, 'errmsg': 'create role fail'})
def register(): """ Attempts to register the user with the given account information. """ name = request.form['name'] email = request.form['email'] password = request.form['password'] repassword = request.form['repassword'] name_error = check_name(name) if name_error != None: # malformed name return jsonify({'type': 'error', 'error': name_error}) email_error = check_email(email) if email_error != None: # malformed e-mail return jsonify({'type': 'error', 'error': email_error}) password_error = check_password(password, repassword) if password_error != None: # malformed password return jsonify({'type': 'error', 'error': password_error}) user_exists = db.user_exists(email) if user_exists: # user with this e-mail already exists error = 'An account with this e-mail address already exists!' return jsonify({'type': 'error', 'error': error}) user = db.make_user(name, email, password) flash('Welcome to Bookmark+, %s!' % user.name) session['user_id'] = unicode(user._id) return jsonify({'type': 'success', 'url': url_for('home')})
def createuser(auth_info,*arg,**kwargs): if auth_info['code'] == 1: return json.dumps(auth_info) username = auth_info['username'] r_id = auth_info['r_id'] #string, eg: '1,2,3' if '1' not in r_id: #角色id = 1 为sa组,超级管理员 return json.dumps({'code': 1,'errmsg':'you not admin,no power' }) try: data = request.get_json()['params'] #api端对传入端参数验证 if 'r_id' not in data: return json.dumps({'code': 1, 'errmsg': "must need a role!"}) if not app.config['cursor'].if_id_exist('role',data['r_id'].split(',')): return json.dumps({'code': 1, 'errmsg': "Role not exist!"}) if not utils.check_name(data['username']): return json.dumps({'code': 1, 'errmsg': "username must be string or num!"}) if data['password'] != data['repwd']: return json.dumps({'code': 1, 'errmsg': "password equal repwd!"}) elif len(data['password']) < 6: return json.dumps({'code': 1, 'errmsg': 'passwd must over 6 string !'}) else: data.pop('repwd') #传入的第二次密码字段不存在,需要删除 data['password'] = hashlib.md5(data['password']).hexdigest() data['join_date'] = time.strftime('%Y-%m-%d %H:%M:%S') app.config['cursor'].execute_insert_sql('user', data) utils.write_log('api').info(username, "create_user %s" % data['username']) return json.dumps({'code': 0, 'result': 'create user %s success' % data['username']}) except: utils.write_log('api').error("Create user error: %s" % traceback.format_exc()) return json.dumps({'code': 1, 'errmsg': 'Create user failed'})
def post(self, request): dev_name = request.data['name'] check_name(dev_name) if dev_name.startswith(ANONYM_PREFIX): raise Error( 'Names starting with "%s" are reserved.' % ANONYM_PREFIX, 'Please choose another name.') try: user = User.objects.get(username__iexact=dev_name) except User.DoesNotExist: pass else: raise Error( 'The user "%s" already exists.' % user.username, 'Name must be be case-insensitively unique.') email = request.data['email'] try: validate_email(email) except ValidationError: raise Error('The email "%s" is incorrect.' % email, 'Please correct the email.') if User.objects.filter(email=email): raise Error( 'The email "%s" has already been taken.' % email, 'Please choose another email.') user = User.objects.create_user( dev_name, email, request.data['password']) user.save() if request.is_half_anonymous: _stop_dev_patsaks(request.dev_name) old_dev_path = ROOT.devs[request.dev_name] dev_path = ROOT.devs[dev_name] os.rename(old_dev_path, dev_path) os.mkdir(old_dev_path) os.symlink(dev_path.tablespace, old_dev_path.tablespace) os.rename( dev_path.grantors[request.dev_name], dev_path.grantors[dev_name]) os.rename(ROOT.locks[request.dev_name], ROOT.locks[dev_name]) execute_sql( 'SELECT ak.rename_dev(%s, %s)', (request.dev_name, dev_name.lower())) else: create_dev(dev_name) user.backend = AUTHENTICATION_BACKENDS[0] auth.login(request, user) return HttpResponse(status=CREATED)
def __call__(self, form, field): length = field.data and len(field.data) or 0 if length == 0: pass elif check_name(field.data): pass else: raise ValidationError(self.message)
def post(self, request, project): serializer = TestcaseSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: case_name = serializer.validated_data['name'] case_type = serializer.validated_data['type'] case_description = serializer.validated_data['description'] case_script_path = serializer.validated_data['script_path'] case_config_path = serializer.validated_data['config_path'] case_parameters = serializer.validated_data['parameters'] case_feature = serializer.validated_data['feature'] suite_list = serializer.validated_data['testsuite'] except KeyError: return Response({'detail': unicode("The lack of required parameters.")}, status=status.HTTP_400_BAD_REQUEST) perf = serializer.validated_data.get('performance', False) app = serializer.validated_data.get('app', None) if perf and not app: return Response({'detail': unicode("parameter app must provide when performance=True")}, status=status.HTTP_400_BAD_REQUEST) if not perf and app: return Response({'detail': unicode("parameter app can not be set when performance=False")}, status=status.HTTP_400_BAD_REQUEST) if not check_name(TestCase, case_name, project, check_flag=True): return Response({'detail': unicode("Found same name testcase, " "please check your testcase name.")}, status=status.HTTP_409_CONFLICT) for suite in suite_list: if suite.performance != perf or suite.app != app: return Response({'detail': unicode("suite:{0} not match test case of " "performance type".format(suite.id))}, status=status.HTTP_409_CONFLICT) new_case = TestCase.objects.create( name=case_name, type=case_type, description=case_description, script_path=case_script_path, config_path=case_config_path, parameters=case_parameters, feature=case_feature, performance=perf, app=app, project=get_project_object(project) ) for suite in suite_list: new_case.testsuite.add(suite) new_case.save() new_serializer = TestcaseSerializer(new_case) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request): dev_name = request.data['name'] check_name(dev_name) if dev_name.startswith(ANONYM_PREFIX): raise Error( 'Names starting with "%s" are reserved.' % ANONYM_PREFIX, 'Please choose another name.') try: user = User.objects.get(username__iexact=dev_name) except User.DoesNotExist: pass else: raise Error('The user "%s" already exists.' % user.username, 'Name must be be case-insensitively unique.') email = request.data['email'] try: validate_email(email) except ValidationError: raise Error('The email "%s" is incorrect.' % email, 'Please correct the email.') if User.objects.filter(email=email): raise Error('The email "%s" has already been taken.' % email, 'Please choose another email.') user = User.objects.create_user(dev_name, email, request.data['password']) user.save() if request.is_half_anonymous: _stop_dev_patsaks(request.dev_name) old_dev_path = ROOT.devs[request.dev_name] dev_path = ROOT.devs[dev_name] os.rename(old_dev_path, dev_path) os.mkdir(old_dev_path) os.symlink(dev_path.tablespace, old_dev_path.tablespace) os.rename(dev_path.grantors[request.dev_name], dev_path.grantors[dev_name]) os.rename(ROOT.locks[request.dev_name], ROOT.locks[dev_name]) execute_sql('SELECT ak.rename_dev(%s, %s)', (request.dev_name, dev_name.lower())) else: create_dev(dev_name) user.backend = AUTHENTICATION_BACKENDS[0] auth.login(request, user) return HttpResponse(status=CREATED)
def deleteAddressbooks(name): resultCheckName = utils.check_name(name) if resultCheckName[0]: return resultCheckName dbResult= db.deletePerson(name) if not dbResult[0]: return response_error(dbResult[1],400) return response_success(name+" is deleted",204)
def __init__(self, node, tree): """ Constructor Keyword arguments: node -- XML node defining this event tree -- currently evaluted communication structure tree """ self.name = node.get('name') utils.check_name(self.name) self.id = xml_utils.get_identifier(node) self.description = xml_utils.get_description(node) self.rate = node.get('rate') type = node.get('type') if type is None: self.type = None else: try: self.type = tree.types[type] except KeyError as e: raise ParserException("Type '%s' is not defined. Used by Event '%s')" % (type, self.name))
def create(auth_info, **kwargs): username = auth_info['username'] if '1' not in auth_info['r_id'] return json.dumps({'code':1, 'errmsg':'you are not admin, no power'}) try: data = request.get_json()['params'] if not utils.check_name(data['name']) return json.dumps({'code':1, 'errmsg':'name must be stirng or num'}) app.config['db'].execute_insert_sql('power', data) utils.write_log('api').info('%s create power %s success' % (username, data['name'])) return json.dumps({'code':0 , 'result': '%s create %s success' % (username, data[name]})) except: utils.write_log('api').error('create power error' % traceback.format_exec()) return json.dumps({'code':1 , 'errmsg': 'create power failed' })
def __init__(self, node, tree): """ Constructor Keyword arguments: node -- XML node defining this event tree -- currently evaluted communication structure tree """ self.name = node.get('name') utils.check_name(self.name) self.id = xml_utils.get_identifier(node) self.description = xml_utils.get_description(node) self.rate = node.get('rate') type = node.get('type') if type is None: self.type = None else: try: self.type = tree.types[type] except KeyError as e: raise ParserException( "Type '%s' is not defined. Used by Event '%s')" % (type, self.name))
def post(self, request, project): serializer = TestexecutionOsSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) os_name = serializer.data['name'] if not check_name(OS, os_name, project): return Response({'detail': unicode("Found same name OS, please check your OS name.")}, status=status.HTTP_409_CONFLICT) new_os = OS.objects.create(name=os_name, project=get_project_object(project)) new_os.save() new_serializer = TestexecutionOsSerializer(new_os) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = TestexecutionPlatformSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) platform_name = serializer.data['name'] if not check_name(Platform, platform_name, project): return Response({'detail': unicode("Found same name platform, please check your platform name.")}, status=status.HTTP_409_CONFLICT) new_platform = Platform.objects.create(name=platform_name, project=get_project_object(project)) new_platform.save() new_serializer = TestexecutionPlatformSerializer(new_platform) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = TestsuiteSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: suite_name = serializer.validated_data['name'] suite_subsystem = serializer.validated_data['subsystem'] suite_description = serializer.validated_data['description'] plan_list = serializer.validated_data['testplan'] except KeyError: return Response({'detail': unicode("The lack of required parameters.")}, status=status.HTTP_400_BAD_REQUEST) perf = serializer.validated_data.get('performance', False) app = serializer.validated_data.get('app', None) if perf and not app: return Response({'detail': unicode("parameter app must provide when performance=True")}, status=status.HTTP_400_BAD_REQUEST) if not perf and app: return Response({'detail': unicode("parameter app can not be set when performance=False")}, status=status.HTTP_400_BAD_REQUEST) if not check_name(TestSuite, suite_name, project, check_flag=True): return Response({'detail': unicode("Found same name testsuite, " "please check your testsuite name.")}, status=status.HTTP_409_CONFLICT) for plan in plan_list: if plan.performance != perf or plan.app != app: return Response({'detail': unicode("plan:{0} not match test suite of " "performance type".format(plan.id))}, status=status.HTTP_409_CONFLICT) new_suite = TestSuite.objects.create( name=suite_name, subsystem=suite_subsystem, performance=perf, app=app, description=suite_description, project=get_project_object(project) ) for plan in plan_list: new_suite.testplan.add(plan) new_suite.save() new_serializer = TestsuiteSerializer(new_suite) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = TestcaseTypeSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) type_name = serializer.data['name'] if not check_name(TestCaseType, type_name, project): return Response({'detail': unicode("Found same name type, please check your type name.")}, status=status.HTTP_409_CONFLICT) new_type = TestCaseType.objects.create( name=type_name, project=get_project_object(project) ) new_serializer = TestcaseTypeSerializer(new_type) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = TestsuiteSubsystemSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) subsystem_name = serializer.data['name'] if not check_name(Subsystem, subsystem_name, project): return Response({'detail': unicode("Found same name subsystem, " "please check your subsystem name.")}, status=status.HTTP_409_CONFLICT) new_subsystem = Subsystem.objects.create( name=subsystem_name, project=get_project_object(project) ) new_serializer = TestsuiteSubsystemSerializer(new_subsystem) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def create(**kwargs): try: data = request.get_json()['params'] if not utils.check_name(data['name']): return json.dumps({ 'code': 1, 'errmsg': 'name must be string or num' }) app.config['cursor'].execute_insert_sql('power', data) utils.write_log('api').info(username, "create power %s sucess" % data['name']) return json.dumps({ 'code': 0, 'result': 'create %s sucess' % data['name'] }) except Exception, e: utils.write_log('api').error('create power error:%s' % traceback.format_exc()) return json.dumps({'code': 1, 'errmsg': 'create power failed'})
def role_create(auth_info, **kwargs): if auth_info['code'] == 1: return json.dumps(auth_info) username = auth_info['username'] if '1' not in auth_info['r_id'] return json.dumps({'code':1, 'errmsg': 'you are not admin, no power'}) try: data = request.get_json()['params'] if not data.has_key('p_id'): return json.dumps({"code":1, "errmsg":"must have a p_id!"}) if not app.config['db'].if_id_exist("power",data['p_id'].split(',')): return json.dumps({"code":1, "errmsg":"p_id not exist!"}) if not utils.check_name(data['username']): return json.dumps({"code":1, "errmsg":"username must be string or num!"}) app.config['db'].execute_insert_sql('role', data) utils.write_log('api').info('%s create role %s success' % (username, data['name'])) return json.dumps({'code':0 , 'result': '%s create role %s success' % (username, data[name]})) except: utils.write_log('api').error('create role error' % traceback.format_exec()) return json.dumps({'code':1 , 'errmsg': 'create role failed' })
def post(self, request, project): serializer = AppSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) app_name = serializer.data['name'] if not check_name(App, app_name, project): return Response( { 'detail': unicode("Found same name app, please check your app name.") }, status=status.HTTP_409_CONFLICT) new_app = App.objects.create(name=app_name, project=get_project_object(project)) new_app.save() new_serializer = AppSerializer(new_app) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = TestPlanCategorySerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) category_name = serializer.data['name'] if not check_name(Category, category_name, project): return Response( { 'detail': unicode("Found same name category, " "please check your category name.") }, status=status.HTTP_409_CONFLICT) new_category = Category.objects.create( name=category_name, project=get_project_object(project)) new_serializer = TestPlanCategorySerializer(new_category) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): auth_status, message = check_auth(request.user, project, 'writer') if not auth_status: return Response(message, status=status.HTTP_401_UNAUTHORIZED) serializer = FeatureSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: fea_name = serializer.data['name'] fea_owner = serializer.data['owner'] fea_component = serializer.data['component'] fea_requirement = serializer.data['requirement'] fea_description = serializer.data['description'] except KeyError: return Response({'detail': unicode("The lack of required parameters.")}, status=status.HTTP_400_BAD_REQUEST) if not check_name(Feature, fea_name, project): return Response({'detail': unicode("Found same name feature, " "please check your feature name.")}, status=status.HTTP_409_CONFLICT) if not check_owner_runner(request.user, fea_owner): return Response({'detail': unicode("The owner should be current user - {0}".format(request.user))}, status=status.HTTP_400_BAD_REQUEST) new_fea = Feature.objects.create( name=fea_name, owner=fea_owner, component_id=fea_component, requirement_id=fea_requirement, description=fea_description, project=get_project_object(project) ) new_serializer = FeatureSerializer(new_fea) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): auth_status, message = check_auth(request.user, project, 'writer') if not auth_status: return Response(message, status=status.HTTP_401_UNAUTHORIZED) serializer = FeatureComponentSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) component_name = serializer.data['name'] if not check_name(Component, component_name, project): return Response({'detail': unicode("Found same name componet, " "please check your componet name.")}, status=status.HTTP_409_CONFLICT) new_component = Component.objects.create( name=component_name, project=get_project_object(project) ) new_serializer = FeatureComponentSerializer(new_component) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def create(auth_info, *arg, **kwargs): if auth_info['code'] == 1: return json.dumps(auth_info) username = auth_info['username'] if '1' not in auth_info['r_id']: return json.dumps({'code': 1, 'errmsg': 'you not admin,no power'}) try: data = request.get_json()['params'] if not utils.check_name(data['name']): return json.dumps({ 'code': 1, 'errmsg': 'name must be string or num' }) app.config['cursor'].execute_insert_sql('power', data) utils.write_log('api').info(username, "create power %s success" % data['name']) return json.dumps({ 'code': 0, 'result': 'create %s success' % data['name'] }) except: utils.write_log('api').error('create power error:%s' % traceback.format_exc()) return json.dumps({'code': 1, 'errmsg': 'create power failed'})
def post(self, request): app_name = request.data['name'] check_name(app_name) create_app(request.dev_name, app_name) return HttpResponse(status=CREATED)
def test_check_name(self): assert check_name('') is not None assert check_name('# @') is not None assert check_name('Ben Bitdiddle') is None assert check_name('Ben 22 Bitdiddle') is None
else: model = UNet(1 + (e2d*2), 1, residual=res, small=small, bias=bias, bn=bn) if model_folder is not None: path = glob.glob(os.path.join(model_folder, "*" + o + ".pt"))[0] model.load_state_dict(torch.load(path)) models[o] = model return models results = {} for basename in bnames: print(basename) model_folder = os.path.join(basepath, basename) print("Save point: {}".format(model_folder)) bias = not check_name("nobias", basename) e2d = check_name("E2D", basename) res = check_name("RES", basename) small = check_name("SMALL", basename) adam = check_name("ADAM", basename) bn = not check_name("NOBN", basename) dunet = check_name("DUNET", basename) mixed = check_name("MIXED", basename) # Main volumetric performance test if volume: print("Calculating performance in volume") if db_name == "cc359":
def save_doc_photo_end(bot, update): Bot.get_file(Bot(TG_TOKEN), bot.message.photo[0].file_id).download( os.path.join(FILES_PATH, check_name('new.jpg'))) bot.message.reply_text('Ваше фото сохранено', reply_markup=get_keyboard()) return ConversationHandler.END
def save_doc_document_end(bot, update): Bot.get_file(Bot(TG_TOKEN), bot.message.document.file_id).download( os.path.join(FILES_PATH, check_name(bot.message.document.file_name))) bot.message.reply_text('Ваш документ сохранен', reply_markup=get_keyboard()) return ConversationHandler.END
def _check_name(self): utils.check_name(self.name)