def po(args):
"""
Manage catalog for all knowed languages
"""
starttime = datetime.datetime.now()
# Init, load and builds
root_logger = init_logging(args.loglevel.upper(), logfile=args.logfile)
# Only load optimus stuff after the settings module name has been retrieved
os.environ['OPTIMUS_SETTINGS_MODULE'] = args.settings
from optimus.conf import settings
from optimus.utils import display_settings
display_settings(settings, ('DEBUG', 'PROJECT_DIR', 'SOURCES_DIR',
'TEMPLATES_DIR', 'LOCALES_DIR'))
i18n = I18NManager(root_logger, settings)
# NOTE: Should we do this automatically to prevent error on missing files
# OR should we only do checking before and abort on the first missing file ?
if args.init or args.update or args.compile:
i18n.init_locales_dir()
i18n.extract(force=args.update)
i18n.init_catalogs()
if args.update:
i18n.update_catalogs()
if args.compile:
i18n.compile_catalogs()
endtime = datetime.datetime.now()
root_logger.info('Done in %s', str(endtime - starttime))
def build(args):
"""
Build elements for a project
"""
starttime = datetime.datetime.now()
# Init, load and builds
root_logger = init_logging(args.loglevel.upper(), logfile=args.logfile)
# Only load optimus stuff after the settings module name has been retrieved
os.environ['OPTIMUS_SETTINGS_MODULE'] = args.settings
from optimus.conf import settings, import_project_module
from optimus.builder.assets import register_assets
from optimus.builder.pages import PageBuilder
from optimus.utils import initialize, display_settings
display_settings(settings, ('DEBUG', 'PROJECT_DIR','SOURCES_DIR','TEMPLATES_DIR','PUBLISH_DIR','STATIC_DIR','STATIC_URL'))
if hasattr(settings, 'PAGES_MAP'):
root_logger.info('Loading external pages map')
pages_map = import_project_module(settings.PAGES_MAP)
setattr(settings, 'PAGES', pages_map.PAGES)
initialize(settings)
# Assets
assets_env = register_assets()
# Pages
pages_env = PageBuilder(assets_env=assets_env)
pages_env.build_bulk(settings.PAGES)
endtime = datetime.datetime.now()
root_logger.info('Done in %s', str(endtime-starttime))
def init(args):
"""
Create a new project from a project template
"""
starttime = datetime.datetime.now()
# Init, load and builds
root_logger = init_logging(args.loglevel.upper(), logfile=args.logfile)
# DEPRECATED
#if not args.name:
#root_logger.error("'--name' argument is required")
#return
# TODO: Check that the given project name is a valid python module name
# identifier ::= (letter|"_") (letter | digit | "_")*
# So valid that all characters from the name are : "_" character, letters,
# digits and does not starts with digits
if args.dry_run:
root_logger.warning("'Dry run' mode enabled")
# TODO: optionnal command option to specify another path where the project will
# be created
project_directory = os.path.abspath(os.getcwd())
loader = ProjectStarter(project_directory, args.name, dry_run=args.dry_run)
loader.install(args.template)
endtime = datetime.datetime.now()
root_logger.info('Done in %s', str(endtime-starttime))
def build(args):
"""
Build elements for a project
"""
starttime = datetime.datetime.now()
# Init, load and builds
root_logger = init_logging(args.loglevel.upper(), logfile=args.logfile)
# Only load optimus stuff after the settings module name has been retrieved
os.environ['OPTIMUS_SETTINGS_MODULE'] = args.settings
from optimus.conf import settings, import_pages_module
from optimus.builder.assets import register_assets
from optimus.builder.pages import PageBuilder
from optimus.utils import initialize, display_settings
display_settings(settings, ('DEBUG', 'PROJECT_DIR','SOURCES_DIR','TEMPLATES_DIR','PUBLISH_DIR','STATIC_DIR','STATIC_URL'))
if hasattr(settings, 'PAGES_MAP'):
root_logger.info('Loading external pages map')
pages_map = import_pages_module(settings.PAGES_MAP)
setattr(settings, 'PAGES', pages_map.PAGES)
initialize(settings)
# Assets
assets_env = register_assets()
# Pages
pages_env = PageBuilder(assets_env=assets_env)
pages_env.build_bulk(settings.PAGES)
endtime = datetime.datetime.now()
root_logger.info('Done in %s', str(endtime-starttime))
def init(args):
"""
Create a new project from a project template
"""
starttime = datetime.datetime.now()
# Init, load and builds
root_logger = init_logging(args.loglevel.upper(), logfile=args.logfile)
# Valid that all characters from the name are : "_" character, letters,
# identifier ::= (letter|"_") (letter | digit | "_")*
# This is not fully safe, user can create a project name using an installed
# Python module that will override it and make some troubles in some case
if args.name:
if args.name[0] not in letters:
root_logger.error("Project name must start with a letter")
return
for k in args.name[1:]:
if k not in letters and k not in digits and k != "_":
root_logger.error("Project name must only contains letters, digits or '_' character")
return
if args.dry_run:
root_logger.warning("'Dry run' mode enabled")
# TODO: optionnal command option to specify another path where the project will
# be created
project_directory = os.path.abspath(os.getcwd())
loader = ProjectStarter(project_directory, args.name, dry_run=args.dry_run)
loader.install(args.template)
endtime = datetime.datetime.now()
root_logger.info('Done in %s', str(endtime-starttime))
def po(args):
"""
Manage catalog for all knowed languages
"""
starttime = datetime.datetime.now()
# Init, load and builds
root_logger = init_logging(args.loglevel.upper(), logfile=args.logfile)
# Only load optimus stuff after the settings module name has been retrieved
os.environ['OPTIMUS_SETTINGS_MODULE'] = args.settings
from optimus.conf import settings
from optimus.utils import display_settings
display_settings(settings, ('DEBUG', 'PROJECT_DIR','SOURCES_DIR','TEMPLATES_DIR','LOCALES_DIR'))
i18n = I18NManager(root_logger, settings)
# NOTE: Should we do this automatically to prevent error on missing files
# OR should we only do checking before and abort on the first missing file ?
if args.init or args.update or args.compile:
i18n.init_locales_dir()
i18n.extract(force=args.update)
i18n.init_catalogs()
if args.update:
i18n.update_catalogs()
if args.compile:
i18n.compile_catalogs()
endtime = datetime.datetime.now()
root_logger.info('Done in %s', str(endtime-starttime))
def runserver(args):
"""
Launch the project watcher to automatically re-build knowed elements on changes
"""
root_logger = init_logging(args.loglevel.upper(), printout=not(args.silent), logfile=args.logfile)
# Only load optimus stuff after the settings module name has been retrieved
os.environ['OPTIMUS_SETTINGS_MODULE'] = args.settings
from optimus.conf import settings, import_project_module
from optimus.utils import display_settings
display_settings(settings, ('DEBUG', 'PROJECT_DIR','PUBLISH_DIR','STATIC_DIR','STATIC_URL'))
# Parse given hostname
address, port = ("127.0.0.1", "80")
_splits = args.hostname.split(':')
if len(_splits)>2:
raise CommandError("Error: Invalid hostname format, too many ':'")
elif len(_splits)==2:
address, port = _splits
if not port or not address:
raise CommandError("Error: Invalid hostname format, address or port is empty")
else:
port = _splits[0]
try:
int(port)
except ValueError:
raise CommandError("Error: Invalid port given: {0}".format(port))
if not os.path.exists(settings.PUBLISH_DIR):
raise CommandError("Error: Publish directory does not exist yet, you should build it before")
# Run server with publish directory served with tools.staticdir
print "Running http server on address {address} with port {port}".format(address=address, port=port)
cherrypy.config.update({
'server.socket_host': address,
'server.socket_port': int(port),
'engine.autoreload_on': False,
})
conf = {
'/': {
'tools.staticdir.index': 'index.html',
'tools.staticdir.on': True,
'tools.staticdir.dir': settings.PUBLISH_DIR,
},
}
cherrypy.quickstart(None, '/', config=conf)
def runserver(args):
"""
Launch the project watcher to automatically re-build knowed elements on changes
"""
root_logger = init_logging(args.loglevel.upper(), printout=not(args.silent), logfile=args.logfile)
# Only load optimus stuff after the settings module name has been retrieved
os.environ['OPTIMUS_SETTINGS_MODULE'] = args.settings
from optimus.conf import settings
from optimus.utils import display_settings
display_settings(settings, ('DEBUG', 'PROJECT_DIR','PUBLISH_DIR','STATIC_DIR','STATIC_URL'))
# Parse given hostname
address, port = ("127.0.0.1", "80")
_splits = args.hostname.split(':')
if len(_splits)>2:
raise CommandError("Error: Invalid hostname format, too many ':'")
elif len(_splits)==2:
address, port = _splits
if not port or not address:
raise CommandError("Error: Invalid hostname format, address or port is empty")
else:
port = _splits[0]
try:
int(port)
except ValueError:
raise CommandError("Error: Invalid port given: {0}".format(port))
if not os.path.exists(settings.PUBLISH_DIR):
raise CommandError("Error: Publish directory does not exist yet, you should build it before")
# Run server with publish directory served with tools.staticdir
print("Running HTTP server on address {address} with port {port}".format(address=address, port=port))
cherrypy.config.update({
'server.socket_host': address,
'server.socket_port': int(port),
'engine.autoreload_on': False,
})
conf = {
'/': {
'tools.staticdir.index': 'index.html',
'tools.staticdir.on': True,
'tools.staticdir.dir': settings.PUBLISH_DIR,
},
}
cherrypy.quickstart(None, '/', config=conf)
def po(args, init=False, update=False, compile=False):
"""
Manage catalog for all knowed languages
"""
starttime = datetime.datetime.now()
# Init, load and builds
root_logger = init_logging(args.loglevel.upper(), logfile=args.logfile)
# Only load optimus stuff after the settings module name has been retrieved
os.environ['OPTIMUS_SETTINGS_MODULE'] = args.settings
from optimus.conf import settings, import_project_module
from optimus.utils import display_settings
display_settings(settings, ('DEBUG', 'PROJECT_DIR','SOURCES_DIR','TEMPLATES_DIR','LOCALES_DIR'))
i18n = I18NManager(root_logger, settings)
# TODO: * Copy the actual locale directory to a temporary directory
# * If process is success, remove previous backup dir if exists then promote the temp backup dir as the current backup
# * If process goes wrong, just remove the temp backup dir
# -> Always keeping only one backup dir and allways for a successful process
if args.backup:
pass
# NOTE: Should we do this automatically to prevent error on missing files
# OR should we only do checking before and abort on the first missing file ?
if args.init or args.update or args.compile:
i18n.init_locales_dir()
i18n.extract(force=args.update)
i18n.init_catalogs()
if args.update:
i18n.update_catalogs()
if args.compile:
i18n.compile_catalogs()
endtime = datetime.datetime.now()
root_logger.info('Done in %s', str(endtime-starttime))
def watch(args):
"""
Launch the project watcher to automatically re-build knowed elements on changes
"""
root_logger = init_logging(args.loglevel.upper(), printout=not(args.silent), logfile=args.logfile)
# Only load optimus stuff after the settings module name has been retrieved
os.environ['OPTIMUS_SETTINGS_MODULE'] = args.settings
from optimus.conf import settings, import_project_module
from optimus.watchers import TemplatesWatchEventHandler, AssetsWatchEventHandler
from optimus.builder.assets import register_assets
from optimus.builder.pages import PageBuilder
from optimus.utils import initialize, display_settings
display_settings(settings, ('DEBUG', 'PROJECT_DIR','SOURCES_DIR','TEMPLATES_DIR','PUBLISH_DIR','STATIC_DIR','STATIC_URL'))
if hasattr(settings, 'PAGES_MAP'):
root_logger.info('Loading external pages map')
pages_map = import_project_module(settings.PAGES_MAP)
setattr(settings, 'PAGES', pages_map.PAGES)
# Init environments
assets_env = register_assets()
pages_env = PageBuilder(assets_env=assets_env)
# add a first build to avoid error on unbuilded project
if not os.path.exists(settings.PUBLISH_DIR):
root_logger.info('Seems you never do a first build so do it now')
pages_env.build_bulk(settings.PAGES)
pages_env.scan_bulk(settings.PAGES)
observer = Observer()
# Templates watcher settings
watcher_templates_patterns = {
'patterns': ['*.html'],
'ignore_patterns': None,
'ignore_directories': False,
'case_sensitive': False,
}
watcher_templates_patterns.update(settings.WATCHER_TEMPLATES_PATTERNS)
# Assets watcher settings
watcher_assets_patterns = {
'patterns': ['*.css', '*.js', '*.json'],
'ignore_patterns': None,
'ignore_directories': False,
'case_sensitive': False,
}
watcher_assets_patterns.update(settings.WATCHER_ASSETS_PATTERNS)
# Init templates and assets event watchers
templates_event_handler = TemplatesWatchEventHandler(settings, root_logger, assets_env, pages_env, **watcher_templates_patterns)
if assets_env is not None:
assets_event_handler = AssetsWatchEventHandler(settings, root_logger, assets_env, pages_env, **watcher_assets_patterns)
# Registering event watchers and start to watch
observer.schedule(templates_event_handler, settings.TEMPLATES_DIR, recursive=True)
if assets_env is not None:
observer.schedule(assets_event_handler, settings.SOURCES_DIR, recursive=True)
root_logger.warning('Launching the watcher, use CTRL+C to stop it')
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def watch(args):
"""
Launch the project watcher to automatically re-build knowed elements on changes
"""
root_logger = init_logging(args.loglevel.upper(),
printout=not (args.silent),
logfile=args.logfile)
# Only load optimus stuff after the settings module name has been retrieved
os.environ['OPTIMUS_SETTINGS_MODULE'] = args.settings
from optimus.conf import settings, import_pages_module
from optimus.watchers import TemplatesWatchEventHandler, AssetsWatchEventHandler
from optimus.builder.assets import register_assets
from optimus.builder.pages import PageBuilder
from optimus.utils import initialize, display_settings
display_settings(settings,
('DEBUG', 'PROJECT_DIR', 'SOURCES_DIR', 'TEMPLATES_DIR',
'PUBLISH_DIR', 'STATIC_DIR', 'STATIC_URL'))
if hasattr(settings, 'PAGES_MAP'):
root_logger.info('Loading external pages map')
pages_map = import_pages_module(settings.PAGES_MAP)
setattr(settings, 'PAGES', pages_map.PAGES)
# Init environments
assets_env = register_assets()
pages_env = PageBuilder(assets_env=assets_env)
# add a first build to avoid error on unbuilded project
if not os.path.exists(settings.PUBLISH_DIR):
root_logger.info('Seems you never do a first build so do it now')
pages_env.build_bulk(settings.PAGES)
pages_env.scan_bulk(settings.PAGES)
observer = Observer()
# Templates watcher settings
watcher_templates_patterns = {
'patterns': ['*.html'],
'ignore_patterns': None,
'ignore_directories': False,
'case_sensitive': False,
}
watcher_templates_patterns.update(settings.WATCHER_TEMPLATES_PATTERNS)
# Assets watcher settings
watcher_assets_patterns = {
'patterns': ['*.css', '*.js', '*.json'],
'ignore_patterns': None,
'ignore_directories': False,
'case_sensitive': False,
}
watcher_assets_patterns.update(settings.WATCHER_ASSETS_PATTERNS)
# Init templates and assets event watchers
templates_event_handler = TemplatesWatchEventHandler(
settings, root_logger, assets_env, pages_env,
**watcher_templates_patterns)
if assets_env is not None:
assets_event_handler = AssetsWatchEventHandler(
settings, root_logger, assets_env, pages_env,
**watcher_assets_patterns)
# Registering event watchers and start to watch
observer.schedule(templates_event_handler,
settings.TEMPLATES_DIR,
recursive=True)
if assets_env is not None:
observer.schedule(assets_event_handler,
settings.SOURCES_DIR,
recursive=True)
root_logger.warning('Launching the watcher, use CTRL+C to stop it')
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
root_logger.warning('Stopping watcher..')
observer.stop()
observer.join()
def runserver(args):
"""
Launch the project watcher to automatically re-build knowed elements on changes
"""
root_logger = init_logging(args.loglevel.upper(), printout=not(args.silent), logfile=args.logfile)
raise CommandError("Error: Unable to import CherryPy, you should install it with 'pip install cherrypy'")