python - una - Estructura de botella y OOP, utilizando método en lugar de función

try except python ejemplos

Question

He hecho algo de codificación con Bottle. Es realmente simple y se ajusta a mis necesidades. Sin embargo, obtuve un palo cuando intenté envolver la aplicación en una clase:

import bottle
app = bottle

class App():
    def __init__(self,param):
        self.param   = param

    # Doesn''t work
    @app.route("/1")
    def index1(self):
        return("I''m 1 | self.param = %s" % self.param)

    # Doesn''t work
    @app.route("/2")
    def index2(self):
        return("I''m 2")

    # Works fine
    @app.route("/3")
    def index3():
        return("I''m 3")

¿Es posible utilizar métodos en lugar de funciones en Botella?

Answer 1

A continuación, funciona bien para mí :) Bastante orientado a objetos y fácil de seguir.

from bottle import Bottle, template

class Server:
    def __init__(self, host, port):
        self._host = host
        self._port = port
        self._app = Bottle()
        self._route()

    def _route(self):
        self._app.route(''/'', method="GET", callback=self._index)
        self._app.route(''/hello/<name>'', callback=self._hello)

    def start(self):
        self._app.run(host=self._host, port=self._port)

    def _index(self):
        return ''Welcome''

    def _hello(self, name="Guest"):
        return template(''Hello {{name}}, how are you?'', name=name)

server = Server(host=''localhost'', port=8090)
server.start()

Answer 2

Respondí @Skirmantas y lo modifiqué un poco para permitir argumentos de palabras clave en el decorador, como método, omisión, etc.

def routemethod(route, **kwargs):
    def decorator(f):
        f.route = route
        for arg in kwargs:
            setattr(f, arg, kwargs[arg])
        return f
    return decorator

def routeapp(obj):
    for kw in dir(obj):
        attr = getattr(obj, kw)
        if hasattr(attr, "route"):
            if hasattr(attr, "method"):
                method = getattr(attr, "method")
            else:
                method = "GET"
            if hasattr(attr, "callback"):
                callback = getattr(attr, "callback")
            else:
                callback = None
            if hasattr(attr, "name"):
                name = getattr(attr, "name")
            else:
                name = None
            if hasattr(attr, "apply"):
                aply = getattr(attr, "apply")
            else:
                aply = None
            if hasattr(attr, "skip"):
                skip = getattr(attr, "skip")
            else:
                skip = None

            bottle.route(attr.route, method, callback, name, aply, skip)(attr)

Answer 3

Su código no funciona porque está intentando enrutar a métodos no enlazados. Los métodos no vinculados no tienen una referencia a self , ¿cómo podrían hacerlo, si la instancia de la App no se ha creado?

Si desea enrutar a métodos de clase, primero tiene que inicializar su clase y luego bottle.route() a los métodos en ese objeto, como bottle.route() :

import bottle        

class App(object):
    def __init__(self,param):
        self.param   = param

    def index1(self):
        return("I''m 1 | self.param = %s" % self.param)

myapp = App(param=''some param'')
bottle.route("/1")(myapp.index1)

Si desea aplicar definiciones de rutas cerca de los manejadores, puede hacer algo como esto:

def routeapp(obj):
    for kw in dir(app):
        attr = getattr(app, kw)
        if hasattr(attr, ''route''):
            bottle.route(attr.route)(attr)

class App(object):
    def __init__(self, config):
        self.config = config

    def index(self):
        pass
    index.route = ''/index/''

app = App({''config'':1})
routeapp(app)

No haga la parte bottle.route() en App.__init__() , porque no podrá crear dos instancias de la clase App .

Si le gusta la sintaxis de los decoradores más que establecer el atributo index.route= , puede escribir un decorador simple:

def methodroute(route):
    def decorator(f):
        f.route = route
        return f
    return decorator

class App(object):
    @methodroute(''/index/'')
    def index(self):
        pass

Answer 4

Tienes que extender la clase Bottle . Sus instancias son aplicaciones web WSGI.

from bottle import Bottle

class MyApp(Bottle):
    def __init__(self, name):
        super(MyApp, self).__init__()
        self.name = name
        self.route(''/'', callback=self.index)

    def index(self):
        return "Hello, my name is " + self.name

app = MyApp(''OOBottle'')
app.run(host=''localhost'', port=8080)

Lo que la mayoría de los ejemplos están haciendo, incluidas las respuestas proporcionadas anteriormente a esta pregunta, son todos reutilizar la "aplicación predeterminada", no crear la suya propia, y no utilizar la conveniencia de la orientación del objeto y la herencia.

Answer 5

prueba esto, funcionó para mí, la documentación también es bastante decente para empezar ...

https://github.com/techchunks/bottleCBV