Exemplo n.º 1
0
 def __init__(self, session_factory, scopefunc=None):
     self.session_factory = session_factory
     if scopefunc:
         self.registry = ScopedRegistry(session_factory, scopefunc)
     else:
         self.registry = ThreadLocalRegistry(session_factory)
     self.extension = _ScopedExt(self)
Exemplo n.º 2
0
    def Configure(cls,
                  app,
                  engine,
                  monkey_patch_debugtoolbar=True,
                  package_names=None):
        """Configure the debug panel with an engine and session

        :param Flask app: flask application
        :param Engine engine: sqlalchemy Engine
        :param callable session: callable that returns a
        :param monkey_patch_debugtoolbar: replace existing SQLalchemy debug panel (default True)
        """
        if monkey_patch_debugtoolbar:
            _monkey_patch_flasksqlalchemy_panel()

        if package_names:
            cls.package_names = package_names
        else:
            cls.package_names = []

        cls._engine = engine
        scopefunc = _app_ctx_stack.__ident_func__
        cls._locals = ScopedRegistry(dict, scopefunc)

        @app.teardown_request
        def clear_statements(*args, **kwargs):
            cls._locals.clear()

        event.listen(cls._engine, "before_cursor_execute",
                     cls._before_cursor_execute)
        event.listen(cls._engine, "after_cursor_execute",
                     cls._after_cursor_execute)
Exemplo n.º 3
0
def init(connection_uri, echo=False, scopefunc=None):
    """Initialize the session.

    Args:
        connection_uri (str): The connection uri, such as
            "postgrseql://*****:*****@localhost/dbname"
        echo (bool): Echo SQL statements to stdout.  Useful for debugging.
        scopefunc (func): Optional function which defines
            the current scope.  See
            http://docs.sqlalchemy.org/en/latest/orm/contextual.html#sqlalchemy.orm.scoping.scoped_session.__init__
            for more information.  If this is not passed, the "thread-local"
            scope will be assumed.
    """
    global engine, session

    from frf.models import Model

    if 'postgres' in connection_uri:
        engine = create_engine(connection_uri,
                               echo=echo,
                               json_serializer=serialize,
                               json_deserializer=deserialize)
    else:
        engine = create_engine(connection_uri, echo=echo)

    if scopefunc is not None:
        session.registry = ScopedRegistry(session.session_factory,
                                          scopefunc=scopefunc)
    else:
        session.registry = ThreadLocalRegistry(session.session_factory)

    session.configure(bind=engine)
    Model.query = _QueryProperty(session)
Exemplo n.º 4
0
    def __init__(self, session_factory, scopefunc=None):  # pylint: disable=super-init-not-called
        self.session_factory = session_factory

        if scopefunc:
            self.registry = ScopedRegistry(session_factory, scopefunc)
        else:
            self.registry = FalconOauthRegistry(session_factory)
Exemplo n.º 5
0
class SessionContext(object):
    """A simple wrapper for ScopedRegistry that provides a "current" property
    which can be used to get, set, or remove the session in the current scope.

    By default this object provides thread-local scoping, which is the default
    scope provided by sqlalchemy.util.ScopedRegistry.

    Usage:
        engine = create_engine(...)
        def session_factory():
            return Session(bind_to=engine)
        context = SessionContext(session_factory)

        s = context.current # get thread-local session
        context.current = Session(bind_to=other_engine) # set current session
        del context.current # discard the thread-local session (a new one will
                            # be created on the next call to context.current)
    """
    def __init__(self, session_factory, scopefunc=None):
        self.registry = ScopedRegistry(session_factory, scopefunc)
        super(SessionContext, self).__init__()

    def get_current(self):
        return self.registry()

    def set_current(self, session):
        self.registry.set(session)

    def del_current(self):
        self.registry.clear()

    current = property(
        get_current, set_current, del_current,
        """Property used to get/set/del the session in the current scope""")

    def _get_mapper_extension(self):
        try:
            return self._extension
        except AttributeError:
            self._extension = ext = SessionContextExt(self)
            return ext

    mapper_extension = property(
        _get_mapper_extension,
        doc=
        """get a mapper extension that implements get_session using this context"""
    )
Exemplo n.º 6
0
class SessionContext(object):
    """A simple wrapper for ``ScopedRegistry`` that provides a
    `current` property which can be used to get, set, or remove the
    session in the current scope.

    By default this object provides thread-local scoping, which is the
    default scope provided by sqlalchemy.util.ScopedRegistry.

    Usage::

      engine = create_engine(...)
      def session_factory():
          return Session(bind_to=engine)
      context = SessionContext(session_factory)

      s = context.current # get thread-local session
      context.current = Session(bind_to=other_engine) # set current session
      del context.current # discard the thread-local session (a new one will
                          # be created on the next call to context.current)
    """

    def __init__(self, session_factory, scopefunc=None):
        self.registry = ScopedRegistry(session_factory, scopefunc)
        super(SessionContext, self).__init__()

    def get_current(self):
        return self.registry()

    def set_current(self, session):
        self.registry.set(session)

    def del_current(self):
        self.registry.clear()

    current = property(get_current, set_current, del_current,
                       """Property used to get/set/del the session in the current scope.""")

    def _get_mapper_extension(self):
        try:
            return self._extension
        except AttributeError:
            self._extension = ext = SessionContextExt(self)
            return ext

    mapper_extension = property(_get_mapper_extension,
                                doc="""Get a mapper extension that implements `get_session` using this context.""")
