index
int64 0
731k
| package
stringlengths 2
98
⌀ | name
stringlengths 1
76
| docstring
stringlengths 0
281k
⌀ | code
stringlengths 4
1.07M
⌀ | signature
stringlengths 2
42.8k
⌀ |
|---|---|---|---|---|---|
7,626 | emmett.app | config_from_yaml | null | def config_from_yaml(self, filename: str, namespace: Optional[str] = None):
#: import configuration from yaml files
rc = read_file(os.path.join(self.config_path, filename))
rc = ymlload(rc, Loader=ymlLoader)
c = self.config if namespace is None else self.config[namespace]
for key, val in rc.items():
c[key] = dict_to_sdict(val)
| (self, filename: str, namespace: Optional[str] = None) |
7,627 | emmett.app | make_shell_context | null | def make_shell_context(self, context: Dict[str, Any] = {}) -> Dict[str, Any]:
context['app'] = self
return context
| (self, context: Dict[str, Any] = {}) -> Dict[str, Any] |
7,628 | emmett.app | module | null | def module(
self,
import_name: str,
name: str,
template_folder: Optional[str] = None,
template_path: Optional[str] = None,
static_folder: Optional[str] = None,
static_path: Optional[str] = None,
url_prefix: Optional[str] = None,
hostname: Optional[str] = None,
cache: Optional[RouteCacheRule] = None,
root_path: Optional[str] = None,
pipeline: Optional[List[Pipe]] = None,
injectors: Optional[List[Injector]] = None,
module_class: Optional[Type[AppModule]] = None,
**kwargs: Any
) -> AppModule:
module_class = module_class or self.config.modules_class
return module_class.from_app(
self,
import_name,
name,
template_folder=template_folder,
template_path=template_path,
static_folder=static_folder,
static_path=static_path,
url_prefix=url_prefix,
hostname=hostname,
cache=cache,
root_path=root_path,
pipeline=pipeline or [],
injectors=injectors or [],
opts=kwargs
)
| (self, import_name: str, name: str, template_folder: Optional[str] = None, template_path: Optional[str] = None, static_folder: Optional[str] = None, static_path: Optional[str] = None, url_prefix: Optional[str] = None, hostname: Optional[str] = None, cache: Optional[emmett.cache.RouteCacheRule] = None, root_path: Optional[str] = None, pipeline: Optional[List[emmett.pipeline.Pipe]] = None, injectors: Optional[List[emmett.pipeline.Injector]] = None, module_class: Optional[Type[emmett.app.AppModule]] = None, **kwargs: Any) -> emmett.app.AppModule |
7,629 | emmett.app | module_group | null | def module_group(self, *modules: AppModule) -> AppModuleGroup:
return AppModuleGroup(*modules)
| (self, *modules: emmett.app.AppModule) -> emmett.app.AppModuleGroup |
7,630 | emmett.app | on_error | null | def on_error(self, code: int) -> Callable[[ErrorHandlerType], ErrorHandlerType]:
def decorator(f: ErrorHandlerType) -> ErrorHandlerType:
self.error_handlers[code] = f
return f
return decorator
| (self, code: int) -> Callable[[~ErrorHandlerType], ~ErrorHandlerType] |
7,631 | emmett.app | render_template | null | def render_template(self, filename: str) -> str:
ctx = {
'current': current, 'url': url, 'asis': asis,
'load_component': load_component
}
return self.templater.render(filename, ctx)
| (self, filename: str) -> str |
7,632 | emmett.app | route | null | def route(
self,
paths: Optional[Union[str, List[str]]] = None,
name: Optional[str] = None,
template: Optional[str] = None,
pipeline: Optional[List[Pipe]] = None,
injectors: Optional[List[Injector]] = None,
schemes: Optional[Union[str, List[str]]] = None,
hostname: Optional[str] = None,
methods: Optional[Union[str, List[str]]] = None,
prefix: Optional[str] = None,
template_folder: Optional[str] = None,
template_path: Optional[str] = None,
cache: Optional[RouteCacheRule] = None,
output: str = 'auto'
) -> RoutingCtx:
if callable(paths):
raise SyntaxError('Use @route(), not @route.')
return self._router_http(
paths=paths,
name=name,
template=template,
pipeline=pipeline,
injectors=injectors,
schemes=schemes,
hostname=hostname,
methods=methods,
prefix=prefix,
template_folder=template_folder,
template_path=template_path,
cache=cache,
output=output
)
| (self, paths: Union[str, List[str], NoneType] = None, name: Optional[str] = None, template: Optional[str] = None, pipeline: Optional[List[emmett.pipeline.Pipe]] = None, injectors: Optional[List[emmett.pipeline.Injector]] = None, schemes: Union[str, List[str], NoneType] = None, hostname: Optional[str] = None, methods: Union[str, List[str], NoneType] = None, prefix: Optional[str] = None, template_folder: Optional[str] = None, template_path: Optional[str] = None, cache: Optional[emmett.cache.RouteCacheRule] = None, output: str = 'auto') -> emmett.routing.router.RoutingCtx |
7,633 | emmett.app | send_signal | null | def send_signal(self, signal: Union[str, Signals], *args, **kwargs):
if not isinstance(signal, Signals):
warn_of_deprecation(
"App.send_signal str argument",
"extensions.Signals as argument",
stack=3
)
try:
signal = Signals[signal]
except KeyError:
raise SyntaxError(f"{signal} is not a valid signal")
for listener in self._extensions_listeners[signal]:
listener(*args, **kwargs)
| (self, signal: Union[str, emmett.extensions.Signals], *args, **kwargs) |
7,634 | emmett.app | test_client | null | def test_client(self, use_cookies: bool = True, **kwargs) -> EmmettTestClient:
tclass = self.test_client_class or EmmettTestClient
return tclass(self, use_cookies=use_cookies, **kwargs)
| (self, use_cookies: bool = True, **kwargs) -> emmett.testing.client.EmmettTestClient |
7,635 | emmett.app | use_extension | null | def use_extension(self, ext_cls: Type[ExtensionType]) -> ExtensionType:
if not issubclass(ext_cls, Extension):
raise RuntimeError(
f'{ext_cls.__name__} is an invalid Emmett extension'
)
ext_env, ext_config = self.__init_extension(ext_cls)
ext = self.ext[ext_cls.__name__] = ext_cls(self, ext_env, ext_config)
self.__register_extension_listeners(ext)
ext.on_load()
return ext
| (self, ext_cls: Type[~ExtensionType]) -> ~ExtensionType |
7,636 | emmett.app | use_template_extension | null | def use_template_extension(self, ext_cls, **config):
return self.templater.use_extension(ext_cls, **config)
| (self, ext_cls, **config) |
7,637 | emmett.app | websocket | null | def websocket(
self,
paths: Optional[Union[str, List[str]]] = None,
name: Optional[str] = None,
pipeline: Optional[List[Pipe]] = None,
schemes: Optional[Union[str, List[str]]] = None,
hostname: Optional[str] = None,
prefix: Optional[str] = None
) -> RoutingCtx:
if callable(paths):
raise SyntaxError('Use @websocket(), not @websocket.')
return self._router_ws(
paths=paths,
name=name,
pipeline=pipeline,
schemes=schemes,
hostname=hostname,
prefix=prefix
)
| (self, paths: Union[str, List[str], NoneType] = None, name: Optional[str] = None, pipeline: Optional[List[emmett.pipeline.Pipe]] = None, schemes: Union[str, List[str], NoneType] = None, hostname: Optional[str] = None, prefix: Optional[str] = None) -> emmett.routing.router.RoutingCtx |
7,638 | emmett.app | AppModule | null | class AppModule:
@classmethod
def from_app(
cls,
app: App,
import_name: str,
name: str,
template_folder: Optional[str],
template_path: Optional[str],
static_folder: Optional[str],
static_path: Optional[str],
url_prefix: Optional[str],
hostname: Optional[str],
cache: Optional[RouteCacheRule],
root_path: Optional[str],
pipeline: List[Pipe],
injectors: List[Injector],
opts: Dict[str, Any] = {}
):
return cls(
app,
name,
import_name,
template_folder=template_folder,
template_path=template_path,
static_folder=static_folder,
static_path=static_path,
url_prefix=url_prefix,
hostname=hostname,
cache=cache,
root_path=root_path,
pipeline=pipeline,
injectors=injectors,
**opts
)
@classmethod
def from_module(
cls,
appmod: AppModule,
import_name: str,
name: str,
template_folder: Optional[str],
template_path: Optional[str],
static_folder: Optional[str],
static_path: Optional[str],
url_prefix: Optional[str],
hostname: Optional[str],
cache: Optional[RouteCacheRule],
root_path: Optional[str],
opts: Dict[str, Any] = {}
):
if '.' in name:
raise RuntimeError(
"Nested app modules' names should not contains dots"
)
name = appmod.name + '.' + name
if url_prefix and not url_prefix.startswith('/'):
url_prefix = '/' + url_prefix
module_url_prefix = (appmod.url_prefix + (url_prefix or '')) \
if appmod.url_prefix else url_prefix
hostname = hostname or appmod.hostname
cache = cache or appmod.cache
return cls(
appmod.app,
name,
import_name,
template_folder=template_folder,
template_path=template_path,
static_folder=static_folder,
static_path=static_path,
url_prefix=module_url_prefix,
hostname=hostname,
cache=cache,
root_path=root_path,
pipeline=appmod.pipeline,
injectors=appmod.injectors,
**opts
)
@classmethod
def from_module_group(
cls,
appmodgroup: AppModuleGroup,
import_name: str,
name: str,
template_folder: Optional[str],
template_path: Optional[str],
static_folder: Optional[str],
static_path: Optional[str],
url_prefix: Optional[str],
hostname: Optional[str],
cache: Optional[RouteCacheRule],
root_path: Optional[str],
opts: Dict[str, Any] = {}
) -> AppModulesGrouped:
mods = []
for module in appmodgroup.modules:
mod = cls.from_module(
module,
import_name,
name,
template_folder=template_folder,
template_path=template_path,
static_folder=static_folder,
static_path=static_path,
url_prefix=url_prefix,
hostname=hostname,
cache=cache,
root_path=root_path,
opts=opts
)
mods.append(mod)
return AppModulesGrouped(*mods)
def module(
self,
import_name: str,
name: str,
template_folder: Optional[str] = None,
template_path: Optional[str] = None,
static_folder: Optional[str] = None,
static_path: Optional[str] = None,
url_prefix: Optional[str] = None,
hostname: Optional[str] = None,
cache: Optional[RouteCacheRule] = None,
root_path: Optional[str] = None,
module_class: Optional[Type[AppModule]] = None,
**kwargs: Any
) -> AppModule:
module_class = module_class or self.__class__
return module_class.from_module(
self,
import_name,
name,
template_folder=template_folder,
template_path=template_path,
static_folder=static_folder,
static_path=static_path,
url_prefix=url_prefix,
hostname=hostname,
cache=cache,
root_path=root_path,
opts=kwargs
)
def __init__(
self,
app: App,
name: str,
import_name: str,
template_folder: Optional[str] = None,
template_path: Optional[str] = None,
static_folder: Optional[str] = None,
static_path: Optional[str] = None,
url_prefix: Optional[str] = None,
hostname: Optional[str] = None,
cache: Optional[RouteCacheRule] = None,
root_path: Optional[str] = None,
pipeline: Optional[List[Pipe]] = None,
injectors: Optional[List[Injector]] = None,
**kwargs: Any
):
self.app = app
self.name = name
self.import_name = import_name
if root_path is None:
root_path = get_root_path(self.import_name)
self.root_path = root_path
#: - `template_folder` is referred to application `template_path`
# - `template_path` is referred to module root_directory unless absolute
self.template_folder = template_folder
if template_path and not template_path.startswith("/"):
template_path = os.path.join(self.root_path, template_path)
self.template_path = template_path
#: - `static_folder` is referred to application `static_path`
# - `static_path` is referred to module root_directory unless absolute
if static_path and not static_path.startswith("/"):
static_path = os.path.join(self.root_path, static_path)
self._static_path = (
os.path.join(self.app.static_path, static_folder) if static_folder else
(static_path or self.app.static_path)
)
self.url_prefix = url_prefix
self.hostname = hostname
self.cache = cache
self._super_pipeline = pipeline or []
self._super_injectors = injectors or []
self.pipeline = []
self.injectors = []
self.app._register_module(self)
@property
def pipeline(self) -> List[Pipe]:
return self._pipeline
@pipeline.setter
def pipeline(self, pipeline: List[Pipe]):
self._pipeline = self._super_pipeline + pipeline
@property
def injectors(self) -> List[Injector]:
return self._injectors
@injectors.setter
def injectors(self, injectors: List[Injector]):
self._injectors = self._super_injectors + injectors
def route(
self,
paths: Optional[Union[str, List[str]]] = None,
name: Optional[str] = None,
template: Optional[str] = None,
**kwargs
) -> RoutingCtx:
if name is not None and "." in name:
raise RuntimeError(
"App modules' route names should not contains dots"
)
name = self.name + "." + (name or "")
pipeline = kwargs.get('pipeline', [])
injectors = kwargs.get('injectors', [])
if self.pipeline:
pipeline = self.pipeline + pipeline
kwargs['pipeline'] = pipeline
if self.injectors:
injectors = self.injectors + injectors
kwargs['injectors'] = injectors
kwargs['cache'] = kwargs.get('cache', self.cache)
return self.app.route(
paths=paths,
name=name,
template=template,
prefix=self.url_prefix,
template_folder=self.template_folder,
template_path=self.template_path,
hostname=self.hostname,
**kwargs
)
def websocket(
self,
paths: Optional[Union[str, List[str]]] = None,
name: Optional[str] = None,
**kwargs
) -> RoutingCtx:
if name is not None and "." in name:
raise RuntimeError(
"App modules' websocket names should not contains dots"
)
name = self.name + "." + (name or "")
pipeline = kwargs.get('pipeline', [])
if self.pipeline:
pipeline = self.pipeline + pipeline
kwargs['pipeline'] = pipeline
return self.app.websocket(
paths=paths,
name=name,
prefix=self.url_prefix,
hostname=self.hostname,
**kwargs
)
| (app: 'App', name: 'str', import_name: 'str', template_folder: 'Optional[str]' = None, template_path: 'Optional[str]' = None, static_folder: 'Optional[str]' = None, static_path: 'Optional[str]' = None, url_prefix: 'Optional[str]' = None, hostname: 'Optional[str]' = None, cache: 'Optional[RouteCacheRule]' = None, root_path: 'Optional[str]' = None, pipeline: 'Optional[List[Pipe]]' = None, injectors: 'Optional[List[Injector]]' = None, **kwargs: 'Any') |
7,639 | emmett.app | __init__ | null | def __init__(
self,
app: App,
name: str,
import_name: str,
template_folder: Optional[str] = None,
template_path: Optional[str] = None,
static_folder: Optional[str] = None,
static_path: Optional[str] = None,
url_prefix: Optional[str] = None,
hostname: Optional[str] = None,
cache: Optional[RouteCacheRule] = None,
root_path: Optional[str] = None,
pipeline: Optional[List[Pipe]] = None,
injectors: Optional[List[Injector]] = None,
**kwargs: Any
):
self.app = app
self.name = name
self.import_name = import_name
if root_path is None:
root_path = get_root_path(self.import_name)
self.root_path = root_path
#: - `template_folder` is referred to application `template_path`
# - `template_path` is referred to module root_directory unless absolute
self.template_folder = template_folder
if template_path and not template_path.startswith("/"):
template_path = os.path.join(self.root_path, template_path)
self.template_path = template_path
#: - `static_folder` is referred to application `static_path`
# - `static_path` is referred to module root_directory unless absolute
if static_path and not static_path.startswith("/"):
static_path = os.path.join(self.root_path, static_path)
self._static_path = (
os.path.join(self.app.static_path, static_folder) if static_folder else
(static_path or self.app.static_path)
)
self.url_prefix = url_prefix
self.hostname = hostname
self.cache = cache
self._super_pipeline = pipeline or []
self._super_injectors = injectors or []
self.pipeline = []
self.injectors = []
self.app._register_module(self)
| (self, app: emmett.app.App, name: str, import_name: str, template_folder: Optional[str] = None, template_path: Optional[str] = None, static_folder: Optional[str] = None, static_path: Optional[str] = None, url_prefix: Optional[str] = None, hostname: Optional[str] = None, cache: Optional[emmett.cache.RouteCacheRule] = None, root_path: Optional[str] = None, pipeline: Optional[List[emmett.pipeline.Pipe]] = None, injectors: Optional[List[emmett.pipeline.Injector]] = None, **kwargs: Any) |
7,640 | emmett.app | module | null | def module(
self,
import_name: str,
name: str,
template_folder: Optional[str] = None,
template_path: Optional[str] = None,
static_folder: Optional[str] = None,
static_path: Optional[str] = None,
url_prefix: Optional[str] = None,
hostname: Optional[str] = None,
cache: Optional[RouteCacheRule] = None,
root_path: Optional[str] = None,
module_class: Optional[Type[AppModule]] = None,
**kwargs: Any
) -> AppModule:
module_class = module_class or self.__class__
return module_class.from_module(
self,
import_name,
name,
template_folder=template_folder,
template_path=template_path,
static_folder=static_folder,
static_path=static_path,
url_prefix=url_prefix,
hostname=hostname,
cache=cache,
root_path=root_path,
opts=kwargs
)
| (self, import_name: str, name: str, template_folder: Optional[str] = None, template_path: Optional[str] = None, static_folder: Optional[str] = None, static_path: Optional[str] = None, url_prefix: Optional[str] = None, hostname: Optional[str] = None, cache: Optional[emmett.cache.RouteCacheRule] = None, root_path: Optional[str] = None, module_class: Optional[Type[emmett.app.AppModule]] = None, **kwargs: Any) -> emmett.app.AppModule |
7,641 | emmett.app | route | null | def route(
self,
paths: Optional[Union[str, List[str]]] = None,
name: Optional[str] = None,
template: Optional[str] = None,
**kwargs
) -> RoutingCtx:
if name is not None and "." in name:
raise RuntimeError(
"App modules' route names should not contains dots"
)
name = self.name + "." + (name or "")
pipeline = kwargs.get('pipeline', [])
injectors = kwargs.get('injectors', [])
if self.pipeline:
pipeline = self.pipeline + pipeline
kwargs['pipeline'] = pipeline
if self.injectors:
injectors = self.injectors + injectors
kwargs['injectors'] = injectors
kwargs['cache'] = kwargs.get('cache', self.cache)
return self.app.route(
paths=paths,
name=name,
template=template,
prefix=self.url_prefix,
template_folder=self.template_folder,
template_path=self.template_path,
hostname=self.hostname,
**kwargs
)
| (self, paths: Union[str, List[str], NoneType] = None, name: Optional[str] = None, template: Optional[str] = None, **kwargs) -> emmett.routing.router.RoutingCtx |
7,642 | emmett.app | websocket | null | def websocket(
self,
paths: Optional[Union[str, List[str]]] = None,
name: Optional[str] = None,
**kwargs
) -> RoutingCtx:
if name is not None and "." in name:
raise RuntimeError(
"App modules' websocket names should not contains dots"
)
name = self.name + "." + (name or "")
pipeline = kwargs.get('pipeline', [])
if self.pipeline:
pipeline = self.pipeline + pipeline
kwargs['pipeline'] = pipeline
return self.app.websocket(
paths=paths,
name=name,
prefix=self.url_prefix,
hostname=self.hostname,
**kwargs
)
| (self, paths: Union[str, List[str], NoneType] = None, name: Optional[str] = None, **kwargs) -> emmett.routing.router.RoutingCtx |
7,643 | emmett.cache | Cache | null | class Cache:
def __init__(self, **kwargs):
#: load handlers
handlers = []
for key, val in kwargs.items():
if key == "default":
continue
handlers.append((key, val))
if not handlers:
handlers.append(('ram', RamCache()))
#: set handlers
for name, handler in handlers:
setattr(self, name, handler)
_default_handler_name = kwargs.get('default', handlers[0][0])
self._default_handler = getattr(self, _default_handler_name)
@overload
def __call__(
self,
key: Optional[str] = None,
function: None = None,
duration: Union[int, str, None] = 'default'
) -> CacheDecorator:
...
@overload
def __call__(
self,
key: str,
function: Optional[Callable[..., T]],
duration: Union[int, str, None] = 'default'
) -> T:
...
def __call__(
self,
key: Optional[str] = None,
function: Optional[Callable[..., T]] = None,
duration: Union[int, str, None] = 'default'
) -> Union[CacheDecorator, T]:
return self._default_handler(key, function, duration)
def get(self, key: str) -> Any:
return self._default_handler.get(key)
def set(
self,
key: str,
value: Any,
duration: Union[int, str, None] = 'default'
):
self._default_handler.set(key, value, duration)
def get_or_set(
self,
key: str,
function: Callable[..., T],
duration: Union[int, str, None] = 'default'
) -> T:
return self._default_handler.get_or_set(key, function, duration)
def clear(self, key: Optional[str] = None):
self._default_handler.clear(key)
def response(
self,
duration: Union[int, str, None] = 'default',
query_params: bool = True,
language: bool = True,
hostname: bool = False,
headers: List[str] = []
) -> RouteCacheRule:
return self._default_handler.response(
duration, query_params, language, hostname, headers
)
| (**kwargs) |
7,644 | emmett.cache | __call__ | null | def __call__(
self,
key: Optional[str] = None,
function: Optional[Callable[..., T]] = None,
duration: Union[int, str, None] = 'default'
) -> Union[CacheDecorator, T]:
return self._default_handler(key, function, duration)
| (self, key: Optional[str] = None, function: Optional[Callable[..., ~T]] = None, duration: Union[int, str, NoneType] = 'default') -> Union[emmett.cache.CacheDecorator, ~T] |
7,645 | emmett.cache | __init__ | null | def __init__(self, **kwargs):
#: load handlers
handlers = []
for key, val in kwargs.items():
if key == "default":
continue
handlers.append((key, val))
if not handlers:
handlers.append(('ram', RamCache()))
#: set handlers
for name, handler in handlers:
setattr(self, name, handler)
_default_handler_name = kwargs.get('default', handlers[0][0])
self._default_handler = getattr(self, _default_handler_name)
| (self, **kwargs) |
7,646 | emmett.cache | clear | null | def clear(self, key: Optional[str] = None):
self._default_handler.clear(key)
| (self, key: Optional[str] = None) |
7,647 | emmett.cache | get | null | def get(self, key: str) -> Any:
return self._default_handler.get(key)
| (self, key: str) -> Any |
7,648 | emmett.cache | get_or_set | null | def get_or_set(
self,
key: str,
function: Callable[..., T],
duration: Union[int, str, None] = 'default'
) -> T:
return self._default_handler.get_or_set(key, function, duration)
| (self, key: str, function: Callable[..., ~T], duration: Union[int, str, NoneType] = 'default') -> ~T |
7,649 | emmett.cache | response | null | def response(
self,
duration: Union[int, str, None] = 'default',
query_params: bool = True,
language: bool = True,
hostname: bool = False,
headers: List[str] = []
) -> RouteCacheRule:
return self._default_handler.response(
duration, query_params, language, hostname, headers
)
| (self, duration: Union[int, str, NoneType] = 'default', query_params: bool = True, language: bool = True, hostname: bool = False, headers: List[str] = []) -> emmett.cache.RouteCacheRule |
7,650 | emmett.cache | set | null | def set(
self,
key: str,
value: Any,
duration: Union[int, str, None] = 'default'
):
self._default_handler.set(key, value, duration)
| (self, key: str, value: Any, duration: Union[int, str, NoneType] = 'default') |
7,651 | emmett.orm.objects | Field | null | class Field(_Field):
_internal_types = {
'integer': 'int',
'double': 'float',
'boolean': 'bool',
'list:integer': 'list:int'
}
_pydal_types = {
'int': 'integer',
'bool': 'boolean',
'list:int': 'list:integer',
}
_internal_delete = {
'cascade': 'CASCADE', 'nullify': 'SET NULL', 'nothing': 'NO ACTION'
}
_inst_count_ = 0
_obj_created_ = False
def __init__(self, type='string', *args, **kwargs):
self.modelname = None
#: convert type
self._type = self._internal_types.get(type, type)
#: convert 'rw' -> 'readable', 'writeable'
if 'rw' in kwargs:
_rw = kwargs.pop('rw')
if isinstance(_rw, (tuple, list)):
read, write = _rw
else:
read = write = _rw
kwargs['readable'] = read
kwargs['writable'] = write
#: convert 'info' -> 'comment'
_info = kwargs.pop('info', None)
if _info:
kwargs['comment'] = _info
#: convert ondelete parameter
_ondelete = kwargs.get('ondelete')
if _ondelete:
if _ondelete not in list(self._internal_delete):
raise SyntaxError(
'Field ondelete should be set on %s, %s or %s' %
list(self._internal_delete)
)
kwargs['ondelete'] = self._internal_delete[_ondelete]
#: process 'refers_to' fields
self._isrefers = kwargs.pop('_isrefers', None)
#: get auto validation preferences
self._auto_validation = kwargs.pop('auto_validation', True)
#: intercept validation (will be processed by `_make_field`)
self._requires = {}
self._custom_requires = []
if 'validation' in kwargs:
_validation = kwargs.pop('validation')
if isinstance(_validation, dict):
self._requires = _validation
else:
self._custom_requires = _validation
if not isinstance(self._custom_requires, list):
self._custom_requires = [self._custom_requires]
self._validation = {}
self._vparser = ValidateFromDict()
#: ensure 'length' is an integer
if 'length' in kwargs:
kwargs['length'] = int(kwargs['length'])
#: store args and kwargs for `_make_field`
self._ormkw = kwargs.pop('_kw', {})
self._args = args
self._kwargs = kwargs
#: increase creation counter (used to keep order of fields)
self._inst_count_ = Field._inst_count_
Field._inst_count_ += 1
def _default_validation(self):
rv = {}
auto_types = [
'int', 'float', 'date', 'time', 'datetime', 'json'
]
if self._type in auto_types:
rv['is'] = self._type
elif self._type.startswith('decimal'):
rv['is'] = 'decimal'
elif self._type == 'jsonb':
rv['is'] = 'json'
if self._type == 'bigint':
rv['is'] = 'int'
if self._type == 'bool':
rv['in'] = (False, True)
if self._type in ['string', 'text', 'password']:
rv['len'] = {'lte': self.length}
if self._type == 'password':
rv['len']['gte'] = 6
rv['crypt'] = True
if self._type == 'list:int':
rv['is'] = 'list:int'
if (
self.notnull or self._type.startswith('reference') or
self._type.startswith('list:reference')
):
rv['presence'] = True
if not self.notnull and self._isrefers is True:
rv['allow'] = 'empty'
if self.unique:
rv['unique'] = True
return rv
def _parse_validation(self):
for key in list(self._requires):
self._validation[key] = self._requires[key]
self.requires = self._vparser(self, self._validation) + \
self._custom_requires
#: `_make_field` will be called by `Model` class or `Form` class
# it will make internal Field class compatible with the pyDAL's one
def _make_field(self, name, model=None):
if self._obj_created_:
return self
if model is not None:
self.modelname = model.__class__.__name__
#: convert field type to pyDAL ones if needed
ftype = self._pydal_types.get(self._type, self._type)
if ftype.startswith("geo") and model:
geometry_type = self._ormkw["geometry_type"]
srid = self._ormkw["srid"] or getattr(model.db._adapter, "srid", 4326)
dimension = self._ormkw["dimension"] or 2
ftype = f"{ftype}({geometry_type},{srid},{dimension})"
#: create pyDAL's Field instance
super(Field, self).__init__(name, ftype, *self._args, **self._kwargs)
#: add automatic validation (if requested)
if self._auto_validation:
auto = True
if self.modelname:
auto = model.auto_validation
if auto:
self._validation = self._default_validation()
#: validators
if not self.modelname:
self._parse_validation()
self._obj_created_ = True
return self
def __str__(self):
if self._obj_created_:
return super(Field, self).__str__()
return object.__str__(self)
def __repr__(self):
if self.modelname and hasattr(self, 'name'):
return "<%s.%s (%s) field>" % (self.modelname, self.name,
self._type)
return super(Field, self).__repr__()
@classmethod
def string(cls, *args, **kwargs):
return cls('string', *args, **kwargs)
@classmethod
def int(cls, *args, **kwargs):
return cls('int', *args, **kwargs)
@classmethod
def bigint(cls, *args, **kwargs):
return cls('bigint', *args, **kwargs)
@classmethod
def float(cls, *args, **kwargs):
return cls('float', *args, **kwargs)
@classmethod
def text(cls, *args, **kwargs):
return cls('text', *args, **kwargs)
@classmethod
def bool(cls, *args, **kwargs):
return cls('bool', *args, **kwargs)
@classmethod
def blob(cls, *args, **kwargs):
return cls('blob', *args, **kwargs)
@classmethod
def date(cls, *args, **kwargs):
return cls('date', *args, **kwargs)
@classmethod
def time(cls, *args, **kwargs):
return cls('time', *args, **kwargs)
@classmethod
def datetime(cls, *args, **kwargs):
return cls('datetime', *args, **kwargs)
@classmethod
def decimal(cls, precision, scale, *args, **kwargs):
return cls('decimal({},{})'.format(precision, scale), *args, **kwargs)
@classmethod
def json(cls, *args, **kwargs):
return cls('json', *args, **kwargs)
@classmethod
def jsonb(cls, *args, **kwargs):
return cls('jsonb', *args, **kwargs)
@classmethod
def password(cls, *args, **kwargs):
return cls('password', *args, **kwargs)
@classmethod
def upload(cls, *args, **kwargs):
return cls('upload', *args, **kwargs)
@classmethod
def int_list(cls, *args, **kwargs):
return cls('list:int', *args, **kwargs)
@classmethod
def string_list(cls, *args, **kwargs):
return cls('list:string', *args, **kwargs)
@classmethod
def geography(
cls,
geometry_type: str = 'GEOMETRY',
srid: Optional[type_int] = None,
dimension: Optional[type_int] = None,
**kwargs
):
kwargs['_kw'] = {
"geometry_type": geometry_type,
"srid": srid,
"dimension": dimension
}
return cls("geography", **kwargs)
@classmethod
def geometry(
cls,
geometry_type: str = 'GEOMETRY',
srid: Optional[type_int] = None,
dimension: Optional[type_int] = None,
**kwargs
):
kwargs['_kw'] = {
"geometry_type": geometry_type,
"srid": srid,
"dimension": dimension
}
return cls("geometry", **kwargs)
def cast(self, value, **kwargs):
return Expression(
self.db, self._dialect.cast, self,
self._dialect.types[value] % kwargs, value)
| (type='string', *args, **kwargs) |
7,652 | pydal.objects | __add__ | null | def __add__(self, other):
return Expression(self.db, self._dialect.add, self, other, self.type)
| (self, other) |
7,653 | pydal.objects | __bool__ | null | def __bool__(self):
return True
| (self) |
7,654 | pydal.objects | __div__ | null | def __div__(self, other):
return Expression(self.db, self._dialect.div, self, other, self.type)
| (self, other) |
7,655 | pydal.objects | __eq__ | null | def __eq__(self, value):
return Query(self.db, self._dialect.eq, self, value)
| (self, value) |
7,656 | pydal.objects | __ge__ | null | def __ge__(self, value):
return Query(self.db, self._dialect.gte, self, value)
| (self, value) |
7,657 | pydal.objects | __getitem__ | null | def __getitem__(self, i):
if isinstance(i, slice):
start = i.start or 0
stop = i.stop
db = self.db
if start < 0:
pos0 = '(%s - %d)' % (self.len(), abs(start) - 1)
else:
pos0 = start + 1
maxint = sys.maxint if PY2 else sys.maxsize
if stop is None or stop == maxint:
length = self.len()
elif stop < 0:
length = '(%s - %d - %s)' % (self.len(), abs(stop) - 1, pos0)
else:
length = '(%s - %s)' % (stop + 1, pos0)
return Expression(db, self._dialect.substring,
self, (pos0, length), self.type)
else:
return self[i:i + 1]
| (self, i) |
7,658 | pydal.objects | __gt__ | null | def __gt__(self, value):
return Query(self.db, self._dialect.gt, self, value)
| (self, value) |
7,659 | pydal.objects | __hash__ | null | def __hash__(self):
return id(self)
| (self) |
7,660 | emmett.orm.objects | __init__ | null | def __init__(self, type='string', *args, **kwargs):
self.modelname = None
#: convert type
self._type = self._internal_types.get(type, type)
#: convert 'rw' -> 'readable', 'writeable'
if 'rw' in kwargs:
_rw = kwargs.pop('rw')
if isinstance(_rw, (tuple, list)):
read, write = _rw
else:
read = write = _rw
kwargs['readable'] = read
kwargs['writable'] = write
#: convert 'info' -> 'comment'
_info = kwargs.pop('info', None)
if _info:
kwargs['comment'] = _info
#: convert ondelete parameter
_ondelete = kwargs.get('ondelete')
if _ondelete:
if _ondelete not in list(self._internal_delete):
raise SyntaxError(
'Field ondelete should be set on %s, %s or %s' %
list(self._internal_delete)
)
kwargs['ondelete'] = self._internal_delete[_ondelete]
#: process 'refers_to' fields
self._isrefers = kwargs.pop('_isrefers', None)
#: get auto validation preferences
self._auto_validation = kwargs.pop('auto_validation', True)
#: intercept validation (will be processed by `_make_field`)
self._requires = {}
self._custom_requires = []
if 'validation' in kwargs:
_validation = kwargs.pop('validation')
if isinstance(_validation, dict):
self._requires = _validation
else:
self._custom_requires = _validation
if not isinstance(self._custom_requires, list):
self._custom_requires = [self._custom_requires]
self._validation = {}
self._vparser = ValidateFromDict()
#: ensure 'length' is an integer
if 'length' in kwargs:
kwargs['length'] = int(kwargs['length'])
#: store args and kwargs for `_make_field`
self._ormkw = kwargs.pop('_kw', {})
self._args = args
self._kwargs = kwargs
#: increase creation counter (used to keep order of fields)
self._inst_count_ = Field._inst_count_
Field._inst_count_ += 1
| (self, type='string', *args, **kwargs) |
7,661 | pydal.objects | __invert__ | null | def __invert__(self):
if hasattr(self, '_op') and self.op == self._dialect.invert:
return self.first
return Expression(self.db, self._dialect.invert, self, type=self.type)
| (self) |
7,662 | pydal.objects | __le__ | null | def __le__(self, value):
return Query(self.db, self._dialect.lte, self, value)
| (self, value) |
7,663 | pydal.objects | __lt__ | null | def __lt__(self, value):
return Query(self.db, self._dialect.lt, self, value)
| (self, value) |
7,664 | pydal.objects | __mod__ | null | def __mod__(self, other):
return Expression(self.db, self._dialect.mod, self, other, self.type)
| (self, other) |
7,665 | pydal.objects | __mul__ | null | def __mul__(self, other):
return Expression(self.db, self._dialect.mul, self, other, self.type)
| (self, other) |
7,666 | pydal.objects | __ne__ | null | def __ne__(self, value):
return Query(self.db, self._dialect.ne, self, value)
| (self, value) |
7,667 | pydal.objects | __new__ | null | def __new__(cls, *args, **kwargs):
for name, wrapper in iteritems(cls._dialect_expressions_):
setattr(cls, name, _expression_wrap(wrapper))
new_cls = super(Expression, cls).__new__(cls)
return new_cls
| (cls, *args, **kwargs) |
7,668 | pydal.objects | __or__ | null | def __or__(self, other): # for use in sortby
return Expression(self.db, self._dialect.comma, self, other, self.type)
| (self, other) |
7,669 | emmett.orm.objects | __repr__ | null | def __repr__(self):
if self.modelname and hasattr(self, 'name'):
return "<%s.%s (%s) field>" % (self.modelname, self.name,
self._type)
return super(Field, self).__repr__()
| (self) |
7,670 | emmett.orm.objects | __str__ | null | def __str__(self):
if self._obj_created_:
return super(Field, self).__str__()
return object.__str__(self)
| (self) |
7,671 | pydal.objects | __sub__ | null | def __sub__(self, other):
if self.type in ('integer', 'bigint'):
result_type = 'integer'
elif self.type in ['date', 'time', 'datetime', 'double', 'float']:
result_type = 'double'
elif self.type.startswith('decimal('):
result_type = self.type
else:
raise SyntaxError("subtraction operation not supported for type")
return Expression(self.db, self._dialect.sub, self, other, result_type)
| (self, other) |
7,672 | pydal.objects | __truediv__ | null | def __truediv__(self, other):
return self.__div__(other)
| (self, other) |
7,673 | emmett.orm.objects | _default_validation | null | def _default_validation(self):
rv = {}
auto_types = [
'int', 'float', 'date', 'time', 'datetime', 'json'
]
if self._type in auto_types:
rv['is'] = self._type
elif self._type.startswith('decimal'):
rv['is'] = 'decimal'
elif self._type == 'jsonb':
rv['is'] = 'json'
if self._type == 'bigint':
rv['is'] = 'int'
if self._type == 'bool':
rv['in'] = (False, True)
if self._type in ['string', 'text', 'password']:
rv['len'] = {'lte': self.length}
if self._type == 'password':
rv['len']['gte'] = 6
rv['crypt'] = True
if self._type == 'list:int':
rv['is'] = 'list:int'
if (
self.notnull or self._type.startswith('reference') or
self._type.startswith('list:reference')
):
rv['presence'] = True
if not self.notnull and self._isrefers is True:
rv['allow'] = 'empty'
if self.unique:
rv['unique'] = True
return rv
| (self) |
7,674 | emmett.orm.objects | _make_field | null | def _make_field(self, name, model=None):
if self._obj_created_:
return self
if model is not None:
self.modelname = model.__class__.__name__
#: convert field type to pyDAL ones if needed
ftype = self._pydal_types.get(self._type, self._type)
if ftype.startswith("geo") and model:
geometry_type = self._ormkw["geometry_type"]
srid = self._ormkw["srid"] or getattr(model.db._adapter, "srid", 4326)
dimension = self._ormkw["dimension"] or 2
ftype = f"{ftype}({geometry_type},{srid},{dimension})"
#: create pyDAL's Field instance
super(Field, self).__init__(name, ftype, *self._args, **self._kwargs)
#: add automatic validation (if requested)
if self._auto_validation:
auto = True
if self.modelname:
auto = model.auto_validation
if auto:
self._validation = self._default_validation()
#: validators
if not self.modelname:
self._parse_validation()
self._obj_created_ = True
return self
| (self, name, model=None) |
7,675 | emmett.orm.objects | _parse_validation | null | def _parse_validation(self):
for key in list(self._requires):
self._validation[key] = self._requires[key]
self.requires = self._vparser(self, self._validation) + \
self._custom_requires
| (self) |
7,676 | pydal.objects | abs | null | def abs(self):
return Expression(
self.db, self._dialect.aggregate, self, 'ABS', self.type)
| (self) |
7,677 | pydal.objects | as_dict | null | def as_dict(self, flat=False, sanitize=True):
attrs = (
'name', 'authorize', 'represent', 'ondelete',
'custom_store', 'autodelete', 'custom_retrieve',
'filter_out', 'uploadseparate', 'widget', 'uploadfs',
'update', 'custom_delete', 'uploadfield', 'uploadfolder',
'custom_qualifier', 'unique', 'writable', 'compute',
'map_none', 'default', 'type', 'required', 'readable',
'requires', 'comment', 'label', 'length', 'notnull',
'custom_retrieve_file_properties', 'filter_in')
serializable = (int, long, basestring, float, tuple,
bool, type(None))
def flatten(obj):
if isinstance(obj, dict):
return dict((flatten(k), flatten(v)) for k, v in obj.items())
elif isinstance(obj, (tuple, list, set)):
return [flatten(v) for v in obj]
elif isinstance(obj, serializable):
return obj
elif isinstance(obj, (datetime.datetime,
datetime.date, datetime.time)):
return str(obj)
else:
return None
d = dict()
if not (sanitize and not (self.readable or self.writable)):
for attr in attrs:
if flat:
d.update({attr: flatten(getattr(self, attr))})
else:
d.update({attr: getattr(self, attr)})
d["fieldname"] = d.pop("name")
return d
| (self, flat=False, sanitize=True) |
7,678 | pydal.helpers.classes | as_json | null | def as_json(self, sanitize=True):
return serializers.json(self.as_dict(flat=True, sanitize=sanitize))
| (self, sanitize=True) |
7,679 | pydal.helpers.classes | as_xml | null | def as_xml(self, sanitize=True):
return serializers.xml(self.as_dict(flat=True, sanitize=sanitize))
| (self, sanitize=True) |
7,680 | pydal.helpers.classes | as_yaml | null | def as_yaml(self, sanitize=True):
return serializers.yaml(self.as_dict(flat=True, sanitize=sanitize))
| (self, sanitize=True) |
7,681 | pydal.objects | avg | null | def avg(self):
return Expression(
self.db, self._dialect.aggregate, self, 'AVG', self.type)
| (self) |
7,682 | pydal.objects | belongs |
Accepts the following inputs::
field.belongs(1, 2)
field.belongs((1, 2))
field.belongs(query)
Does NOT accept:
field.belongs(1)
If the set you want back includes `None` values, you can do::
field.belongs((1, None), null=True)
| def belongs(self, *value, **kwattr):
"""
Accepts the following inputs::
field.belongs(1, 2)
field.belongs((1, 2))
field.belongs(query)
Does NOT accept:
field.belongs(1)
If the set you want back includes `None` values, you can do::
field.belongs((1, None), null=True)
"""
db = self.db
if len(value) == 1:
value = value[0]
if isinstance(value, Query):
value = db(value)._select(value.first._table._id)
elif not isinstance(value, (Select, basestring)):
value = set(value)
if kwattr.get('null') and None in value:
value.remove(None)
return (self == None) | Query(
self.db, self._dialect.belongs, self, value)
return Query(self.db, self._dialect.belongs, self, value)
| (self, *value, **kwattr) |
7,683 | pydal.objects | bind | null | def bind(self, table):
if self._table is not None:
raise ValueError(
'Field %s is already bound to a table' % self.longname)
self.db = self._db = table._db
self.table = self._table = table
self.tablename = self._tablename = table._tablename
if self._db and self._rname is None:
self._rname = self._db._adapter.sqlsafe_field(self.name)
self._raw_rname = self.name
| (self, table) |
7,684 | emmett.orm.objects | cast | null | def cast(self, value, **kwargs):
return Expression(
self.db, self._dialect.cast, self,
self._dialect.types[value] % kwargs, value)
| (self, value, **kwargs) |
7,685 | pydal.objects | clone | null | def clone(self, point_self_references_to=False, **args):
field = copy.copy(self)
if point_self_references_to and \
self.type == 'reference %s' % self._tablename:
field.type = 'reference %s' % point_self_references_to
field.__dict__.update(args)
field.db = field._db = None
field.table = field._table = None
field.tablename = field._tablename = None
if self._db and \
self._rname == self._db._adapter.sqlsafe_field(self.name):
# Reset the name because it may need to be requoted by bind()
field._rname = field._raw_rname = None
return field
| (self, point_self_references_to=False, **args) |
7,686 | pydal.objects | coalesce | null | def coalesce(self, *others):
return Expression(
self.db, self._dialect.coalesce, self, others, self.type)
| (self, *others) |
7,687 | pydal.objects | coalesce_zero | null | def coalesce_zero(self):
return Expression(
self.db, self._dialect.coalesce_zero, self, None, self.type)
| (self) |
7,688 | pydal.objects | contains |
For GAE contains() is always case sensitive
| def contains(self, value, all=False, case_sensitive=False):
"""
For GAE contains() is always case sensitive
"""
if isinstance(value, (list, tuple)):
subqueries = [self.contains(str(v), case_sensitive=case_sensitive)
for v in value if str(v)]
if not subqueries:
return self.contains('')
else:
return reduce(all and AND or OR, subqueries)
if self.type not in ('string', 'text', 'json', 'upload') and not \
self.type.startswith('list:'):
raise SyntaxError("contains used with incompatible field type")
return Query(
self.db, self._dialect.contains, self, value,
case_sensitive=case_sensitive)
| (self, value, all=False, case_sensitive=False) |
7,689 | pydal.objects | count | null | def count(self, distinct=None):
return Expression(
self.db, self._dialect.count, self, distinct, 'integer')
| (self, distinct=None) |
7,690 | pydal.objects | day | null | def day(self):
return Expression(
self.db, self._dialect.extract, self, 'day', 'integer')
| (self) |
7,691 | pydal.objects | endswith | null | def endswith(self, value):
if self.type not in ('string', 'text', 'json', 'upload'):
raise SyntaxError("endswith used with incompatible field type")
return Query(self.db, self._dialect.endswith, self, value)
| (self, value) |
7,692 | pydal.objects | epoch | null | def epoch(self):
return Expression(
self.db, self._dialect.epoch, self, None, 'integer')
| (self) |
7,693 | pydal.objects | formatter | null | def formatter(self, value):
requires = self.requires
if value is None:
return self.map_none
if not requires:
return value
if not isinstance(requires, (list, tuple)):
requires = [requires]
elif isinstance(requires, tuple):
requires = list(requires)
else:
requires = copy.copy(requires)
requires.reverse()
for item in requires:
if hasattr(item, 'formatter'):
value = item.formatter(value)
return value
| (self, value) |
7,694 | pydal.objects | hour | null | def hour(self):
return Expression(
self.db, self._dialect.extract, self, 'hour', 'integer')
| (self) |
7,695 | pydal.objects | ilike | null | def ilike(self, value, escape=None):
return self.like(value, case_sensitive=False, escape=escape)
| (self, value, escape=None) |
7,696 | pydal.objects | len | null | def len(self):
return Expression(
self.db, self._dialect.length, self, None, 'integer')
| (self) |
7,697 | pydal.objects | like | null | def like(self, value, case_sensitive=True, escape=None):
op = case_sensitive and self._dialect.like or self._dialect.ilike
return Query(self.db, op, self, value, escape=escape)
| (self, value, case_sensitive=True, escape=None) |
7,698 | pydal.objects | lower | null | def lower(self):
return Expression(
self.db, self._dialect.lower, self, None, self.type)
| (self) |
7,699 | pydal.objects | max | null | def max(self):
return Expression(
self.db, self._dialect.aggregate, self, 'MAX', self.type)
| (self) |
7,700 | pydal.objects | min | null | def min(self):
return Expression(
self.db, self._dialect.aggregate, self, 'MIN', self.type)
| (self) |
7,701 | pydal.objects | minutes | null | def minutes(self):
return Expression(
self.db, self._dialect.extract, self, 'minute', 'integer')
| (self) |
7,702 | pydal.objects | month | null | def month(self):
return Expression(
self.db, self._dialect.extract, self, 'month', 'integer')
| (self) |
7,703 | pydal.objects | regexp | null | def regexp(self, value):
return Query(self.db, self._dialect.regexp, self, value)
| (self, value) |
7,704 | pydal.objects | replace | null | def replace(self, a, b):
return Expression(
self.db, self._dialect.replace, self, (a, b), self.type)
| (self, a, b) |
7,705 | pydal.objects | retrieve |
If `nameonly==True` return (filename, fullfilename) instead of
(filename, stream)
| def retrieve(self, name, path=None, nameonly=False):
"""
If `nameonly==True` return (filename, fullfilename) instead of
(filename, stream)
"""
self_uploadfield = self.uploadfield
if self.custom_retrieve:
return self.custom_retrieve(name, path)
if self.authorize or isinstance(self_uploadfield, str):
row = self.db(self == name).select().first()
if not row:
raise NotFoundException
if self.authorize and not self.authorize(row):
raise NotAuthorizedException
file_properties = self.retrieve_file_properties(name, path)
filename = file_properties['filename']
if isinstance(self_uploadfield, str): # ## if file is in DB
stream = BytesIO(to_bytes(row[self_uploadfield] or ''))
elif isinstance(self_uploadfield, Field):
blob_uploadfield_name = self_uploadfield.uploadfield
query = self_uploadfield == name
data = self_uploadfield.table(query)[blob_uploadfield_name]
stream = BytesIO(to_bytes(data))
elif self.uploadfs:
# ## if file is on pyfilesystem
stream = self.uploadfs.open(name, 'rb')
else:
# ## if file is on regular filesystem
# this is intentially a sting with filename and not a stream
# this propagates and allows stream_file_or_304_or_206 to be called
fullname = pjoin(file_properties['path'], name)
if nameonly:
return (filename, fullname)
stream = open(fullname, 'rb')
return (filename, stream)
| (self, name, path=None, nameonly=False) |
7,706 | pydal.objects | retrieve_file_properties | null | def retrieve_file_properties(self, name, path=None):
m = REGEX_UPLOAD_PATTERN.match(name)
if not m or not self.isattachment:
raise TypeError('Can\'t retrieve %s file properties' % name)
self_uploadfield = self.uploadfield
if self.custom_retrieve_file_properties:
return self.custom_retrieve_file_properties(name, path)
if m.group('name'):
try:
filename = base64.b16decode(m.group('name'), True).decode('utf-8')
filename = REGEX_CLEANUP_FN.sub('_', filename)
except (TypeError, AttributeError):
filename = name
else:
filename = name
# ## if file is in DB
if isinstance(self_uploadfield, (str, Field)):
return dict(path=None, filename=filename)
# ## if file is on filesystem
if not path:
if self.uploadfolder:
path = self.uploadfolder
else:
path = pjoin(self.db._adapter.folder, '..', 'uploads')
if self.uploadseparate:
t = m.group('table')
f = m.group('field')
u = m.group('uuidkey')
path = pjoin(path, "%s.%s" % (t, f), u[:2])
return dict(path=path, filename=filename)
| (self, name, path=None) |
7,707 | pydal.objects | seconds | null | def seconds(self):
return Expression(
self.db, self._dialect.extract, self, 'second', 'integer')
| (self) |
7,708 | pydal.objects | set_attributes | null | def set_attributes(self, *args, **attributes):
self.__dict__.update(*args, **attributes)
| (self, *args, **attributes) |
7,709 | pydal.objects | st_asgeojson | null | def st_asgeojson(self, precision=15, options=0, version=1):
return Expression(self.db, self.db._adapter.ST_ASGEOJSON, self,
dict(precision=precision, options=options,
version=version), 'string')
| (self, precision=15, options=0, version=1) |
7,710 | pydal.objects | st_astext | null | def st_astext(self):
return Expression(
self.db, self._dialect.st_astext, self, type='string')
| (self) |
7,711 | pydal.objects | st_contains | null | def st_contains(self, value):
return Query(self.db, self._dialect.st_contains, self, value)
| (self, value) |
7,712 | pydal.objects | st_distance | null | def st_distance(self, other):
return Expression(
self.db, self._dialect.st_distance, self, other, 'double')
| (self, other) |
7,713 | pydal.objects | st_dwithin | null | def st_dwithin(self, value, distance):
return Query(
self.db, self._dialect.st_dwithin, self, (value, distance))
| (self, value, distance) |
7,714 | pydal.objects | st_equals | null | def st_equals(self, value):
return Query(self.db, self._dialect.st_equals, self, value)
| (self, value) |
7,715 | pydal.objects | st_intersects | null | def st_intersects(self, value):
return Query(self.db, self._dialect.st_intersects, self, value)
| (self, value) |
7,716 | pydal.objects | st_overlaps | null | def st_overlaps(self, value):
return Query(self.db, self._dialect.st_overlaps, self, value)
| (self, value) |
7,717 | pydal.objects | st_simplify | null | def st_simplify(self, value):
return Expression(
self.db, self._dialect.st_simplify, self, value, self.type)
| (self, value) |
7,718 | pydal.objects | st_simplifypreservetopology | null | def st_simplifypreservetopology(self, value):
return Expression(
self.db, self._dialect.st_simplifypreservetopology, self, value,
self.type)
| (self, value) |
7,719 | pydal.objects | st_touches | null | def st_touches(self, value):
return Query(self.db, self._dialect.st_touches, self, value)
| (self, value) |
7,720 | pydal.objects | st_within | null | def st_within(self, value):
return Query(self.db, self._dialect.st_within, self, value)
| (self, value) |
7,721 | pydal.objects | st_x | null | def st_x(self):
return Expression(self.db, self._dialect.st_x, self, type='string')
| (self) |
7,722 | pydal.objects | st_y | null | def st_y(self):
return Expression(self.db, self._dialect.st_y, self, type='string')
| (self) |
7,723 | pydal.objects | startswith | null | def startswith(self, value):
if self.type not in ('string', 'text', 'json', 'upload'):
raise SyntaxError("startswith used with incompatible field type")
return Query(self.db, self._dialect.startswith, self, value)
| (self, value) |
7,724 | pydal.objects | store | null | def store(self, file, filename=None, path=None):
# make sure filename is a str sequence
filename = "{}".format(filename)
if self.custom_store:
return self.custom_store(file, filename, path)
if isinstance(file, cgi.FieldStorage):
filename = filename or file.filename
file = file.file
elif not filename:
filename = file.name
filename = os.path.basename(
filename.replace('/', os.sep).replace('\\', os.sep))
m = REGEX_STORE_PATTERN.search(filename)
extension = m and m.group('e') or 'txt'
uuid_key = self._db.uuid().replace('-', '')[-16:]
encoded_filename = to_native(
base64.b16encode(to_bytes(filename)).lower())
newfilename = '%s.%s.%s.%s' % (
self._tablename, self.name, uuid_key, encoded_filename)
newfilename = newfilename[:(self.length - 1 - len(extension))] + \
'.' + extension
self_uploadfield = self.uploadfield
if isinstance(self_uploadfield, Field):
blob_uploadfield_name = self_uploadfield.uploadfield
keys = {self_uploadfield.name: newfilename,
blob_uploadfield_name: file.read()}
self_uploadfield.table.insert(**keys)
elif self_uploadfield is True:
if self.uploadfs:
dest_file = self.uploadfs.open(newfilename, 'wb')
else:
if path:
pass
elif self.uploadfolder:
path = self.uploadfolder
elif self.db._adapter.folder:
path = pjoin(self.db._adapter.folder, '..', 'uploads')
else:
raise RuntimeError(
"you must specify a Field(..., uploadfolder=...)")
if self.uploadseparate:
if self.uploadfs:
raise RuntimeError("not supported")
path = pjoin(path, "%s.%s" % (
self._tablename, self.name), uuid_key[:2]
)
if not exists(path):
os.makedirs(path)
pathfilename = pjoin(path, newfilename)
dest_file = open(pathfilename, 'wb')
try:
shutil.copyfileobj(file, dest_file)
except IOError:
raise IOError(
'Unable to store file "%s" because invalid permissions, '
'readonly file system, or filename too long' %
pathfilename)
dest_file.close()
return newfilename
| (self, file, filename=None, path=None) |
7,725 | pydal.objects | sum | null | def sum(self):
return Expression(
self.db, self._dialect.aggregate, self, 'SUM', self.type)
| (self) |
Subsets and Splits