def test_get_user():
"""Test get_user fanction with valid data"""
app = create_app("flask_test.cfg")
with app.app_context():
with patch("requests.get") as MockTask:
MockTask.return_value.raise_for_status = Mock()
MockTask.return_value.json.return_value = {
"results": [
{
"gender": "male",
"name": {"title": "Mr", "first": "Felix", "last": "Hansen"},
"location": {
"street": {"number": 5177, "name": "Hyldevej"},
"city": "Gørløse",
"country": "Denmark",
},
"email": "*****@*****.**",
"cell": "29130618",
"picture": {
"large": "https://randomuser.me/api/portraits/men/76.jpg",
"medium": "https://randomuser.me/api/portraits/med/men/76.jpg",
"thumbnail": "https://randomuser.me/api/portraits/thumb/men/76.jpg",
},
}
]
}
assert isinstance(get_user(1), list)
def reclassify_photos():
'''
Для каждой неотклассифицированной фотографии запускает отдельную задачу классификации
'''
logger.info('Task 3: reclassify_photos')
app = create_app()
with app.app_context():
current_cnn_version = get_current_cnn_version()
photos = db.session.query(Photos.id.label('id'), StorageUsers.id.label('id_storage')) \
.join(Folders) \
.join(StorageUsers) \
.filter(StorageUsers.storage_id == 1).all()
for photo in photos:
logger.info('Проверяем картинку с id: %s, id_storage: %s' %
(photo.id, photo.id_storage))
c_q = db.session.query(func.count(photosclasses.c.alg_id)) \
.select_from(photosclasses) \
.filter(photosclasses.c.photo_id == photo.id) \
.filter(photosclasses.c.alg_id == current_cnn_version) \
.group_by(photosclasses.c.alg_id)
cnt = db.session.execute(c_q).scalar()
if cnt is None or cnt == 0:
logger.info('Отправляем на классификацию картинку с id: %s' %
photo.id)
get_class.delay(photo.id, photo.id_storage)
def dbdowngrade(configkey, version=None):
"""
Resets / upgrades / downgrades DB (up / down to some version).
"""
dbapp = create_app(configkey)
logger.debug("Going to downgrade %s", dbapp.config.__class__)
dbapp.db.downgradedb(dbapp.config, version)
def __init__(self):
cur_path = os.path.dirname(os.path.abspath(__file__))
self.app = webapp.create_app()
self.app.debug = True
self.port = get_config().getint("setup", "listen_port")
self.pidfile = os.path.join(cur_path, "..", get_config().get("setup", "pidpath"))
Daemon.__init__(self, self.pidfile)
def db():
app = create_app('testing')
DBAdmin.resetdb(app.config)
DBAdmin.create_table_changelog(app.config)
DBAdmin.upgradedb(app.config, None)
DBAdmin.insert_initial_data(app)
return app.db
def setUp(self):
# Bug workarounds: Flask Admin和Flask Restful扩展中，
# 它们会为应用生成蓝图对象并在内部保存起来，但在应用销毁时不会主动将其移除。
admin._views = []
rest_api.resources = []
self.app = create_app('test')
# 必须push context，否则会报错误
self.app_context = self.app.app_context()
self.app_context.push()
self.client = self.app.test_client(use_cookies=True)
# Bug workaround: 如果不在webapp目录中运行，
# 则Flask SQLAlchemy的初始化代码就不能正确地在应用对象中进行初始化
db.app = self.app
db.create_all()
# create role and user
# 由于下面有个test_register_and_login测试，要注册新用户，
# 在register路由中会默认添加上'poster'和'default'角色，因此这里要先创建两种角色
poster = Role('poster')
poster.description = 'poster role'
default = Role('default')
default.description = 'default role'
db.session.add(poster)
db.session.add(default)
test_user = User('test')
test_user.email = '*****@*****.**'
test_user.password = '******'
test_user.confirmed = True
test_user.roles.append(poster)
db.session.add(test_user)
db.session.commit()
def setUp(self):
admin._views = []
rest_api.resources = []
app = create_app('webapp.config.TestConfig')
self.client = app.test_client()
db.app = app
db.create_all()
def send(filenames, conf):
app = create_app(filenames)
app.config.update(conf)
http_server = serve(app)
address, port = http_server.address
announce(address, port)
gevent.wait(count=1)
def setUp(self):
app = create_app('webapp.config.TestConfig')
self.client = app.test_client()
# Bug workaround
db.app = app
db.create_all()
def test_test_config(self):
""" Tests if the test config loads correctly """
app = create_app('webapp.settings.TestConfig')
assert app.config['DEBUG'] is True
assert app.config['SQLALCHEMY_ECHO'] is True
assert app.config['CACHE_TYPE'] == 'null'
def setup_class(cls):
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
if cls.app.db.conn is not None:
cls.app.db.conn.close()
cls.app.db.createdb(cls.app.config)
def test_prod_config(self):
""" Tests if the production config loads correctly """
app = create_app('webapp.settings.ProdConfig')
assert app.config[
'SQLALCHEMY_DATABASE_URI'] == 'sqlite:///../database.db'
assert app.config['CACHE_TYPE'] == 'simple'
def setUp(self) -> None:
admin._views = []
rest_api._resources = []
app = create_app('config.TestConfig')
self.client = app.test_client()
db.app = app
db.create_all()
def setUp(self):
admin._views = []
rest_api.resources = []
app = create_app("config.TestConfig")
self.client = app.test_client()
db.app = app
db.create_all()
def app():
app = create_app({
'TESTING': True,
'WTF_CSRF_SECRET_KEY': 'Testing secret key',
'SECRET_KEY': 'Testing secret key'
})
yield app
def choose_run_type(cmd_args):
"""
function to help determine which type of function to use
"""
if cmd_args.postgresql:
# create app and db
app, db = create_app(app_type="PROD")
# return app and db
return app, db
else:
# create app and db
app, db = create_app(app_type="TEST", verify_ask=False)
# create tables
db.create_all()
# load test data
curr_f_name = "Jon"
curr_l_name = "Snow"
curr_procedure = "ileostomy"
curr_bday = datetime.strptime("1990-10-10", "%Y-%m-%d")
# define test objects
usr = User(
curr_f_name,
curr_l_name,
curr_bday,
curr_procedure,
)
# add user and commit
db.session.add(usr)
db.session.commit()
# read in fixtures
path = "resources/application_settings.yaml"
with open(path, "r") as f:
data = yaml.load(f)
# add data to database
add_and_commit_fixtures(data, db)
# return app and db
return app, db
def init_manager(config=None):
global manager
global app
app = create_app(config)
manager = Manager(app)
project_root_path = os.path.join(os.path.dirname(app.root_path))
manager.add_command('run', RunServer())
manager.add_command('debug', DebugServer())
manager.add_command('reset', Reset())
def setup_class(cls):
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
if cls.app.db.conn is not None:
cls.app.db.conn.close()
cls.admin_conn = cls.app.db.connectdb(
cls.app.config['DB_CONN_URI_ADMIN'])
cls.app.db.createdb(cls.app.config)
def test_dev_config(self):
""" Tests if the development config loads correctly """
app = create_app('webapp.settings.DevConfig')
assert app.config['DEBUG'] is True
assert app.config[
'SQLALCHEMY_DATABASE_URI'] == 'sqlite:///../database.db'
assert app.config['CACHE_TYPE'] == 'null'
def main():
"""
Example for literal string interpolation (f-string)
"""
opts = parseargs()
print("Configuration key: {}".format(opts.configkey))
app = create_app(opts.configkey)
migratedb(app)
casepath = os.path.join(app.confg['BASEDIR'], 'tests', opts.testcase)
pytest.main(['-x', '-v', casepath])
def setUp(self):
"""
Create temp application and database in memory for tests
"""
app = create_app("config.TestConfig")
app.config["WTF_CSRF_ENABLED"] = False
self.client = app.test_client()
db.app = app
db.create_all()
self.app = app
def app():
test_app = create_app(env='testing')
with test_app.app_context():
db.create_all()
yield test_app
db.session.remove()
db.drop_all()
def bypass_storages():
'''
Для каждого хранилища запускаем отдельную задачу синхронизации
'''
logger.info('Task 1: bypass storages')
app = create_app()
with app.app_context():
for storage in StorageUsers.query.all():
sync_file_list.delay(storage.id)
def setUp(self):
admin._views = []
self.app = create_app('config.TestingConfig')
self.app_context = self.app.app_context()
self.app_context.push()
self.client = self.app.test_client()
#db.app = app
db.create_all()
Clinic.insert_clinic()
Role.insert_roles()
User.insert_users()
def main():
# create app and db
app, db = create_app(app_type="MIGRATION")
# read in fixtures
path = "resources/application_settings.yaml"
with open(path, "r") as f:
data = yaml.load(f)
# call function to add and commit data
add_and_commit_fixtures(data, db)
def app(request):
"""Session-wide test `Flask` application."""
app = create_app("config.TestConfig")
with app.app_context() as ctx:
ctx.push()
def teardown():
ctx.pop()
request.addfinalizer(teardown)
return app
def setup_app():
# need to freeze time so that time specific functional tests are not flaky
world.freezer = freeze_time("2015-03-14 09:26:53")
world.freezer.start()
world.now = get_utcnow()
# start responses mock
world.responses_mock = responses.RequestsMock()
world.responses_mock.start()
# create a test client app
world.app = create_app('test')
world.app.logger.setLevel(logging.ERROR)
logging.getLogger("CSSUTILS").setLevel(logging.ERROR)
def setUp(self):
# Bug workarounds
admin._views = []
rest_api.resources = []
app = create_app('webapp.config.TestConfig')
self.client = app.test_client()
# Bug workaround
db.app = app
db.create_all()
def setUp(self):
# type: () -> None
self._storage_path = tempfile.mkdtemp()
self.mock_env = mock.patch.dict(os.environ, {
'STORAGE_PATH': self._storage_path,
})
self.mock_env.start()
self.app = webapp.create_app() # type: flask.Flask
self.app_context = self.app.test_request_context(
) # type: flask.ctx.RequestContext
self.app_context.push()
self.client = self.app.test_client() # type: flask.testing.FlaskClient
def create_app(self):
app = create_app('webapp.config.TestConfig')
self.client = app.test_client()
app.config['WTF_CSRF_ENABLED'] = False
# Bug workaround
db.app = app
db.create_all()
return app
def setUp(self):
admin._views = []
rest_api.resources = []
app = create_app('test')
self.client = app.test_client()
# 弥补 bug 的方法
db.app = app
db.create_all()
def test_client():
flask_app = create_app()
flask_app.config.from_pyfile('../tests/flask_test.py')
testing_client = flask_app.test_client()
ctx = flask_app.app_context()
ctx.push()
yield testing_client
ctx.pop()
def setUp(self):
# Bug workarounds: Flask Admin和Flask Restful扩展中，
# 它们会为应用生成蓝图对象并在内部保存起来，但在应用销毁时不会主动将其移除。
admin._views = []
rest_api.resources = []
self.app = create_app('test')
self.app_context = self.app.app_context()
self.app_context.push()
# Bug workaround: 如果不在webapp目录中运行，
# 则Flask SQLAlchemy的初始化代码就不能正确地在应用对象中进行初始化
db.app = self.app
db.create_all()
def init_services(self):
# General Services
self.logger = LoggingService()
self.file_service = FileService(self.logger)
# Drive Services
distance_config = DistanceConfig()
self.distance_service = DistanceService(distance_config, self.logger)
# will need distance service eventually
motor_config = MotorConfig()
self.drive_service = DriveService(motor_config, self.logger)
# Input services
keyboard_config = KeyboardServiceConfig()
self.keyboard_service = KeyboardInputService(keyboard_config,
self.logger)
user_control_config = UserControlConfig()
self.user_control_service = UserControlService(user_control_config,
self.keyboard_service,
self.drive_service,
self.logger)
# Power service
power_config = PowerConfig()
self.power_service = PowerService(power_config, self.logger)
# Wifi service
wifi_config = WifiServiceConfig()
self.wifi_service = WifiService(wifi_config, self.logger)
# Menu
menu_config = MenuConfig()
self.menu_service = MenuService(menu_config, self.keyboard_service,
self.power_service,
self.distance_service,
self.wifi_service, self.logger)
self.logger.log(self.TAG,
"All services initialized, starting web server...")
# Bluetooth
bt_config = BluetoothConfig()
self.bluetooth = BluetoothService(bt_config, self.user_control_service,
self.logger)
# Web server
self.web_config = WebServerConfig()
self.webapp = create_app(self.user_control_service)
def setUp(self):
#
# Bug workarounds (?)
#
admin._views = []
rest_api.resources = []
#
# Create the test app
#
app = create_app('webapp.config.TestConfig')
self.client = app.test_client()
#
# Bug workaround
#
db.app = app
db.create_all()
def create_new():
'''
Функция создания структуры новой БД. Также:
1) в таблице Storages создается справочник из 3 типов хранилищ:
dropbox, yadisk, NAS;
2) в таблице Classes создается справочник используемых классов classes_dict;
3) создается запись о фиктивном алгоритме в таблице algorithms
'''
try:
app = create_app()
db.create_all(app=app)
with app.app_context():
# Создаем записи в таблице storages
dropbox = Storages(id=1,
name='dropbox',
full_path='https://www.dropbox.com')
yadisk = Storages(id=2,
name='yadisk',
full_path='https://disk.yandex.ru/')
NAS = Storages(id=3, name='NAS', full_path='')
db.session.add(dropbox)
db.session.add(yadisk)
db.session.add(NAS)
# Создаем словарь базовых классов
for item in classes_dict:
class_ = Classes(id=(classes_dict.index(item) + 1),
name=item['label'])
db.session.add(class_)
# Создаем фиктивный алгоритм в справочнике используемых алгоритмов
alg_fict = Algorithms(id=0,
name='test',
create_date=datetime.strptime(
'2000-01-01', '%Y-%m-%d'))
db.session.add(alg_fict)
db.session.commit()
except:
print(
'ОШИБКА при попытке создания новой БД: Возможно Вы не удалили старую базу...'
)
sys.exit(0)
def testapp(request):
app = create_app('webapp.settings.TestConfig', env='dev')
client = app.test_client()
db.app = app
db.create_all()
if getattr(request.module, "create_user", True):
admin = User('admin', 'supersafepassword')
db.session.add(admin)
db.session.commit()
def teardown():
db.session.remove()
db.drop_all()
request.addfinalizer(teardown)
return client
from webapp import create_app
application = create_app("webapp.config.ProdConfig")
from webapp import create_app
app = create_app("webapp.config.ProdConfig")
#!venv/bin/python
from webapp import create_app, socketio
from flask.ext.script import Manager
from flask.ext.migrate import MigrateCommand
from flask.ext.script import Command
app = create_app('production')
class Server(Command):
def run(self):
socketio.run(app)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
manager.add_command('runserver', Server())
if __name__ == '__main__':
manager.run()
#!/usr/bin/env python
#coding=utf-8
from flask import Flask, current_app
from flaskext.script import Server, Shell, Manager, Command
from webapp import create_app
from webapp.extensions import db
manager = Manager(create_app('config.cfg'))
manager.add_command("runserver", Server('0.0.0.0',port=80))
def _make_context():
return dict(db=db)
manager.add_command("shell", Shell(make_context=_make_context))
@manager.command
def createall():
"Creates database tables"
db.create_all()
@manager.command
def dropall():
"Drops all database tables"
if prompt_bool("Are you sure ? You will lose all your data !"):
db.drop_all()
if __name__ == "__main__":
manager.run()
# COPY (select customer.id, user_id, email, is_shop_owner, temp_password, confirmed_at, last_login_at, stripe_customer_id, stripe_subscription_id, subscription.timestamp as subscription_timestamp from customer, public.user, subscription where customer.user_id=public.user.id and subscription.customer_id=customer.id) TO '/tmp/current_customers.csv' DELIMITER ',' CSV HEADER;
from webapp import models, db, create_app
import datetime
app = create_app("development")
with app.app_context():
platform_shopify = models.Platform.query.filter_by(id=2).first()
no_shopify_basic = models.Plan.query.filter_by(id=7).first()
shopify_basic = models.Plan.query.filter_by(id=8).first()
shopify_simple = models.Plan.query.filter_by(id=9).first()
# Edit beauty kitchen subscription
bk_s = models.Subscription.query.filter_by(id=2).first()
bk_s.stripe_subscription_id = "sub_8EBtDUle9oaBQ2"
bk_s.plan = shopify_simple
bk_s.trialed_for = 30
db.session.add(bk_s)
# Edit rachel mcmillan subscription
s2 = models.Subscription.query.filter_by(id=6).first()
s2.stripe_subscription_id = "sub_8EBoQIKzdvzYtZ"
s2.plan = shopify_simple
s2.trialed_for = 30
db.session.add(s2)
# Edit white rabbit subscription
s4 = models.Subscription.query.filter_by(id=7).first()
s4.stripe_subscription_id = "sub_8EBrRGwWacDbBi"
s4.plan = shopify_simple
s4.trialed_for = 30
#!/usr/bin/env python
from webapp import create_app
app = create_app('config.cfg')
from flup.server.fcgi import WSGIServer
WSGIServer(app,bindAddress='/tmp/webapp.sock').run()
from webapp import create_app
from webapp.config import DevConfig
from webapp.models import db
from webapp.tasks import log
def make_celery(app):
celery = Celery(
app.import_name,
broker=app.config['CELERY_BROKER_URL'],
backend=app.config['CELERY_BACKEND_URL']
)
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
# make a dev app (with no REST)
flask_app = create_app(DevConfig)
db.init_app(flask_app)
celery = make_celery(flask_app)
def create_app(self):
"""Create and return a testing flask app."""
app = create_app(TestConfig)
self.twill = Twill(app, port=3000)
return app
model_one_name, model_two_name = fname.split('_')
headers = csv_reader.next()
for row in csv_reader:
model_one_class = getattr(models, model_one_name)
model_two_class = getattr(models, model_two_name)
model_one_instance = model_one_class.query.filter_by(id=row[0]).first()
model_two_instance = model_two_class.query.filter_by(id=row[1]).first()
getattr(model_one_instance, headers[1]).append(model_two_instance)
db_instance.session.add(model_one_instance)
db_instance.session.commit()
if __name__ == '__main__':
arguments = sys.argv
if not len(sys.argv) == 2 or arguments[1] not in ['db_dev', 'db_prod']:
print "USAGE: ./repopulate.py db_dev|db_prod"
exit(1)
option = arguments[1]
app = create_app(option)
db.init_app(app)
###############################
# INIT DB
###############################
app.app_context().push()
db.create_all()
db_dir = os.path.join(basedir, 'install', 'db', current_app.config.get('MODE'))
import_tables(db, db_dir)
import unittest
import webapp
from webapp import db, models
from tests import testing_constants
app = webapp.create_app('testing')
class BaseTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = app
cls.client = cls.app.test_client()
cls.app.app_context().push()
db.create_all()
db.engine.dialect.supports_sane_multi_rowcount = False
@classmethod
def tearDownClass(cls):
db.session.remove()
db.drop_all()
def setUp(self):
pass
def tearDown(self):
db.session.close()
db.session.rollback()
def register(self, email, password):
if FLASK_COVERAGE:
COV = coverage.coverage(branch=True, include='opac/webapp/*')
COV.start()
else:
COV = None
from webapp import create_app, dbsql, dbmongo, mail
from opac_schema.v1.models import Collection, Sponsor, Journal, Issue, Article
from webapp import controllers
from webapp.utils import reset_db, create_db_tables, create_user, create_image
from flask_script import Manager, Shell
from flask_migrate import Migrate, MigrateCommand
from webapp.admin.forms import EmailForm
from flask import current_app
app = create_app()
migrate = Migrate(app, dbsql)
manager = Manager(app)
manager.add_command('dbsql', MigrateCommand)
def make_shell_context():
app_models = {
'Collection': Collection,
'Sponsor': Sponsor,
'Journal': Journal,
'Issue': Issue,
'Article': Article,
}
return dict(app=app, dbsql=dbsql, dbmongo=dbmongo, mail=mail, **app_models)
manager.add_command("shell", Shell(make_context=make_shell_context))
import webapp
from config import Config
from werkzeug.contrib.fixers import ProxyFix
# Inicializa o aplicativo com as configurações desejadas
app = webapp.create_app(Config)
# Configura o aplicativo para proxy reverso
app.wsgi_app = ProxyFix(app.wsgi_app)
# Condicional importante para não invocar o servidor de debugging
if __name__ == "__main__":
app.run()
from os import getenv
from webapp import create_app
from argparse import ArgumentParser
app = create_app(getenv("FLASK_CONFIG") or "development")
def main():
parser = ArgumentParser()
parser.add_argument("-p", "--port", help="port number")
args = parser.parse_args()
port = int(args.port or 5000)
app.run(port=port)
if __name__ == "__main__":
main()
import os
from flask.ext.script import Manager, Server
from flask.ext.script.commands import ShowUrls
from flask.ext.migrate import Migrate, MigrateCommand
from webapp import create_app
from webapp.models import db, User
# default to dev config
env = os.environ.get("WEBAPP_ENV", "DEV")
app = create_app("webapp.config.%sConfig" % env.capitalize())
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command("server", Server())
manager.add_command("show-urls", ShowUrls())
manager.add_command('db', MigrateCommand)
@manager.shell
def make_shell_context():
return dict(
app=app,
db=db,
User=User
)
if __name__ == "__main__":
manager.run()
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from webapp import create_app
app = WSGIContainer(create_app("webapp.config.ProdConfig"))
http_server = HTTPServer(app)
http_server.listen(80)
IOLoop.instance().start()
from webapp import create_app
from async.email_sender import send_email
if __name__ == '__main__':
app = create_app('dummy')
app.app_context().push()
send_email(recipients=['*****@*****.**'],
template='email/new_user.html',
template_ctx={"subject": "New user",
"user_password": "******"},
subject="Welcome to Opinew")
import os
from webapp import create_app
from webapp.config import DevConfig
from flask_script import Manager, Server
#default to dev config
#env = os.environ.get("WEBAPP_ENV", "dev")
app = create_app('webapp.config.DevConfig')
manager = Manager(app)
manager.add_command("server", Server(host='0.0.0.0', port='5000'))
@manager.shell
def make_shell_context():
return dict(
app=app,
User = User,
Role=Role
)
if __name__ == "__main__":
manager.run()
from gevent.wsgi import WSGIServer
from webapp import create_app
app = create_app('webapp.config.ProdConfig')
server = WSGIServer(('', 80), app)
server.serve_forever()
#!venv/bin/python
from webapp import create_app
from flask.ext.script import Manager
from flask.ext.migrate import MigrateCommand
app = create_app('development')
manager = Manager(app)
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run()
import os
from flask.ext.script import Manager, Server
from flask.ext.script.commands import ShowUrls
from flask_migrate import Migrate, MigrateCommand
from webapp import create_app
from webapp.models import db, Account, Investment, AccountHistory
from webapp.session_helper import PickleSessionInterface
# default to dev config
env = os.environ.get('WEBAPP_ENV', 'dev')
app = create_app('webapp.config.%sConfig' % env.capitalize())
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command("server", Server())
manager.add_command("show-urls", ShowUrls())
manager.add_command('db', MigrateCommand)
@manager.shell
def make_shell_context():
return dict(
app=app,
db=db,
Account=Account,
Investment=Investment,
AccountHistory=AccountHistory
)
def setup_app():
app = create_app('test')
world.client = app.test_client()
world.ctx = app.test_request_context()
world.ctx.push()
import facebook
from webapp import create_app
app = create_app('db_dev')
app.app_context().push()
# TODO: Facebook requires page access token...
# http://aseriesoftubes.com/articles/obtaining-facebook-page-access-tokens-the-4-step-program/
fb_graph = facebook.GraphAPI(access_token=app.config.get('FB_USER_ACCESS_SECRET'))
fb_profile = fb_graph.get_object('me')
from webapp import create_app
app = create_app('dev')
if __name__ == "__main__":
app.run("0.0.0.0",port=5050)