Exemplo n.º 7
0
    def __init__(self, session_factory, scopefunc=None):
        """Construct a new :class:`.scoped_session`.

        :param session_factory: a factory to create new :class:`.Session`
         instances. This is usually, but not necessarily, an instance
         of :class:`.sessionmaker`.
        :param scopefunc: optional function which defines
         the current scope.   If not passed, the :class:`.scoped_session`
         object assumes "thread-local" scope, and will use
         a Python ``threading.local()`` in order to maintain the current
         :class:`.Session`.  If passed, the function should return
         a hashable token; this token will be used as the key in a
         dictionary in order to store and retrieve the current
         :class:`.Session`.

        """
        self.session_factory = session_factory

        if scopefunc:
            self.registry = ScopedRegistry(session_factory, scopefunc)
        else:
            self.registry = ThreadLocalRegistry(session_factory)
Exemplo n.º 8
0
class ScopedSession(object):
    """Provides thread-local management of Sessions.

    Usage::

      Session = scoped_session(sessionmaker(autoflush=True))
      
      To map classes so that new instances are saved in the current
      Session automatically, as well as to provide session-aware
      class attributes such as "query":
      
      mapper = Session.mapper
      mapper(Class, table, ...)

    """

    def __init__(self, session_factory, scopefunc=None):
        self.session_factory = session_factory
        self.registry = ScopedRegistry(session_factory, scopefunc)
        self.extension = _ScopedExt(self)

    def __call__(self, **kwargs):
        if kwargs:
            scope = kwargs.pop("scope", False)
            if scope is not None:
                if self.registry.has():
                    raise exceptions.InvalidRequestError(
                        "Scoped session is already present; no new arguments may be specified."
                    )
                else:
                    sess = self.session_factory(**kwargs)
                    self.registry.set(sess)
                    return sess
            else:
                return self.session_factory(**kwargs)
        else:
            return self.registry()

    def remove(self):
        if self.registry.has():
            self.registry().close()
        self.registry.clear()

    def mapper(self, *args, **kwargs):
        """return a mapper() function which associates this ScopedSession with the Mapper."""

        from sqlalchemy.orm import mapper

        extension_args = dict([(arg, kwargs.pop(arg)) for arg in get_cls_kwargs(_ScopedExt) if arg in kwargs])

        kwargs["extension"] = extension = to_list(kwargs.get("extension", []))
        if extension_args:
            extension.append(self.extension.configure(**extension_args))
        else:
            extension.append(self.extension)
        return mapper(*args, **kwargs)

    def configure(self, **kwargs):
        """reconfigure the sessionmaker used by this ScopedSession."""

        self.session_factory.configure(**kwargs)

    def query_property(self):
        """return a class property which produces a `Query` object against the
        class when called.
        
        e.g.::
            Session = scoped_session(sessionmaker())
            
            class MyClass(object):
                query = Session.query_property()
                
            # after mappers are defined
            result = MyClass.query.filter(MyClass.name=='foo').all()
        
        """

        class query(object):
            def __get__(s, instance, owner):
                mapper = class_mapper(owner, raiseerror=False)
                if mapper:
                    return self.registry().query(mapper)
                else:
                    return None

        return query()
Exemplo n.º 9
0
 def __init__(self, session_factory, scopefunc=None):
     self.session_factory = session_factory
     self.registry = ScopedRegistry(session_factory, scopefunc)
     self.extension = _ScopedExt(self)
