def cli():
"""Unicorn dev server (reload and logs)"""
# Uvicorn dev server info
appname = uvicore.config('app.server.app')
host = uvicore.config('app.server.host')
port = uvicore.config('app.server.port')
autoreload = uvicore.config('app.server.reload')
access_log = uvicore.config('app.server.access_log')
# Run Uvicorn server
uvicorn.run(appname,
host=host,
port=port,
reload=autoreload,
access_log=access_log)
async def model(name: str, table: str):
"""
\b
Generate a new ORM model schematic...
\b
USAGE:
Models should be lower_understore and SINGULAR
While their table should be lower_understore and PLURAL
\b
./uvicore gen model user users
./uvicore gen model user_detail user_details
./uvicore gen model post posts
./uvicore gen model post_tag post_tags
"""
stub = os.path.dirname(__file__) + '/stubs/model.py'
dest = uvicore.config('app.paths.models') + '/' + name + '.py'
Schematic(
type='model',
stub=stub,
dest=dest,
replace = [
('xx_modelname', name),
('xx_ModelName', str.studly(name)),
('xx_tablename', table),
('xx_TableName', str.studly(table)),
]
).generate()
uvicore.log.nl()
uvicore.log.notice('Be sure to add this model to your ./models/__init__.py')
def register(self) -> None:
"""Register package into uvicore framework.
All packages are registered before the framework boots. This is where
you define your packages configs and IoC bindings. Configs are deep merged only after
all packages are registered. No real work should be performed here as it
is very early in the bootstraping process and most internal processes are not
instantiated yet.
"""
# Note about logger config
# We cannot use the standard package config/logger.py here with proper
# app config overrides because the logger is SUPER early in the bootstrapping
# process. I want the log available almost first thing, even in your packages
# service provider register() and boot() methods. This means if the logger config
# were in this packages config/logger.py file you wouldn't be able to override it
# as usual from your own app. So instead, the logger config is in your actual app config
# Register IoC bindings
self.bind(name='Logger',
object='mreschke.wiki.overrides.logger.Logger',
kwargs={'config': uvicore.config('app.logger')},
singleton=True,
aliases=['Log', 'log', 'logger'])
# Set uvicore.log global
uvicore.log = uvicore.ioc.make('Logger')
async def table(name: str):
"""
\b
Generate a new Database table schematic...
\b
USAGE:
Tables should be lower_underscore and PLURAL
If a table is awkward as plural, ok to make a few singluar (user_info)
\b
./uvicore gen table users
./uvicore gen table user_details
./uvicore gen table posts
./uvicore gen table post_tags
"""
stub = os.path.dirname(__file__) + '/stubs/table.py'
dest = uvicore.config('app.paths.tables') + '/' + name + '.py'
Schematic(type='table',
stub=stub,
dest=dest,
replace=[
('xx_tablename', name),
('xx_TableName', str.studly(name)),
]).generate()
uvicore.log.nl()
uvicore.log.notice(
'Be sure to add this table to your ./database/tables/__init__.py')
async def seeder(name: str):
"""
\b
Generate a new Database table seeder schematic...
\b
USAGE:
Seeder should match the lower_underscore PLURAL tablenames
\b
./uvicore gen seeder users
./uvicore gen seeder user_details
./uvicore gen seeder posts
./uvicore gen seeder post_tags
"""
stub = os.path.dirname(__file__) + '/stubs/seeder.py'
dest = uvicore.config('app.paths.seeders') + '/' + name + '.py'
Schematic(type='seeder',
stub=stub,
dest=dest,
replace=[
('xx_modelname', name),
('xx_ModelName', str.studly(name)),
]).generate()
uvicore.log.nl()
uvicore.log.notice(
'Be sure to add this seeder to your ./database/seeders/__init__.py')
def get_prefix(self, confpath: str) -> str:
"""Get configured web and api prefixes ensuring "" prefix and no trailing /, or / if blank)"""
prefix = uvicore.config(confpath)
#if not prefix: prefix = '/'
#if prefix != '/' and prefix[-1] == '/': prefix = prefix[0:-1] # No trailing /
if prefix and prefix[-1] == '/': prefix = prefix[0:-1] # No trailing /
return prefix
async def command(name: str):
"""Generate a new CLI Command"""
stub = os.path.dirname(__file__) + '/stubs/command.py'
dest = uvicore.config('app.paths.commands') + '/' + name + '.py'
Schematic(type='command',
stub=stub,
dest=dest,
replace=[('xx_name', name)]).generate()
# Get running package
package = uvicore.app.package(main=True)
log.nl()
log.header('Add this to your Service Provider commands List')
print("'{}': '{}.commands.{}.cli',".format(name, package.name, name))
log.nl()
log.notice(
'IF you do NOT have a self.commands() already in your Service Provider, add this'
)
print("""self.commands(
group='{}',
help='{} Commands',
commands={{
'{}': '{}.commands.{}.cli',
}}
)""".format(
package.short_name,
str.studly(package.short_name),
name,
package.name,
name,
))
async def seeder(name: str):
"""Generate a new Database table seeder schematic"""
stub = os.path.dirname(__file__) + '/stubs/seeder.py'
dest = uvicore.config('app.paths.seeders') + '/' + name + '.py'
Schematic(type='seeder',
stub=stub,
dest=dest,
replace=[
('xx_modelname', name),
('xx_ModelName', str.studly(name)),
]).generate()
async def table(name: str):
"""Generate a new Database table schematic"""
stub = os.path.dirname(__file__) + '/stubs/table.py'
dest = uvicore.config('app.paths.tables') + '/' + name + '.py'
Schematic(type='table',
stub=stub,
dest=dest,
replace=[
('xx_tablename', name),
('xx_TableName', str.studly(name)),
]).generate()
def create(password: str, *, type: str = None, hash_len: int = None, salt_len: int = None, encoding: str = None, time_cost: int = None, memory_cost: int = None, parallelism: int = None):
"""Create a new hashed password using config driven Argon2 default or parameter overrides"""
config = uvicore.config('uvicore.auth.hasher')
if type is None: type = config.type
if hash_len is None: hash_len = config.hash_len
if salt_len is None: salt_len = config.salt_len
if encoding is None: encoding = config.encoding
if time_cost is None: time_cost = config.time_cost
if memory_cost is None: memory_cost = config.memory_cost
if parallelism is None: parallelism = config.parallelism
# New Argon2 Password Hasher
ph = PasswordHasher(type=Type[type], hash_len=hash_len, salt_len=salt_len, encoding=encoding, time_cost=time_cost, memory_cost=memory_cost, parallelism=parallelism)
return ph.hash(password)
async def command(name: str):
"""
\b
Generate a new CLI command...
\b
USAGE:
Commands should be lower_underscore and SINGULAR (plural is OK)
Remember to manually add the command to your service provider!
\b
./uvicore gen command welcome
./uvicore gen command process
./uvicore gen command scan_files
"""
stub = os.path.dirname(__file__) + '/stubs/command.py'
dest = uvicore.config('app.paths.commands') + '/' + name + '.py'
Schematic(type='command',
stub=stub,
dest=dest,
replace=[('xx_name', name)]).generate()
# Get running package
package = uvicore.app.package(main=True)
log.nl()
log.header('Add this to your Service Provider commands List')
print("'{}': '{}.commands.{}.cli',".format(str.kebab(name), package.name,
name))
log.nl()
log.notice(
'IF you do NOT have a self.commands() already in your Service Provider, add this'
)
print("""self.commands(
group='{}',
help='{} Commands',
commands={{
'{}': '{}.commands.{}.cli',
}}
)""".format(
package.short_name,
str.studly(package.short_name),
str.kebab(name),
package.name,
name,
))
def create_http_servers(
self, web_routes: Dict[str, WebRoute],
api_routes: Dict[str,
ApiRoute]) -> Tuple[Starlette, FastAPI, FastAPI]:
"""Fire up one or multiple HTTP servers"""
# If we have both web and api routes then we will submount subservers.
# If not, we will only use one server.
base_server: Starlette = None
web_server: FastAPI = None
api_server: FastAPI = None
debug = uvicore.config('app.debug'),
# Base server is Starlette
if web_routes and api_routes:
base_server = Starlette(debug=debug, )
# Web server is FastAPI with NO OpenAPI setup
if web_routes:
web_server = FastAPI(
debug=debug,
version=uvicore.app.version,
openapi_url=None,
swagger_ui_oauth2_redirect_url=None,
)
# Api server is FastAPI with OpenAPI setup
if api_routes:
api_server = FastAPI(
debug=debug,
#title=uvicore.config('app.api.openapi.title'),
version=uvicore.app.version,
#openapi_url=uvicore.config('app.api.openapi.url'),
#swagger_ui_oauth2_redirect_url=uvicore.config('app.api.openapi.docs_url') + '/oauth2-redirect',
# Default FastAPI docs and redoc routes
#docs_url=uvicore.config('app.api.openapi.docs_url'),
#redoc_url=uvicore.config('app.api.openapi.redoc_url'),
docs_url=None,
redoc_url=None,
#swagger_ui_oauth2_redirect_url=
#root_path='/api', #fixme with trying out kong
)
return (base_server, web_server, api_server)
async def controller(name: str):
"""
\b
Generate a new HTTP Web controller schematic...
\b
USAGE:
Web Controllers should be lower_understore and SINGULAR
\b
./uvicore gen controller home
./uvicore gen controller about
./uvicore gen controller contact_us
"""
stub = os.path.dirname(__file__) + '/stubs/controller.py'
dest = uvicore.config('app.paths.controllers') + '/' + name + '.py'
Schematic(type='controller',
stub=stub,
dest=dest,
replace=[
('xx_controllername', name),
('xx_ControllerName', str.studly(name)),
]).generate()
async def api_controller(name: str):
"""
\b
Generate a new HTTP API controller schematic...
\b
USAGE:
API Controllers should be lower_understore and SINGULAR
\b
./uvicore gen controller user
./uvicore gen controller user_detail
./uvicore gen controller post
./uvicore gen controller post_tag
"""
stub = os.path.dirname(__file__) + '/stubs/api_controller.py'
dest = uvicore.config('app.paths.api') + '/' + name + '.py'
Schematic(type='api_controller',
stub=stub,
dest=dest,
replace=[
('xx_controllername', name),
('xx_ControllerName', str.studly(name)),
]).generate()
import uvicore
from starlette.applications import Starlette as _Starlette
from uvicore.support.dumper import dd, dump
@uvicore.service(
'uvicore.http.servers.web._Server',
#aliases=['api', 'web_server'],
singleton=True,
kwargs={
'debug': uvicore.config('app.debug'),
},
)
class Server(_Starlette):
@property
def server(self) -> _Starlette:
return self
def get_home(self):
return {
'Page': 'Home',
'Config': config(),
}
import uvicore
from fastapi import FastAPI as _FastAPI
from uvicore.support.dumper import dd, dump
@uvicore.service(
'uvicore.http.servers.api._Server',
#aliases=['api', 'web_server'],
singleton=True,
kwargs={
'debug': uvicore.config('app.debug'),
'title': uvicore.config('app.api.openapi.title'),
'version': uvicore.app.version,
'openapi_url': uvicore.config('app.api.openapi.url'),
'docs_url': uvicore.config('app.api.openapi.docs_url'),
'redoc_url': uvicore.config('app.api.openapi.redoc_url'),
#'root_path': uvicore.config('app.api.root_path'), # experiment with using Kong for API but Nginx for Web, may need 2 root_paths
},
)
class Server(_FastAPI):
@property
def server(self) -> _FastAPI:
return self
message = ('{0}{1}{2}').format(fg('orange_red_1'), message,
attr(0))
elif (level == 'ERROR'):
message = ('{0}{1}{2}').format(fg('red'), message, attr(0))
elif (level == 'CRITICAL'):
message = ('{0}{1}{2}{3}').format(fg('black'), bg('red'), message,
attr(0))
return message
@uvicore.service(
'uvicore.logging.logger.Logger',
aliases=['Logger', 'logger', 'Log', 'log'],
singleton=True,
kwargs={'config': uvicore.config('app.logger')},
)
class Logger(LoggerInterface):
"""Logger private class.
Do not import from this location.
Use the uvicore.log singleton global instead."""
def __init__(self, config):
# Default Config
# Levels from logging._levelToName are
# {50: 'CRITICAL', 40: 'ERROR', 30: 'WARNING', 20: 'INFO', 10: 'DEBUG', 0: 'NOTSET'}
# Levels = DEBUG, INFO, WARNING, ERROR, CRITICAL
default = {
'console': {
'enabled': True,
def make(self, Logger: LoggerInterface):
config = uvicore.config('app.logger')
return Logger(config)
