def backup(
context, with_files=False, backup_path_db=None, backup_path_files=None, backup_path_private_files=None, quiet=False
):
"Backup"
from frappe.utils.backups import scheduled_backup
verbose = context.verbose
for site in context.sites:
frappe.init(site=site)
frappe.connect()
odb = scheduled_backup(
ignore_files=not with_files,
backup_path_db=backup_path_db,
backup_path_files=backup_path_files,
backup_path_private_files=backup_path_private_files,
force=True,
)
if verbose:
from frappe.utils import now
print "database backup taken -", odb.backup_path_db, "- on", now()
if with_files:
print "files backup taken -", odb.backup_path_files, "- on", now()
print "private files backup taken -", odb.backup_path_private_files, "- on", now()
frappe.destroy()
def _set_limits(context, site, limits):
import datetime
if not limits:
return
if not site:
site = get_site(context)
with frappe.init_site(site):
frappe.connect()
new_limits = {}
for limit, value in limits:
if limit not in ('daily_emails', 'emails', 'space', 'users', 'email_group',
'expiry', 'support_email', 'support_chat', 'upgrade_url'):
frappe.throw(_('Invalid limit {0}').format(limit))
if limit=='expiry' and value:
try:
datetime.datetime.strptime(value, '%Y-%m-%d')
except ValueError:
raise ValueError("Incorrect data format, should be YYYY-MM-DD")
elif limit=='space':
value = float(value)
elif limit in ('users', 'emails', 'email_group', 'daily_emails'):
value = int(value)
new_limits[limit] = value
update_limits(new_limits)
def scheduler_task(site, event, handler, now=False):
from frappe.utils.scheduler import log
traceback = ""
task_logger.info('running {handler} for {site} for event: {event}'.format(handler=handler, site=site, event=event))
try:
frappe.init(site=site)
if not create_lock(handler):
return
if not now:
frappe.connect(site=site)
frappe.get_attr(handler)()
except Exception:
frappe.db.rollback()
traceback = log(handler, "Method: {event}, Handler: {handler}".format(event=event, handler=handler))
task_logger.warn(traceback)
raise
else:
frappe.db.commit()
finally:
delete_lock(handler)
if not now:
frappe.destroy()
task_logger.info('ran {handler} for {site} for event: {event}'.format(handler=handler, site=site, event=event))
def install_db(root_login="******", root_password=None, db_name=None, source_sql=None,
admin_password=None, verbose=True, force=0, site_config=None, reinstall=False):
make_conf(db_name, site_config=site_config)
frappe.flags.in_install_db = True
if reinstall:
frappe.connect(db_name=db_name)
dbman = DbManager(frappe.local.db)
dbman.create_database(db_name)
else:
frappe.local.db = get_root_connection(root_login, root_password)
frappe.local.session = frappe._dict({'user':'******'})
create_database_and_user(force, verbose)
frappe.conf.admin_password = frappe.conf.admin_password or admin_password
frappe.connect(db_name=db_name)
check_if_ready_for_barracuda()
import_db_from_sql(source_sql, verbose)
if not 'tabDefaultValue' in frappe.db.get_tables():
print('''Database not installed, this can due to lack of permission, or that the database name exists.
Check your mysql root password, or use --force to reinstall''')
sys.exit(1)
remove_missing_apps()
create_auth_table()
setup_global_search_table()
create_user_settings_table()
frappe.flags.in_install_db = False
def list_apps(context):
"List apps in site"
site = get_site(context)
frappe.init(site=site)
frappe.connect()
print("\n".join(frappe.get_installed_apps()))
frappe.destroy()
def run_async_task(self, site=None, user=None, cmd=None, form_dict=None, hijack_std=False):
ret = {}
frappe.init(site)
frappe.connect()
frappe.local.task_id = self.request.id
if hijack_std:
original_stdout, original_stderr = sys.stdout, sys.stderr
sys.stdout, sys.stderr = get_std_streams(self.request.id)
frappe.local.stdout, frappe.local.stderr = sys.stdout, sys.stderr
try:
set_task_status(self.request.id, "Running")
frappe.db.commit()
frappe.set_user(user)
# sleep(60)
frappe.local.form_dict = frappe._dict(form_dict)
execute_cmd(cmd, from_async=True)
ret = frappe.local.response
except Exception, e:
frappe.db.rollback()
ret = frappe.local.response
http_status_code = getattr(e, "http_status_code", 500)
ret['status_code'] = http_status_code
frappe.errprint(frappe.get_traceback())
frappe.utils.response.make_logs()
set_task_status(self.request.id, "Error", response=ret)
task_logger.error('Exception in running {}: {}'.format(cmd, ret['exc']))
def sendmail(site, communication_name, print_html=None, print_format=None, attachments=None,
recipients=None, cc=None):
try:
frappe.connect(site=site)
# upto 3 retries
for i in xrange(3):
try:
communication = frappe.get_doc("Communication", communication_name)
communication._notify(print_html=print_html, print_format=print_format, attachments=attachments,
recipients=recipients, cc=cc)
except MySQLdb.OperationalError, e:
# deadlock, try again
if e.args[0]==1213:
frappe.db.rollback()
time.sleep(1)
continue
else:
raise
else:
break
except:
frappe.db.rollback()
else:
frappe.db.commit()
finally:
frappe.destroy()
def install_db(root_login="******", root_password=None, db_name=None, source_sql=None,
admin_password=None, verbose=True, force=0, site_config=None, reinstall=False):
make_conf(db_name, site_config=site_config)
frappe.flags.in_install_db = True
if reinstall:
frappe.connect(db_name=db_name)
dbman = DbManager(frappe.local.db)
dbman.create_database(db_name)
else:
frappe.local.db = get_root_connection(root_login, root_password)
frappe.local.session = frappe._dict({'user':'******'})
create_database_and_user(force, verbose)
frappe.conf.admin_password = frappe.conf.admin_password or admin_password
frappe.connect(db_name=db_name)
check_if_ready_for_barracuda()
import_db_from_sql(source_sql, verbose)
remove_missing_apps()
create_auth_table()
create_list_settings_table()
frappe.flags.in_install_db = False
def scheduler(context, state, site=None):
from frappe.installer import update_site_config
import frappe.utils.scheduler
if not site:
site = get_site(context)
try:
frappe.init(site=site)
if state == 'pause':
update_site_config('pause_scheduler', 1)
elif state == 'resume':
update_site_config('pause_scheduler', 0)
elif state == 'disable':
frappe.connect()
frappe.utils.scheduler.disable_scheduler()
frappe.db.commit()
elif state == 'enable':
frappe.connect()
frappe.utils.scheduler.enable_scheduler()
frappe.db.commit()
print('Scheduler {0}d for site {1}'.format(state, site))
finally:
frappe.destroy()
def migrate(context, rebuild_website=False): "Run patches, sync schema and rebuild files/translations" import frappe.modules.patch_handler import frappe.model.sync from frappe.utils.fixtures import sync_fixtures import frappe.translate from frappe.desk.notifications import clear_notifications for site in context.sites: print 'Migrating', site frappe.init(site=site) frappe.connect() try: prepare_for_update() # run patches frappe.modules.patch_handler.run_all() # sync frappe.model.sync.sync_all(verbose=context.verbose) frappe.translate.clear_cache() sync_fixtures() clear_notifications() finally: frappe.destroy() if rebuild_website: call_command(build_website, context) else: call_command(sync_www, context)
def backup_to_dropbox():
if not frappe.db:
frappe.connect()
# upload database
dropbox_settings = get_dropbox_settings()
if not dropbox_settings['access_token']:
access_token = generate_oauth2_access_token_from_oauth1_token(dropbox_settings)
if not access_token.get('oauth2_token'):
return 'Failed backup upload', 'No Access Token exists! Please generate the access token for Dropbox.'
dropbox_settings['access_token'] = access_token['oauth2_token']
set_dropbox_access_token(access_token['oauth2_token'])
dropbox_client = dropbox.Dropbox(dropbox_settings['access_token'])
backup = new_backup(ignore_files=True)
filename = os.path.join(get_backups_path(), os.path.basename(backup.backup_path_db))
upload_file_to_dropbox(filename, "/database", dropbox_client)
frappe.db.close()
# upload files to files folder
did_not_upload = []
error_log = []
upload_from_folder(get_files_path(), "/files", dropbox_client, did_not_upload, error_log)
upload_from_folder(get_files_path(is_private=1), "/private/files", dropbox_client, did_not_upload, error_log)
frappe.connect()
return did_not_upload, list(set(error_log))
def execute(context, method, args=None, kwargs=None):
"execute a function"
for site in context.sites:
try:
frappe.init(site=site)
frappe.connect()
if args:
args = eval(args)
else:
args = ()
if kwargs:
kwargs = eval(args)
else:
kwargs = {}
ret = frappe.get_attr(method)(*args, **kwargs)
if frappe.db:
frappe.db.commit()
finally:
frappe.destroy()
if ret:
print json.dumps(ret)
def list_apps(context): "Reinstall site ie. wipe all data and start over" site = get_single_site(context) frappe.init(site=site) frappe.connect() print "\n".join(frappe.get_installed_apps()) frappe.destroy()
def execute(method): frappe.connect() ret = frappe.get_attr(method)() frappe.db.commit() frappe.destroy() if ret: print ret
def disable_scheduler(): import frappe.utils.scheduler frappe.connect() frappe.utils.scheduler.disable_scheduler() frappe.db.commit() print "Disabled" frappe.destroy()
def build_website(verbose=False): from frappe.website import render, statics frappe.connect() render.clear_cache() statics.sync(verbose=verbose).start(True) frappe.db.commit() frappe.destroy()
def reset_perms():
frappe.connect()
for d in frappe.db.sql_list("""select name from `tabDocType`
where ifnull(istable, 0)=0 and ifnull(custom, 0)=0"""):
frappe.clear_cache(doctype=d)
frappe.reset_perms(d)
frappe.destroy()
def latest(rebuild_website=True, quiet=False): import frappe.modules.patch_handler import frappe.model.sync from frappe.utils.fixtures import sync_fixtures import frappe.translate from frappe.core.doctype.notification_count.notification_count import clear_notifications verbose = not quiet frappe.connect() try: # run patches frappe.modules.patch_handler.run_all() # sync frappe.model.sync.sync_all(verbose=verbose) frappe.translate.clear_cache() sync_fixtures() clear_notifications() if rebuild_website: build_website() finally: frappe.destroy()
def clear_cache(): import frappe.sessions from frappe.core.doctype.notification_count.notification_count import clear_notifications frappe.connect() frappe.clear_cache() clear_notifications() frappe.destroy()
def import_csv(context, path, only_insert=False, submit_after_import=False, ignore_encoding_errors=False, no_email=True):
"Import CSV using data import tool"
from frappe.core.page.data_import_tool import importer
from frappe.utils.csvutils import read_csv_content
site = get_site(context)
if not os.path.exists(path):
path = os.path.join('..', path)
if not os.path.exists(path):
print('Invalid path {0}'.format(path))
sys.exit(1)
with open(path, 'r') as csvfile:
content = read_csv_content(csvfile.read())
frappe.init(site=site)
frappe.connect()
try:
importer.upload(content, submit_after_import=submit_after_import, no_email=no_email,
ignore_encoding_errors=ignore_encoding_errors, overwrite=not only_insert,
via_console=True)
frappe.db.commit()
except Exception:
print(frappe.get_traceback())
frappe.destroy()
def request(context, args=None, path=None):
"Run a request as an admin"
import frappe.handler
import frappe.api
for site in context.sites:
try:
frappe.init(site=site)
frappe.connect()
if args:
if "?" in args:
frappe.local.form_dict = frappe._dict([a.split("=") for a in args.split("?")[-1].split("&")])
else:
frappe.local.form_dict = frappe._dict()
if args.startswith("/api/method"):
frappe.local.form_dict.cmd = args.split("?")[0].split("/")[-1]
elif path:
with open(os.path.join('..', path), 'r') as f:
args = json.loads(f.read())
frappe.local.form_dict = frappe._dict(args)
frappe.handler.execute_cmd(frappe.form_dict.cmd)
print(frappe.response)
finally:
frappe.destroy()
def install_db(root_login="******", root_password=None, db_name=None, source_sql=None,
admin_password = '******', verbose=True, force=0, site_config=None, reinstall=False):
frappe.flags.in_install_db = True
db_name=db_name[:16]
if "." in db_name:
dn=db_name.split('.')
db_name=dn[0]
frappe.errprint(db_name)
make_conf(db_name, site_config=site_config)
if reinstall:
frappe.connect(db_name=db_name)
dbman = DbManager(frappe.local.db)
dbman.create_database(db_name)
else:
frappe.local.db = make_connection(root_login, root_password)
frappe.local.session = frappe._dict({'user':'******'})
create_database_and_user(force, verbose)
frappe.conf.admin_password = admin_password
frappe.connect(db_name=db_name)
import_db_from_sql(source_sql, verbose)
create_auth_table()
frappe.flags.in_install_db = False
def backup_to_dropbox():
from dropbox import client, session
from frappe.utils.backups import new_backup
from frappe.utils import get_files_path, get_backups_path
if not frappe.db:
frappe.connect()
sess = session.DropboxSession(frappe.conf.dropbox_access_key, frappe.conf.dropbox_secret_key, "app_folder")
sess.set_token(frappe.db.get_value("Dropbox Backup", None, "dropbox_access_key"),
frappe.db.get_value("Dropbox Backup", None, "dropbox_access_secret"))
dropbox_client = client.DropboxClient(sess)
# upload database
backup = new_backup(ignore_files=True)
filename = os.path.join(get_backups_path(), os.path.basename(backup.backup_path_db))
upload_file_to_dropbox(filename, "/database", dropbox_client)
frappe.db.close()
# upload files to files folder
did_not_upload = []
error_log = []
upload_from_folder(get_files_path(), "/files", dropbox_client, did_not_upload, error_log)
upload_from_folder(get_files_path(is_private=1), "/private/files", dropbox_client, did_not_upload, error_log)
frappe.connect()
return did_not_upload, list(set(error_log))
def import_csv(context, path, only_insert=False, submit_after_import=False, ignore_encoding_errors=False):
"Import CSV using data import tool"
from frappe.core.page.data_import_tool import importer
from frappe.utils.csvutils import read_csv_content
site = get_site(context)
with open(path, "r") as csvfile:
content = read_csv_content(csvfile.read())
frappe.init(site=site)
frappe.connect()
try:
importer.upload(
content,
submit_after_import=submit_after_import,
ignore_encoding_errors=ignore_encoding_errors,
overwrite=not only_insert,
via_console=True,
)
frappe.db.commit()
except Exception:
print frappe.get_traceback()
frappe.destroy()
def send_newsletter(site, newsletter, event):
# hack! pass event="bulk_long" to queue in longjob queue
try:
frappe.connect(site=site)
doc = frappe.get_doc("Newsletter", newsletter)
doc.send_bulk()
except:
frappe.db.rollback()
task_logger.error(site)
task_logger.error(frappe.get_traceback())
# wasn't able to send emails :(
doc.db_set("email_sent", 0)
frappe.db.commit()
log("send_newsletter")
raise
else:
frappe.db.commit()
finally:
frappe.destroy()
def patch(patch_module, force=False): import frappe.modules.patch_handler frappe.connect() frappe.local.patch_log_list = [] frappe.modules.patch_handler.run_single(patch_module, force=force) print "\n".join(frappe.local.patch_log_list) frappe.destroy()
def set_admin_password(admin_password):
import frappe
frappe.connect()
frappe.db.sql("""update __Auth set `password`=password(%s)
where user='******'""", (admin_password,))
frappe.db.commit()
frappe.destroy()
def scheduler(context, state, site=None):
from frappe.installer import update_site_config
import frappe.utils.scheduler
if not site:
site = get_site(context)
try:
frappe.init(site=site)
if state == "pause":
update_site_config("pause_scheduler", 1)
elif state == "resume":
update_site_config("pause_scheduler", 0)
elif state == "disable":
frappe.connect()
frappe.utils.scheduler.disable_scheduler()
frappe.db.commit()
elif state == "enable":
frappe.connect()
frappe.utils.scheduler.enable_scheduler()
frappe.db.commit()
print "Scheduler {0}d for site {1}".format(state, site)
finally:
frappe.destroy()
def send_email(success, service_name, error_status=None):
if success:
if frappe.db.get_value("Dropbox Settings", None, "send_email_for_successful_backup") == '0':
return
subject = "Backup Upload Successful"
message ="""<h3>Backup Uploaded Successfully</h3><p>Hi there, this is just to inform you
that your backup was successfully uploaded to your %s account. So relax!</p>
""" % service_name
else:
subject = "[Warning] Backup Upload Failed"
message ="""<h3>Backup Upload Failed</h3><p>Oops, your automated backup to %s
failed.</p>
<p>Error message: <br>
<pre><code>%s</code></pre>
</p>
<p>Please contact your system manager for more information.</p>
""" % (service_name, error_status)
if not frappe.db:
frappe.connect()
recipients = split_emails(frappe.db.get_value("Dropbox Settings", None, "send_notifications_to"))
frappe.sendmail(recipients=recipients, subject=subject, message=message)
def main(app=None, module=None, doctype=None, verbose=False, tests=(), force=False):
frappe.flags.print_messages = verbose
frappe.flags.in_test = True
if not frappe.db:
frappe.connect()
# if not frappe.conf.get("db_name").startswith("test_"):
# raise Exception, 'db_name must start with "test_"'
# workaround! since there is no separate test db
frappe.clear_cache()
frappe.utils.scheduler.disable_scheduler()
set_test_email_config()
if verbose:
print 'Running "before_tests" hooks'
for fn in frappe.get_hooks("before_tests", app_name=app):
frappe.get_attr(fn)()
if doctype:
ret = run_tests_for_doctype(doctype, verbose=verbose, tests=tests, force=force)
elif module:
ret = run_tests_for_module(module, verbose=verbose, tests=tests)
else:
ret = run_all_tests(app, verbose)
frappe.db.commit()
# workaround! since there is no separate test db
frappe.clear_cache()
return ret
def build_sitemap(): from frappe.website import rebuild_config frappe.connect() rebuild_config() frappe.destroy()
def export_fixtures(): from frappe.utils.fixtures import export_fixtures frappe.connect() export_fixtures() frappe.destroy()
def export_csv(doctype, path): from frappe.core.page.data_import_tool import data_import_tool frappe.connect() data_import_tool.export_csv(doctype, path) frappe.destroy()
def export_doclist(doctype, name, path): from frappe.core.page.data_import_tool import data_import_tool frappe.connect() data_import_tool.export_json(doctype, name, path) frappe.destroy()
def export_doc(doctype, docname): import frappe.modules frappe.connect() frappe.modules.export_doc(doctype, docname) frappe.destroy()
def run_scheduler_event(event, force=False): import frappe.utils.scheduler frappe.connect() frappe.utils.scheduler.trigger(frappe.local.site, event, now=force) frappe.destroy()
def sync_statics(): from frappe.website import statics frappe.connect() statics.sync_statics() frappe.db.commit() frappe.destroy()
def clear_web(): import frappe.website.render frappe.connect() frappe.website.render.clear_cache() frappe.destroy()
def make_custom_server_script(doctype): from frappe.core.doctype.custom_script.custom_script import make_custom_server_script_file frappe.connect() make_custom_server_script_file(doctype) frappe.destroy()
def clear_all_sessions(): import frappe.sessions frappe.connect() frappe.sessions.clear_all_sessions() frappe.db.commit() frappe.destroy()
def patch(patch_module, force=False): import frappe.modules.patch_handler frappe.connect() frappe.modules.patch_handler.run_single(patch_module, force=force) frappe.destroy()
def clear_cache(): import frappe.sessions frappe.connect() frappe.clear_cache() frappe.destroy()
def add_system_manager(email, first_name=None, last_name=None): import frappe.utils.user frappe.connect() frappe.utils.user.add_system_manager(email, first_name, last_name) frappe.db.commit() frappe.destroy()
def reload_doc(module, doctype, docname, force=False): frappe.connect() frappe.reload_doc(module, doctype, docname, force=force) frappe.db.commit() frappe.destroy()
send,
recipients=['*****@*****.**'] * 1000,
sender="*****@*****.**",
reference_doctype="User",
reference_name="Administrator",
subject='Testing Email Queue',
message='This email is queued!')
def test_image_parsing(self):
import re
email_account = frappe.get_doc('Email Account',
'_Test Email Account 1')
with open(
frappe.get_app_path('frappe', 'tests', 'data',
'email_with_image.txt'), 'r') as raw:
communication = email_account.insert_communication(raw.read())
#print communication.content
self.assertTrue(
re.search('''<img[^>]*src=["']/private/files/rtco1.png[^>]*>''',
communication.content))
self.assertTrue(
re.search('''<img[^>]*src=["']/private/files/rtco2.png[^>]*>''',
communication.content))
if __name__ == '__main__':
frappe.connect()
unittest.main()
def sync_all(force=False, quiet=False): import frappe.model.sync verbose = not quiet frappe.connect() frappe.model.sync.sync_all(force=force, verbose=verbose) frappe.destroy()
def execute_job(site,
method,
event,
job_name,
kwargs,
user=None,
is_async=True,
retry=0):
"""Executes job in a worker, performs commit/rollback and logs if there is any error"""
if is_async:
frappe.connect(site)
if os.environ.get("CI"):
frappe.flags.in_test = True
if user:
frappe.set_user(user)
if isinstance(method, string_types):
method_name = method
method = frappe.get_attr(method)
else:
method_name = cstr(method.__name__)
frappe.monitor.start("job", method_name, kwargs)
try:
method(**kwargs)
except (frappe.db.InternalError, frappe.RetryBackgroundJobError) as e:
frappe.db.rollback()
if retry < 5 and (isinstance(e, frappe.RetryBackgroundJobError) or
(frappe.db.is_deadlocked(e)
or frappe.db.is_timedout(e))):
# retry the job if
# 1213 = deadlock
# 1205 = lock wait timeout
# or RetryBackgroundJobError is explicitly raised
frappe.destroy()
time.sleep(retry + 1)
return execute_job(site,
method,
event,
job_name,
kwargs,
is_async=is_async,
retry=retry + 1)
else:
frappe.log_error(title=method_name)
raise
except:
frappe.db.rollback()
frappe.log_error(title=method_name)
frappe.db.commit()
print(frappe.get_traceback())
raise
else:
frappe.db.commit()
finally:
frappe.monitor.stop()
if is_async:
frappe.destroy()
def install_app(app_name, quiet=False): verbose = not quiet from frappe.installer import install_app frappe.connect() install_app(app_name, verbose=verbose) frappe.destroy()
def __enter__(self):
frappe.init(site=self.site)
frappe.connect()
print frappe.local.site
frappe.set_user(self.user)
def trim_database(context, dry_run, format, no_backup):
if not context.sites:
raise SiteNotSpecifiedError
from frappe.utils.backups import scheduled_backup
ALL_DATA = {}
for site in context.sites:
frappe.init(site=site)
frappe.connect()
TABLES_TO_DROP = []
STANDARD_TABLES = get_standard_tables()
information_schema = frappe.qb.Schema("information_schema")
table_name = frappe.qb.Field("table_name").as_("name")
queried_result = frappe.qb.from_(
information_schema.tables).select(table_name).where(
information_schema.tables.table_schema ==
frappe.conf.db_name).run()
database_tables = [x[0] for x in queried_result]
doctype_tables = frappe.get_all("DocType", pluck="name")
for x in database_tables:
doctype = x.lstrip("tab")
if not (doctype in doctype_tables or x.startswith("__")
or x in STANDARD_TABLES):
TABLES_TO_DROP.append(x)
if not TABLES_TO_DROP:
if format == "text":
click.secho(
f"No ghost tables found in {frappe.local.site}...Great!",
fg="green")
else:
if not (no_backup or dry_run):
if format == "text":
print(f"Backing Up Tables: {', '.join(TABLES_TO_DROP)}")
odb = scheduled_backup(
ignore_conf=False,
include_doctypes=",".join(
x.lstrip("tab") for x in TABLES_TO_DROP),
ignore_files=True,
force=True,
)
if format == "text":
odb.print_summary()
print("\nTrimming Database")
for table in TABLES_TO_DROP:
if format == "text":
print(f"* Dropping Table '{table}'...")
if not dry_run:
frappe.db.sql_ddl(f"drop table `{table}`")
ALL_DATA[frappe.local.site] = TABLES_TO_DROP
frappe.destroy()
if format == "json":
import json
print(json.dumps(ALL_DATA, indent=1))
})
def execute_job(site,
method,
event,
job_name,
kwargs,
user=None,
async=True,
retry=0):
'''Executes job in a worker, performs commit/rollback and logs if there is any error'''
from frappe.utils.scheduler import log
if async:
frappe.connect(site)
if user:
frappe.set_user(user)
if isinstance(method, basestring):
method_name = method
method = frappe.get_attr(method)
else:
method_name = cstr(method.__name__)
try:
method(**kwargs)
except (MySQLdb.OperationalError, frappe.RetryBackgroundJobError), e:
frappe.db.rollback()
def _get():
if not frappe.db:
frappe.connect()
return frappe.db.sql_list('select name from tabLanguage')
def ipython(site): import frappe frappe.connect(site=site) import IPython IPython.embed()
def main(app=None,
module=None,
doctype=None,
verbose=False,
tests=(),
force=False,
profile=False,
junit_xml_output=None,
ui_tests=False,
doctype_list_path=None,
skip_test_records=False,
failfast=False):
global unittest_runner
if doctype_list_path:
app, doctype_list_path = doctype_list_path.split(os.path.sep, 1)
with open(frappe.get_app_path(app, doctype_list_path), 'r') as f:
doctype = f.read().strip().splitlines()
xmloutput_fh = None
if junit_xml_output:
xmloutput_fh = open(junit_xml_output, 'wb')
unittest_runner = xmlrunner_wrapper(xmloutput_fh)
else:
unittest_runner = unittest.TextTestRunner
try:
frappe.flags.print_messages = verbose
frappe.flags.in_test = True
if not frappe.db:
frappe.connect()
# if not frappe.conf.get("db_name").startswith("test_"):
# raise Exception, 'db_name must start with "test_"'
# workaround! since there is no separate test db
frappe.clear_cache()
frappe.utils.scheduler.disable_scheduler()
set_test_email_config()
if not frappe.flags.skip_before_tests:
if verbose:
print('Running "before_tests" hooks')
for fn in frappe.get_hooks("before_tests", app_name=app):
frappe.get_attr(fn)()
if doctype:
ret = run_tests_for_doctype(doctype, verbose, tests, force,
profile)
elif module:
ret = run_tests_for_module(module, verbose, tests, profile)
else:
ret = run_all_tests(app,
verbose,
profile,
ui_tests,
failfast=failfast)
frappe.db.commit()
# workaround! since there is no separate test db
frappe.clear_cache()
return ret
finally:
if xmloutput_fh:
xmloutput_fh.flush()
xmloutput_fh.close()
def get_untranslated(lang, untranslated_file, all=None): import frappe.translate frappe.connect() frappe.translate.get_untranslated(lang, untranslated_file, get_all=all) frappe.destroy()
def validate(site):
frappe.init(site=site, sites_path=sites_path)
frappe.connect()
if not executed(last_3_patch):
raise Exception, "site not ready to migrate to version 4"
frappe.destroy()
def import_doc(path, force=False): from frappe.core.page.data_import_tool import data_import_tool frappe.connect() data_import_tool.import_doc(path, overwrite=force) frappe.destroy()
def update_translations(lang, untranslated_file, translated_file): import frappe.translate frappe.connect() frappe.translate.update_translations(lang, untranslated_file, translated_file) frappe.destroy()
def sync_statics(force=False): from frappe.website import statics frappe.connect() statics.sync_statics(rebuild = force) frappe.db.commit() frappe.destroy()
def build_message_files(): import frappe.translate frappe.connect() frappe.translate.rebuild_all_translation_files() frappe.destroy()
