Module smartapp.api.smartapp.configuration

Classes

class Option (name, id)

dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)

Expand source code

class Option(dict):

    def __init__(self, name, id):
        super().__init__()
        self['name'] = name
        self['id'] = id

Ancestors

• builtins.dict

class Page (*args, **kwargs)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class Page(models.smartapp.PageData):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.sections = []

    def section(self, name=None) -> List[Section]:
        self.sections.append(Section(name=name))
        return self.sections[len(self.sections)-1]

Ancestors

• PageData
• pydantic.main.BaseModel
• pydantic.utils.Representation

Class variables

var complete : bool

var name : str

var nextPageId : Optional[str]

var pageId : str

var previousPageId : Optional[str]

var sections : Optional[List[PageSection]]

Methods

def section(self, name=None) ‑> List[Section]

Expand source code

def section(self, name=None) -> List[Section]:
    self.sections.append(Section(name=name))
    return self.sections[len(self.sections)-1]

class Route (verb: str, path: str, func: str)

Expand source code

class Route(object):

    def __init__(self, verb: str, path: str, func: str):
        self.verb = verb
        self.path = path
        self.func = func
        self.app  = None
        self.auth = None

    def set_auth_handler(self, func: str) -> type[Route]:
        self.auth = func
        return self

    def register(self):
        handler = getattr(self.app, self.func)
        path = '/{}{}'.format(self.app.app_id, self.path)

        kwargs = {'path': path,
                  'methods': [self.verb],
                  'endpoint': handler}

        if self.auth:
            auth = getattr(self.app, self.auth)
            auth = fastapi.Depends(auth)
            kwargs.update({'dependencies': [auth]})
        router.add_route(**kwargs)

Methods

def register(self)

Expand source code

def register(self):
    handler = getattr(self.app, self.func)
    path = '/{}{}'.format(self.app.app_id, self.path)

    kwargs = {'path': path,
              'methods': [self.verb],
              'endpoint': handler}

    if self.auth:
        auth = getattr(self.app, self.auth)
        auth = fastapi.Depends(auth)
        kwargs.update({'dependencies': [auth]})
    router.add_route(**kwargs)

def set_auth_handler(self, func: str) ‑> type[Route]

Expand source code

def set_auth_handler(self, func: str) -> type[Route]:
    self.auth = func
    return self

class Section (*args, **kwargs)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class Section(models.smartapp.PageSection):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.settings = []

    def setting(self, name: str, id: str, type: models.smartapp.PageSettingType,
                 multiple: bool=False, required: bool=True) -> List[Setting]:
        self.settings.append(
                Setting(name=name, id=id, type=type, multiple=multiple, required=required)
        )
        return self.settings[len(self.settings)-1]

Ancestors

• PageSection
• pydantic.main.BaseModel
• pydantic.utils.Representation

Class variables

var name : str

var settings : Optional[List[PageSetting]]

Methods

def setting(self, name: str, id: str, type: models.smartapp.PageSettingType, multiple: bool = False, required: bool = True) ‑> List[Setting]

Expand source code

def setting(self, name: str, id: str, type: models.smartapp.PageSettingType,
             multiple: bool=False, required: bool=True) -> List[Setting]:
    self.settings.append(
            Setting(name=name, id=id, type=type, multiple=multiple, required=required)
    )
    return self.settings[len(self.settings)-1]

class Setting (*args, **kwargs)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class Setting(models.smartapp.PageSetting):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.options = []
        self.permissions = []

    def option(self, name=None, id=None) -> List[Option]:
        self.options.append(Option(name, id))
        self.options[len(self.options)-1]
        return self

    def has_multiple(self, val: bool) -> type[Setting]:
        self.multiple = val
        return self

    def capabilities(self, val: List[str]) -> type[Setting]:
        self.capabilities = val
        return self

Ancestors

• PageSetting
• pydantic.main.BaseModel
• pydantic.utils.Representation

Class variables

var capabilities : Optional[List[str]]

var description : Optional[str]

var id : str

var multiple : bool

var name : str

var options : Optional[List[Option]]

var permissions : Optional[List[str]]

var required : bool

var type : SettingType

Methods

def has_multiple(self, val: bool) ‑> type[Setting]

Expand source code

def has_multiple(self, val: bool) -> type[Setting]:
    self.multiple = val
    return self

def option(self, name=None, id=None) ‑> List[Option]

Expand source code

def option(self, name=None, id=None) -> List[Option]:
    self.options.append(Option(name, id))
    self.options[len(self.options)-1]
    return self