def main():
parser = ArgumentParser(description='Instabot', add_help=False)
parser.add_argument('--version', action='version', version=__version__)
choices = [
func for func in dir(Instabot)
if callable(getattr(Instabot, func)) and not func.startswith('_')
]
parser.add_argument('action', metavar='|'.join(choices), choices=choices)
defaults = {
'config42':
OrderedDict([
('argv', dict(handler=ArgParse, schema=schema, parents=[parser])),
('env', {
'prefix': 'INSTABOT'
}),
('file', {
'path': 'config.yml'
}),
])
}
config = ConfigManager(schema=schema, defaults=defaults)
config_file = config.get('config.file')
_config = ConfigManager(schema=schema, path=config_file)
config.set_many(_config.as_dict())
config.commit()
logging.config.dictConfig(config.get("logging"))
instabot = Instabot(config)
getattr(instabot, config.get('action'))()
def main():
config = ConfigManager()
config.set_many(DEFAULT_CONFIG)
_config = ConfigManager(schema=schema, defaults=defaults)
config.set_many(_config.as_dict())
config.set_many(ConfigManager(path=_config.get('config.file')).as_dict())
config.set_many(_config.as_dict())
config.commit()
if config.get('dump_configuration'):
conf = config.as_dict()
conf.pop('config42')
print(yaml.dump(conf))
exit(0)
if config.get('show_version'):
print(instabot_py.__version__)
exit(0)
if config.get('verbosity'):
verbosity = int(config.get('verbosity'))
if verbosity == 1:
level = logging.INFO
elif verbosity > 1:
level = logging.DEBUG
config.set("logging.root.level", level)
logging.config.dictConfig(config.get("logging"))
bot = InstaBot(config=config)
bot.mainloop()
def includeme(config):
config.include('dashboard')
config.commit()
config.get_jinja2_environment().filters['friendly_group_name'] =\
friendly_group_name
# hook up our submission handlers
hook_submission_handlers()
# request methods
config.add_request_method(get_request_user, 'user', reify=True)
config.add_request_method(is_current_path)
# pyramid_jinja2 is already included by Dashboard
config.add_jinja2_search_path("composting:templates")
config.add_renderer('xlsx',
'composting.views.renderers.TablibXLSXRenderer')
config.add_static_view('static', 'composting:static', cache_max_age=3600)
config.add_static_view('docs', '../docs/_build/html', cache_max_age=3600)
config.add_route('default', '/')
config.add_route('auth', '/auth/{action}')
config.add_route('oauth', '/oauth/{action}')
config.add_route('municipalities',
'/municipalities/*traverse',
factory=MunicipalityFactory)
config.add_route('submissions',
'/submissions/*traverse',
factory=SubmissionFactory)
config.add_route('skips', '/skips/*traverse', factory=SkipFactory)
config.add_route('users', '/users/*traverse', factory=UserFactory)
config.scan()
def main():
config = ConfigManager()
config.set_many(DEFAULT_CONFIG)
_config = ConfigManager(schema=schema, defaults=defaults)
config.set_many(_config.as_dict())
config.set_many(
ConfigManager(schema=schema,
path=_config.get('config.file')).as_dict())
config.set_many(_config.as_dict())
config.commit()
if config.get('dump_configuration'):
conf = config.as_dict()
conf.pop('config42')
print(yaml.dump(conf))
exit(0)
if config.get('show_version'):
print("Installed version {}".format(instabot_py.__version__))
exit(0)
if not config.get('ignore_updates'):
last_version = get_last_version()
if last_version and last_version != instabot_py.__version__:
print(
"Newer version available: {}, The current version: {}".format(
last_version, instabot_py.__version__))
print(
"To update, please type \n python3 -m pip install instabot-py --upgrade --no-cache-dir "
)
print("")
print(
" > You can ignore warning, run the instabot with --ignore-updates flag"
)
exit(0)
if config.get('verbosity'):
verbosity = int(config.get('verbosity'))
if verbosity == 1:
level = logging.INFO
elif verbosity > 1:
level = logging.DEBUG
config.set("logging.root.level", level)
logging.config.dictConfig(config.get("logging"))
try:
bot = InstaBot(config=config)
except CredsMissing:
print(
"You didn't provide your Instagram login & password or you didn't specify the configuration file"
)
print("Try again :")
print("")
print(" instabot-py --login YOUR_LOGIN --password YOUR_PASSWORD")
print(" instabot-py -c your-config.yml")
print(
"You can export and modify the default configuration by typing the command below"
)
print(" instabot-py --dump")
exit(1)
bot.mainloop()
def includeme(config):
config.include('pyramid_jinja2')
config.commit()
config.add_jinja2_search_path("whoahqa:templates")
config.get_jinja2_environment().filters['format_date'] = \
format_date_for_locale
config.get_jinja2_environment().filters['format_location_name'] = \
format_location_name
config.get_jinja2_environment().filters['round_or_none'] = round_or_none
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('default', '/')
config.add_route('logout', '/logout/')
config.add_route('push', '/push/{action}')
config.add_route('locale', '/locale/')
config.add_route('admin', '/admin/*traverse', factory=UserFactory)
config.add_route('auth', '/auth/{action}')
config.add_route('users', '/users/*traverse',
factory=UserFactory)
config.add_route('clinics', '/clinics/*traverse',
factory=ClinicFactory)
config.add_route('submissions', '/submissions/*traverse',
factory=SubmissionFactory)
config.add_route('periods', '/reporting-periods/*traverse',
factory=ReportingPeriodFactory)
config.add_route('municipalities', '/municipalities/*traverse',
factory=LocationFactory)
config.add_route('states', '/states/*traverse',
factory=LocationFactory)
config.add_route('locations', '/locations/*traverse',
factory=LocationFactory)
config.scan()
def main():
config = ConfigManager()
config.set_many(DEFAULT_CONFIG)
_config = ConfigManager(schema=schema, defaults=defaults)
config.set_many(_config.as_dict())
config_file = _config.get('config.file')
config.set_many(ConfigManager(schema=schema, path=config_file).as_dict())
config.set_many(_config.as_dict())
config.commit()
configure_logging(config)
if config.get('dump_configuration'):
conf = config.as_dict()
conf.pop('config42')
conf.pop('dump_configuration')
print(yaml.dump(conf))
exit(0)
if config.get('show_version'):
print("Installed version {}".format(src.__version__))
exit(0)
if not config.get('ignore_updates'):
last_version = get_last_version()
if last_version and last_version != src.__version__:
print("Newer version available: {}, The current version: {}".format(last_version, src.__version__))
print("To update, please type \n python3 -m pip install instabot-py --upgrade --no-cache-dir ")
print("")
print(" > You can ignore warning, run the instabot with --ignore-updates flag")
exit(0)
try:
bot = InstaBot(config=config)
if config_file:
bot.logger.info(f"Reading configuration ({len(_config.as_dict())} settings) from {config_file}")
else:
bot.logger.info(f"Use the default configuration, add '-c your-config.yml' to specify your config")
except CredsMissing:
print("You didn't provide your Instagram login & password or you didn't specify the configuration file")
print("Try again :")
print("")
print(" instabot-py --login YOUR_LOGIN --password YOUR_PASSWORD")
print(" instabot-py -c your-config.yml")
print("You can export and modify the default configuration by typing the command below")
print(" instabot-py --dump")
exit(1)
bot.mainloop()
def configure_application(module_name, config, root, settings, configured):
if module_name in configured:
return
module = resolve_dotted_name(module_name)
if hasattr(module, 'app_settings') and app_settings != module.app_settings:
# load dependencies if necessary
for dependency in module.app_settings.get('applications') or []:
if dependency not in configured and module_name != dependency:
configure_application(dependency, config, root, settings, configured)
config.begin(module_name)
load_application(module, root, settings)
config.execute_actions()
config.commit()
configured.append(module_name)
def includeme(config):
config.include('pyramid_jinja2')
config.add_jinja2_search_path("dashboard:templates")
config.commit() # commit to allow access to jinja environment
# request methods
config.add_request_method(get_request_user, 'user', reify=True)
config.get_jinja2_environment().filters['format_date'] = format_date
config.get_jinja2_environment().filters['format_time'] = format_time
config.get_jinja2_environment().filters['format_decimal'] = format_decimal
config.get_jinja2_environment().filters['format_percent'] = format_percent
config.get_jinja2_environment().filters['format_number'] = format_number
config.get_jinja2_environment().filters['datetime'] = (
date_string_to_datetime)
config.add_static_view('static', 'dashboard:static', cache_max_age=3600)
config.add_route('default', '/')
config.add_route('submissions', '/submissions/*traverse')
config.scan()
def main():
config = ConfigManager()
config.set_many(DEFAULT_CONFIG)
_config = ConfigManager(schema=schema, defaults=defaults)
config.set_many(_config.as_dict())
config_file = _config.get('config.file')
config.set_many(ConfigManager(schema=schema, path=config_file).as_dict())
config.set_many(_config.as_dict())
config.commit()
configure_logging(config)
if config.get('dump_configuration'):
conf = config.as_dict()
conf.pop('config42')
conf.pop('dump_configuration')
print(yaml.dump(conf))
exit(0)
if config.get('create_configuration'):
create_configuration()
exit(0)
if config.get('show_version'):
print("Installed version {}".format(instabot_py.__version__))
exit(0)
if not config.get('ignore_updates'):
last_version = get_last_version()
current_version = instabot_py.__version__
if last_version and last_version != current_version:
print(f"""Newer version is available: {last_version}. The current \
version is: {current_version}.
To update instabot-py, please perform:
python3 -m pip install instabot-py --upgrade --no-cache-dir
> You can also ignore this warning and upgrade instabot-py later. In this \
case, please run the instabot with '--ignore-updates' flag.""")
exit(0)
if config_file:
print(f"Reading configuration ({len(_config.as_dict())} settings) from"
f" {config_file}")
elif os.path.isfile('instabot.config.yml'):
print("Using 'instabot.config.yml' as a configuration, add "
"'-c your-config.yml' if you want to use your config file")
else:
print("Configuration file has not been found. Please run the instabot "
"with '--create-config' flag.")
exit(0)
try:
bot = InstaBot(config=config)
except CredsMissing:
print(
"""We could not find your Instagram login and/or password. Maybe \
you did not change the default ones in the config file.
You can specify them either directly, correct them in the default config file \
or use your own config file:
instabot-py --login YOUR_LOGIN --password YOUR_PASSWORD
or
instabot-py -c your-config.yml
""")
exit(1)
bot.mainloop()
def make_app(config_file=None, settings=None, loop=None, server_app=None):
app_settings.update(_delayed_default_settings)
if loop is None:
loop = asyncio.get_event_loop()
loop.set_task_factory(aiotask_context.task_factory)
if config_file is not None:
with open(config_file, 'r') as config:
settings = json.load(config)
elif settings is None:
raise Exception('Neither configuration or settings')
# Create root Application
root = ApplicationRoot(config_file)
provide_utility(root, IApplication, 'root')
# Initialize global (threadlocal) ZCA configuration
config = root.config = ConfigurationMachine()
import guillotina
import guillotina.db.factory
import guillotina.db.writer
import guillotina.db.db
configure.scan('guillotina.translation')
configure.scan('guillotina.renderers')
configure.scan('guillotina.api')
configure.scan('guillotina.content')
configure.scan('guillotina.registry')
configure.scan('guillotina.auth')
configure.scan('guillotina.json')
configure.scan('guillotina.behaviors')
configure.scan('guillotina.languages')
configure.scan('guillotina.permissions')
configure.scan('guillotina.security.security_local')
configure.scan('guillotina.security.policy')
configure.scan('guillotina.auth.participation')
configure.scan('guillotina.catalog.index')
configure.scan('guillotina.catalog.catalog')
configure.scan('guillotina.framing')
configure.scan('guillotina.files')
configure.scan('guillotina.annotations')
configure.scan('guillotina.constraintypes')
configure.scan('guillotina.subscribers')
configure.scan('guillotina.db.strategies')
configure.scan('guillotina.db.cache')
load_application(guillotina, root, settings)
config.execute_actions()
config.commit()
for module_name in settings.get('applications', []):
config.begin(module_name)
load_application(resolve_dotted_name(module_name), root, settings)
config.execute_actions()
config.commit()
# XXX we clear now to save some memory
# it's unclear to me if this is necesary or not but it seems to me that
# we don't need things registered in both components AND here.
configure.clear()
# update *after* plugins loaded
update_app_settings(settings)
if 'logging' in app_settings:
logging.config.dictConfig(app_settings['logging'])
# Make and initialize aiohttp app
if server_app is None:
server_app = make_aiohttp_application()
root.app = server_app
server_app.root = root
server_app.config = config
content_type = ContentNegotiatorUtility('content_type',
app_settings['renderers'].keys())
language = ContentNegotiatorUtility('language',
app_settings['languages'].keys())
provide_utility(content_type, IContentNegotiation, 'content_type')
provide_utility(language, IContentNegotiation, 'language')
for database in app_settings['databases']:
for key, dbconfig in database.items():
factory = get_utility(IDatabaseConfigurationFactory,
name=dbconfig['storage'])
if asyncio.iscoroutinefunction(factory):
future = asyncio.ensure_future(factory(key, dbconfig,
server_app),
loop=loop)
loop.run_until_complete(future)
root[key] = future.result()
else:
root[key] = factory(key, dbconfig)
for key, file_path in list_or_dict_items(app_settings['static']):
path = resolve_path(file_path).resolve()
if not path.exists():
raise Exception('Invalid static directory {}'.format(file_path))
if path.is_dir():
root[key] = StaticDirectory(path)
else:
root[key] = StaticFile(path)
for key, file_path in list_or_dict_items(app_settings['jsapps']):
path = resolve_path(file_path).resolve()
if not path.exists() or not path.is_dir():
raise Exception('Invalid jsapps directory {}'.format(file_path))
root[key] = JavaScriptApplication(path)
root.set_root_user(app_settings['root_user'])
if RSA is not None and not app_settings.get('rsa'):
key = RSA.generate(2048)
pub_jwk = {'k': key.publickey().exportKey('PEM')}
priv_jwk = {'k': key.exportKey('PEM')}
app_settings['rsa'] = {'pub': pub_jwk, 'priv': priv_jwk}
# Set router root
server_app.router.set_root(root)
for utility in get_all_utilities_registered_for(IAsyncUtility):
# In case there is Utilties that are registered
if hasattr(utility, 'initialize'):
task = asyncio.ensure_future(lazy_apply(utility.initialize,
app=server_app),
loop=loop)
root.add_async_task(utility, task, {})
else:
logger.warn(f'No initialize method found on {utility} object')
server_app.on_cleanup.append(close_utilities)
for util in app_settings['utilities']:
root.add_async_utility(util, loop=loop)
# Load cached Schemas
load_cached_schema()
optimize_settings(app_settings)
return server_app
async def make_app(config_file=None,
settings=None,
loop=None,
server_app=None):
# reset app_settings
app_settings.clear()
app_settings.update(default_settings)
if loop is None:
loop = asyncio.get_event_loop()
# chainmap task factory is actually very important
# default task factory uses inheritance in a way
# that bubbles back down. So it's possible for a sub-task
# to clear out the request of the parent task
loop.set_task_factory(aiotask_context.chainmap_task_factory)
if config_file is not None:
with open(config_file, 'r') as config:
settings = json.load(config)
elif settings is None:
raise Exception('Neither configuration or settings')
# Create root Application
root = ApplicationRoot(config_file, loop)
provide_utility(root, IApplication, 'root')
# Initialize global (threadlocal) ZCA configuration
config = root.config = ConfigurationMachine()
import guillotina
import guillotina.db.factory
import guillotina.db.writer
import guillotina.db.db
configure.scan('guillotina.renderers')
configure.scan('guillotina.api')
configure.scan('guillotina.content')
configure.scan('guillotina.registry')
configure.scan('guillotina.auth')
configure.scan('guillotina.json')
configure.scan('guillotina.behaviors')
configure.scan('guillotina.languages')
configure.scan('guillotina.permissions')
configure.scan('guillotina.security.security_local')
configure.scan('guillotina.security.policy')
configure.scan('guillotina.auth.participation')
configure.scan('guillotina.catalog.index')
configure.scan('guillotina.catalog.catalog')
configure.scan('guillotina.files')
configure.scan('guillotina.annotations')
configure.scan('guillotina.constraintypes')
configure.scan('guillotina.subscribers')
configure.scan('guillotina.db.strategies')
configure.scan('guillotina.db.cache')
configure.scan('guillotina.exc_resp')
configure.scan('guillotina.fields')
load_application(guillotina, root, settings)
config.execute_actions()
config.commit()
configured = ['guillotina']
for module_name in settings.get('applications') or []:
configure_application(module_name, config, root, settings, configured)
apply_concrete_behaviors()
# update *after* plugins loaded
update_app_settings(settings)
if 'logging' in app_settings:
logging.config.dictConfig(app_settings['logging'])
# Make and initialize aiohttp app
if server_app is None:
server_app = make_aiohttp_application()
root.app = server_app
server_app.root = root
server_app.config = config
optimize_settings(app_settings)
await notify(ApplicationConfiguredEvent(server_app, loop))
for key, dbconfig in list_or_dict_items(app_settings['databases']):
factory = get_utility(IDatabaseConfigurationFactory,
name=dbconfig['storage'])
root[key] = await factory(key, dbconfig, loop)
await notify(DatabaseInitializedEvent(root[key]))
for key, file_path in list_or_dict_items(app_settings['static']):
path = resolve_path(file_path).resolve()
if not path.exists():
raise Exception('Invalid static directory {}'.format(file_path))
if path.is_dir():
root[key] = StaticDirectory(path)
else:
root[key] = StaticFile(path)
for key, file_path in list_or_dict_items(app_settings['jsapps']):
path = resolve_path(file_path).resolve()
if not path.exists() or not path.is_dir():
raise Exception('Invalid jsapps directory {}'.format(file_path))
root[key] = JavaScriptApplication(path)
root.set_root_user(app_settings['root_user'])
if RSA is not None and not app_settings.get('rsa'):
key = RSA.generate(2048)
pub_jwk = {'k': key.publickey().exportKey('PEM')}
priv_jwk = {'k': key.exportKey('PEM')}
app_settings['rsa'] = {'pub': pub_jwk, 'priv': priv_jwk}
# Set router root
server_app.router.set_root(root)
server_app.on_cleanup.append(cleanup_app)
for util in app_settings.get('utilities') or []:
logger.warn('Adding : ' + util['provides'])
root.add_async_utility(util['provides'], util, loop=loop)
for key, util in app_settings['load_utilities'].items():
logger.info('Adding ' + key + ' : ' + util['provides'])
root.add_async_utility(key, util, loop=loop)
# Load cached Schemas
load_cached_schema()
await notify(ApplicationInitializedEvent(server_app, loop))
return server_app
async def make_app(config_file=None,
settings=None,
loop=None,
server_app=None):
'''
Make application from configuration
:param config_file: path to configuration file to load
:param settings: dictionary of settings
:param loop: if not using with default event loop
:param settings: provide your own aiohttp application
'''
# reset app_settings
startup_vars = {}
for key in app_settings.keys():
if key[0] == '_':
startup_vars[key] = app_settings[key]
app_settings.clear()
app_settings.update(startup_vars)
app_settings.update(default_settings)
if loop is None:
loop = asyncio.get_event_loop()
# chainmap task factory is actually very important
# default task factory uses inheritance in a way
# that bubbles back down. So it's possible for a sub-task
# to clear out the request of the parent task
loop.set_task_factory(aiotask_context.chainmap_task_factory)
if config_file is not None:
with open(config_file, 'r') as config:
settings = json.load(config)
elif settings is None:
raise Exception('Neither configuration or settings')
# Create root Application
root = ApplicationRoot(config_file, loop)
provide_utility(root, IApplication, 'root')
# Initialize global (threadlocal) ZCA configuration
config = root.config = ConfigurationMachine()
import guillotina
import guillotina.db.factory
import guillotina.db.writer
import guillotina.db.db
configure.scan('guillotina.renderers')
configure.scan('guillotina.api')
configure.scan('guillotina.content')
configure.scan('guillotina.registry')
configure.scan('guillotina.auth')
configure.scan('guillotina.json')
configure.scan('guillotina.behaviors')
configure.scan('guillotina.languages')
configure.scan('guillotina.permissions')
configure.scan('guillotina.security.security_local')
configure.scan('guillotina.security.policy')
configure.scan('guillotina.auth.participation')
configure.scan('guillotina.catalog.index')
configure.scan('guillotina.catalog.catalog')
configure.scan('guillotina.files')
configure.scan('guillotina.annotations')
configure.scan('guillotina.constraintypes')
configure.scan('guillotina.subscribers')
configure.scan('guillotina.db.strategies')
configure.scan('guillotina.db.cache')
configure.scan('guillotina.exc_resp')
configure.scan('guillotina.fields')
configure.scan('guillotina.migrations')
load_application(guillotina, root, settings)
config.execute_actions()
config.commit()
configured = ['guillotina']
for module_name in settings.get('applications') or []:
configure_application(module_name, config, root, settings, configured)
apply_concrete_behaviors()
# update *after* plugins loaded
update_app_settings(settings)
if 'logging' in app_settings:
logging.config.dictConfig(app_settings['logging'])
# Make and initialize aiohttp app
if server_app is None:
server_app = make_aiohttp_application()
root.app = server_app
server_app.root = root
server_app.config = config
optimize_settings(app_settings)
await notify(ApplicationConfiguredEvent(server_app, loop))
for key, dbconfig in list_or_dict_items(app_settings['databases']):
factory = get_utility(IDatabaseConfigurationFactory,
name=dbconfig['storage'])
root[key] = await factory(key, dbconfig, loop)
await notify(DatabaseInitializedEvent(root[key]))
for key, file_path in list_or_dict_items(app_settings['static']):
path = resolve_path(file_path).resolve()
if not path.exists():
raise Exception('Invalid static directory {}'.format(file_path))
if path.is_dir():
root[key] = StaticDirectory(path)
else:
root[key] = StaticFile(path)
for key, file_path in list_or_dict_items(app_settings['jsapps']):
path = resolve_path(file_path).resolve()
if not path.exists() or not path.is_dir():
raise Exception('Invalid jsapps directory {}'.format(file_path))
root[key] = JavaScriptApplication(path)
root.set_root_user(app_settings['root_user'])
if app_settings.get('jwk') and\
app_settings.get('jwk').get('k') and\
app_settings.get('jwk').get('kty'):
key = jwk.JWK.from_json(json.dumps(app_settings.get('jwk')))
app_settings['jwk'] = key
# {"k":"QqzzWH1tYqQO48IDvW7VH7gvJz89Ita7G6APhV-uLMo","kty":"oct"}
if not app_settings.get('debug') and app_settings['jwt'].get('secret'):
# validate secret
secret = app_settings['jwt']['secret']
if secret == 'secret':
logger.warning(
'You are using a very insecure secret key in production mode. '
'It is strongly advised that you provide a better value for '
'`jwt.secret` in your config.')
elif not secure_passphrase(app_settings['jwt']['secret']):
logger.warning(
'You are using a insecure secret key in production mode. '
'It is recommended that you provide a more complex value for '
'`jwt.secret` in your config.')
# Set router root
server_app.router.set_root(root)
server_app.on_cleanup.append(cleanup_app)
for util in app_settings.get('utilities') or []:
logger.warn('Adding : ' + util['provides'])
root.add_async_utility(util['provides'], util, loop=loop)
for key, util in app_settings['load_utilities'].items():
logger.info('Adding ' + key + ' : ' + util['provides'])
root.add_async_utility(key, util, loop=loop)
# Load cached Schemas
load_cached_schema()
await notify(ApplicationInitializedEvent(server_app, loop))
return server_app