Exemplo n.º 10
0
class ScopedSession(object):
    """Provides thread-local management of Sessions.

    Usage::

      Session = scoped_session(sessionmaker(autoflush=True))
      
      To map classes so that new instances are saved in the current
      Session automatically, as well as to provide session-aware
      class attributes such as "query":
      
      mapper = Session.mapper
      mapper(Class, table, ...)

    """
    def __init__(self, session_factory, scopefunc=None):
        self.session_factory = session_factory
        self.registry = ScopedRegistry(session_factory, scopefunc)
        self.extension = _ScopedExt(self)

    def __call__(self, **kwargs):
        if kwargs:
            scope = kwargs.pop('scope', False)
            if scope is not None:
                if self.registry.has():
                    raise exceptions.InvalidRequestError(
                        "Scoped session is already present; no new arguments may be specified."
                    )
                else:
                    sess = self.session_factory(**kwargs)
                    self.registry.set(sess)
                    return sess
            else:
                return self.session_factory(**kwargs)
        else:
            return self.registry()

    def remove(self):
        if self.registry.has():
            self.registry().close()
        self.registry.clear()

    def mapper(self, *args, **kwargs):
        """return a mapper() function which associates this ScopedSession with the Mapper."""

        from sqlalchemy.orm import mapper

        extension_args = dict([(arg, kwargs.pop(arg))
                               for arg in get_cls_kwargs(_ScopedExt)
                               if arg in kwargs])

        kwargs['extension'] = extension = to_list(kwargs.get('extension', []))
        if extension_args:
            extension.append(self.extension.configure(**extension_args))
        else:
            extension.append(self.extension)
        return mapper(*args, **kwargs)

    def configure(self, **kwargs):
        """reconfigure the sessionmaker used by this ScopedSession."""

        self.session_factory.configure(**kwargs)

    def query_property(self):
        """return a class property which produces a `Query` object against the
        class when called.
        
        e.g.::
            Session = scoped_session(sessionmaker())
            
            class MyClass(object):
                query = Session.query_property()
                
            # after mappers are defined
            result = MyClass.query.filter(MyClass.name=='foo').all()
        
        """
        class query(object):
            def __get__(s, instance, owner):
                mapper = class_mapper(owner, raiseerror=False)
                if mapper:
                    return self.registry().query(mapper)
                else:
                    return None

        return query()
Exemplo n.º 11
0
 def __init__(self, session_factory, scopefunc=None):
     self.session_factory = session_factory
     self.registry = ScopedRegistry(session_factory, scopefunc)
     self.extension = _ScopedExt(self)
Exemplo n.º 12
0
class ScopedSession(object):
    """Provides thread-local management of Sessions.

    Usage::

      Session = scoped_session(sessionmaker(autoflush=True))

      ... use session normally.

    """

    def __init__(self, session_factory, scopefunc=None):
        self.session_factory = session_factory
        self.registry = ScopedRegistry(session_factory, scopefunc)
        self.extension = _ScopedExt(self)

    def __call__(self, **kwargs):
        if kwargs:
            scope = kwargs.pop('scope', False)
            if scope is not None:
                if self.registry.has():
                    raise sa_exc.InvalidRequestError("Scoped session is already present; no new arguments may be specified.")
                else:
                    sess = self.session_factory(**kwargs)
                    self.registry.set(sess)
                    return sess
            else:
                return self.session_factory(**kwargs)
        else:
            return self.registry()

    def remove(self):
        if self.registry.has():
            self.registry().close()
        self.registry.clear()

    @deprecated("Session.mapper is deprecated.  "
        "Please see http://www.sqlalchemy.org/trac/wiki/UsageRecipes/SessionAwareMapper "
        "for information on how to replicate its behavior.")
    def mapper(self, *args, **kwargs):
        """return a mapper() function which associates this ScopedSession with the Mapper.

        DEPRECATED.

        """

        from sqlalchemy.orm import mapper

        extension_args = dict((arg, kwargs.pop(arg))
                              for arg in get_cls_kwargs(_ScopedExt)
                              if arg in kwargs)

        kwargs['extension'] = extension = to_list(kwargs.get('extension', []))
        if extension_args:
            extension.append(self.extension.configure(**extension_args))
        else:
            extension.append(self.extension)
        return mapper(*args, **kwargs)

    def configure(self, **kwargs):
        """reconfigure the sessionmaker used by this ScopedSession."""

        self.session_factory.configure(**kwargs)

    def query_property(self, query_cls=None):
        """return a class property which produces a `Query` object against the
        class when called.

        e.g.::
            Session = scoped_session(sessionmaker())

            class MyClass(object):
                query = Session.query_property()

            # after mappers are defined
            result = MyClass.query.filter(MyClass.name=='foo').all()

        Produces instances of the session's configured query class by
        default.  To override and use a custom implementation, provide
        a ``query_cls`` callable.  The callable will be invoked with
        the class's mapper as a positional argument and a session
        keyword argument.

        There is no limit to the number of query properties placed on
        a class.

        """
        class query(object):
            def __get__(s, instance, owner):
                try:
                    mapper = class_mapper(owner)
                    if mapper:
                        if query_cls:
                            # custom query class
                            return query_cls(mapper, session=self.registry())
                        else:
                            # session's configured query class
                            return self.registry().query(mapper)
                except orm_exc.UnmappedClassError:
                    return None
        return query()
Exemplo n.º 13
0
 def __init__(self, session_factory, scopefunc=None):
     self.registry = ScopedRegistry(session_factory, scopefunc)
     super(SessionContext, self).__init__()
Exemplo n.º 14
0
 def __init__(self, session_factory, scopefunc=None):
     self.registry = ScopedRegistry(session_factory, scopefunc)
     super(SessionContext, self).__init__()