sqlalchemy.orm.undefer_group

Here are the examples of the python api sqlalchemy.orm.undefer_group taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

19 Examples 7

Example 1

Project: quicktill Source File: views.py
@tillweb_view
def delivery(request,info,session,deliveryid):
    try:
        d=session.query(Delivery).\
            filter_by(id=int(deliveryid)).\
            options(joinedload_all('items.stocktype.unit')).\
            options(joinedload_all('items.stockline')).\
            options(undefer_group('qtys')).\
            one()
    except NoResultFound:
        raise Http404
    return ('delivery.html',{'delivery':d,})

Example 2

Project: quicktill Source File: views.py
@tillweb_view
def stocktype(request,info,session,stocktype_id):
    try:
        s=session.query(StockType).\
            filter_by(id=int(stocktype_id)).\
            one()
    except NoResultFound:
        raise Http404
    include_finished=request.GET.get("show_finished","off")=="on"
    items=session.query(StockItem).\
        filter(StockItem.stocktype==s).\
        options(undefer_group('qtys')).\
        order_by(desc(StockItem.id))
    if not include_finished:
        items=items.filter(StockItem.finished==None)
    items=items.all()
    return ('stocktype.html',{'stocktype':s,'items':items,
                              'include_finished':include_finished})

Example 3

Project: quicktill Source File: views.py
@tillweb_view
def stocksearch(request,info,session):
    form=StockForm(request.GET)
    result=[]
    q=session.query(StockItem).join(StockType).order_by(StockItem.id).\
        options(joinedload_all('stocktype.unit')).\
        options(joinedload('stockline')).\
        options(undefer_group('qtys'))
    if form.is_valid():
        if form.is_filled_in():
            q=form.filter(q)
            if not form.cleaned_data['include_finished']:
                q=q.filter(StockItem.finished==None)
            result=q.all()
    return ('stocksearch.html',{'form':form,'stocklist':result})

Example 4

Project: quicktill Source File: views.py
@tillweb_view
def stock(request,info,session,stockid):
    try:
        s=session.query(StockItem).\
            filter_by(id=int(stockid)).\
            options(joinedload_all('stocktype.department')).\
            options(joinedload_all('stocktype.stockline_log.stockline')).\
            options(joinedload_all('delivery.supplier')).\
            options(joinedload_all('stockunit.unit')).\
            options(joinedload_all('annotations.type')).\
            options(subqueryload_all('out.transline.transaction')).\
            options(undefer_group('qtys')).\
            one()
    except NoResultFound:
        raise Http404
    return ('stock.html',{'stock':s,})

Example 5

Project: quicktill Source File: views.py
@tillweb_view
def stockline(request,info,session,stocklineid):
    try:
        s=session.query(StockLine).\
            filter_by(id=int(stocklineid)).\
            options(joinedload_all('stockonsale.stocktype.unit')).\
            options(undefer_group('qtys')).\
            one()
    except NoResultFound:
        raise Http404
    return ('stockline.html',{'stockline':s,})

Example 6

Project: quicktill Source File: views.py
@tillweb_view
def department(request,info,session,departmentid):
    d=session.query(Department).get(int(departmentid))
    if d is None: raise Http404
    include_finished=request.GET.get("show_finished","off")=="on"
    items=session.query(StockItem).\
        join(StockType).\
        filter(StockType.department==d).\
        order_by(desc(StockItem.id)).\
        options(joinedload_all('stocktype.unit')).\
        options(undefer_group('qtys')).\
        options(joinedload('stockline')).\
        options(joinedload('finishcode'))
    if not include_finished:
        items=items.filter(StockItem.finished==None)
    items=items.all()
    return ('department.html',{'department':d,'items':items,
                               'include_finished':include_finished})

Example 7

Project: autonomie Source File: avatar.py
Function: get_avatar
def get_avatar(request):
    """
        Returns the current User object
    """
    log.info("Get avatar")
    login = unauthenticated_userid(request)
    if login is not None:
        log.info("  + Returning the user")
        query = request.dbsession.query(User).options(undefer_group('edit'))
        user = query.filter_by(login=login).first()

        return user

Example 8

Project: autonomie Source File: security.py
Function: get_item
    def _get_item(self, klass, key, object_name):
        assert self.dbsession is not None, "Missing dbsession"

        dbsession = self.dbsession()
        obj = dbsession.query(klass)\
                       .options(undefer_group('edit'))\
                       .filter(getattr(klass, self.id_key) == key)\
                       .scalar()

        if obj is None:
            raise KeyError

        obj.__name__ = object_name
        return obj

Example 9

Project: quicktill Source File: stockterminal.py
Function: draw_lines
    def drawlines(self, h):
        sl = td.s.query(StockLine).\
             filter(StockLine.location.in_(self.locations)).\
             filter(StockLine.capacity==None).\
             order_by(StockLine.name).\
             options(joinedload('stockonsale')).\
             options(joinedload('stockonsale.stocktype')).\
             options(undefer_group('qtys')).\
             all()
        f = ui.tableformatter("pl l l r rp")
        header = f("Line", "StockID", "Stock", "Used", "Remaining")
        def fl(line):
            if line.stockonsale:
                sos = line.stockonsale[0]
                return (line.name, sos.id, sos.stocktype.format(),
                        sos.used, sos.remaining)
            return (line.name, "", "", "", "")
        ml = [header] + [f(*fl(line)) for line in sl]
        y = 0
        for l in ml:
            for line in l.display(self.w):
                self.addstr(y, 0, line)
                y = y + 1
            if y >= h:
                break

Example 10

Project: quicktill Source File: views.py
@tillweb_view
def pubroot(request,info,session):
    date=datetime.date.today()
    # If it's the early hours of the morning, it's more useful for us
    # to consider it still to be yesterday.
    if datetime.datetime.now().hour<4: date=date-datetime.timedelta(1)
    thisweek_start=date-datetime.timedelta(date.weekday())
    thisweek_end=thisweek_start+datetime.timedelta(6)
    lastweek_start=thisweek_start-datetime.timedelta(7)
    lastweek_end=thisweek_end-datetime.timedelta(7)
    weekbefore_start=lastweek_start-datetime.timedelta(7)
    weekbefore_end=lastweek_end-datetime.timedelta(7)

    weeks=[("Current week",thisweek_start,thisweek_end,
            business_totals(session,thisweek_start,thisweek_end)),
           ("Last week",lastweek_start,lastweek_end,
            business_totals(session,lastweek_start,lastweek_end)),
           ("The week before last",weekbefore_start,weekbefore_end,
            business_totals(session,weekbefore_start,weekbefore_end))]

    currentsession=Session.current(session)
    barsummary=session.query(StockLine).\
        filter(StockLine.location=="Bar").\
        order_by(StockLine.dept_id,StockLine.name).\
        options(joinedload_all('stockonsale.stocktype.unit')).\
        options(undefer_group('qtys')).\
        all()
    stillage=session.query(StockAnnotation).\
        join(StockItem).\
        outerjoin(StockLine).\
        filter(tuple_(StockAnnotation.text,StockAnnotation.time).in_(
            select([StockAnnotation.text,func.max(StockAnnotation.time)],
                   StockAnnotation.atype=='location').\
                group_by(StockAnnotation.text))).\
        filter(StockItem.finished==None).\
        order_by(StockLine.name!=null(),StockAnnotation.time).\
        options(joinedload_all('stockitem.stocktype.unit')).\
        options(joinedload_all('stockitem.stockline')).\
        options(undefer_group('qtys')).\
        all()
    return ('index.html',
            {'currentsession':currentsession,
             'barsummary':barsummary,
             'stillage':stillage,
             'weeks':weeks,
             })

Example 11

Project: sqlalchemy Source File: test_deferred.py
    def test_undefer_group(self):
        orders, Order = self.tables.orders, self.classes.Order

        mapper(Order, orders, properties=util.OrderedDict([
            ('userident', deferred(orders.c.user_id, group='primary')),
            ('description', deferred(orders.c.description, group='primary')),
            ('opened', deferred(orders.c.isopen, group='primary'))
            ]
            ))

        sess = create_session()
        q = sess.query(Order).order_by(Order.id)
        def go():
            l = q.options(undefer_group('primary')).all()
            o2 = l[2]
            eq_(o2.opened, 1)
            eq_(o2.userident, 7)
            eq_(o2.description, 'order 3')

        self.sql_eq_(go, [
            ("SELECT orders.user_id AS orders_user_id, "
             "orders.description AS orders_description, "
             "orders.isopen AS orders_isopen, "
             "orders.id AS orders_id, "
             "orders.address_id AS orders_address_id "
             "FROM orders ORDER BY orders.id",
             {})])

Example 12

Project: sqlalchemy Source File: test_deferred.py
    def test_undefer_group_multi(self):
        orders, Order = self.tables.orders, self.classes.Order

        mapper(Order, orders, properties=util.OrderedDict([
            ('userident', deferred(orders.c.user_id, group='primary')),
            ('description', deferred(orders.c.description, group='primary')),
            ('opened', deferred(orders.c.isopen, group='secondary'))
            ]
            ))

        sess = create_session()
        q = sess.query(Order).order_by(Order.id)
        def go():
            l = q.options(
                undefer_group('primary'), undefer_group('secondary')).all()
            o2 = l[2]
            eq_(o2.opened, 1)
            eq_(o2.userident, 7)
            eq_(o2.description, 'order 3')

        self.sql_eq_(go, [
            ("SELECT orders.user_id AS orders_user_id, "
             "orders.description AS orders_description, "
             "orders.isopen AS orders_isopen, "
             "orders.id AS orders_id, "
             "orders.address_id AS orders_address_id "
             "FROM orders ORDER BY orders.id",
             {})])

Example 13

Project: autonomie Source File: 2_7_migrate_table_datas_428f9d451e18.py
def upgrade():
    # Ajout et modification de la structure de données existantes
    op.execute("alter table project modify archived BOOLEAN;")


    for name in ('ht', 'tva', 'ttc'):
        col = sa.Column(name, sa.Integer, default=0)
        op.add_column('task', col)

    for col in (
        sa.Column("project_id", sa.Integer, sa.ForeignKey('project.id')),
        sa.Column("customer_id", sa.Integer, sa.ForeignKey('customer.id')),
        sa.Column("_number", sa.String(10)),
        sa.Column("sequence_number", sa.Integer),
        sa.Column("display_units", sa.Integer, default=0),
        sa.Column('expenses', sa.Integer, default=0),
        sa.Column('expenses_ht', sa.Integer, default=0),
        sa.Column('address', sa.Text, default=""),
        sa.Column('payment_conditions', sa.Text, default=""),
        sa.Column("official_number", sa.Integer, default=None),
    ):
        op.add_column("task", col)

    col = sa.Column("sortie_type_id", sa.Integer, sa.ForeignKey('type_sortie_option.id'))
    op.add_column("user_datas", col)
    op.execute("alter table user_datas modify parcours_num_hours float DEFAULT NULL")
    op.execute("alter table external_activity_datas modify hours float DEFAULT NULL")
    op.execute("alter table external_activity_datas modify brut_salary float DEFAULT NULL")

    col = sa.Column("cgv", sa.Text, default="")
    op.add_column("company", col)

    col = sa.Column('_acl', sa.Text)
    op.add_column("job", col)


    # Migration des donnees vers la nouvelle structure
    from alembic.context import get_bind
    conn = get_bind()
    from autonomie.models.base import DBSESSION
    session = DBSESSION()

    # Expenses will be nodes
    make_expense_nodes(conn, session)

    from autonomie.models.task import (
        Invoice,
        CancelInvoice,
        Estimation,
    )
    # Migration des customer_id et project_id au niveau de la table Task
    index = 0

    for type_ in "invoice", "cancelinvoice", "estimation":
        conditions = "paymentConditions"
        if type_ == "cancelinvoice":
            conditions = "reimbursementConditions"

        request = "select id, customer_id, project_id, number, \
sequenceNumber, displayedUnits, expenses, expenses_ht, address, %s \
from %s;" % (conditions, type_)
        result = conn.execute(request)

        for index, (id, c_id, p_id, number, seq_number, display, expenses,
                    expenses_ht, address, conditions) in enumerate(result):

            request = sa.text(u"update task set \
project_id=:p_id, \
customer_id=:c_id, \
_number=:number, \
sequence_number=:seq_number, \
display_units=:display, \
expenses=:expenses, \
expenses_ht=:expenses_ht, \
address=:address, \
payment_conditions=:conditions \
where id=:id;"
                             )

            conn.execute(
                request,
                p_id=p_id,
                c_id=c_id,
                number=number,
                seq_number=seq_number,
                display=display,
                expenses=expenses,
                expenses_ht=expenses_ht,
                address=address,
                conditions=conditions,
                id=id,
            )
            if index % 50 == 0:
                session.flush()

    for type_ in ('invoice', 'cancelinvoice'):
        request = "select id, officialNumber from %s" % (type_,)
        result = conn.execute(request)

        for index, (id, official_number) in enumerate(result):
            request = sa.text(u"update task set \
official_number=:official_number \
where id=:id;"
                             )
            conn.execute(
                request,
                official_number=official_number,
                id=id,
            )
            if index % 50 == 0:
                session.flush()

    for factory in (Invoice, CancelInvoice, Estimation,):
        for docuement in factory.query().options(undefer_group('edit')):
            docuement.ttc = docuement.total()
            docuement.ht = docuement.total_ht()
            docuement.tva = docuement.tva_amount()
            session.merge(docuement)
            index += 1
        if index % 50 == 0:
            session.flush()

    # Drop old constraints
    for table in ('estimation', 'invoice', 'cancelinvoice'):
        for num in [2,3,4]:
            key = "%s_ibfk_%s" % (table, num,)
            cmd = "ALTER TABLE %s DROP FOREIGN KEY %s;" % (table, key)
            try:
                print(cmd)
                conn.execute(cmd)
            except:
                print("Error while droping a foreignkey : %s %s" % (table, key))

        for column in ('customer_id', 'project_id', 'number', \
                       'sequenceNumber', 'displayedUnits', 'expenses', \
                       'expenses_ht', 'address'):
            op.drop_column(table, column)

    op.drop_column('cancelinvoice', 'reimbursementConditions')
    op.drop_column('estimation', 'paymentConditions')
    op.drop_column('invoice', 'paymentConditions')

    for table in ('invoice', 'cancelinvoice'):
        op.drop_column(table, 'officialNumber')

Example 14

Project: autonomie Source File: customer.py
Function: query
    def query(self):
        company = self.request.context
        query = Customer.query().options(undefer_group('edit'))
        return query.filter(Customer.company_id == company.id)

Example 15

Project: ggrc-core Source File: common.py
def _base_user_query():
  from sqlalchemy import orm
  return Person.query.options(
      orm.undefer_group('Person_complete'))

Example 16

Project: ggrc-core Source File: __init__.py
def load_user_roles(user, permissions):
  """Load all user roles for user

  Args:
      user (Person): Person object
      permissions (dict): dict where the permissions will be stored
  Returns:
      source_contexts_to_rolenames (dict): Role names for contexts
  """
  # Add permissions from all DB-managed roles
  user_roles = db.session.query(UserRole)\
      .options(
          sqlalchemy.orm.undefer_group('UserRole_complete'),
          sqlalchemy.orm.undefer_group('Role_complete'),
          sqlalchemy.orm.joinedload('role'))\
      .filter(UserRole.person_id == user.id)\
      .order_by(UserRole.updated_at.desc())\
      .all()

  source_contexts_to_rolenames = {}
  for user_role in user_roles:
    source_contexts_to_rolenames.setdefault(
        user_role.context_id, list()).append(user_role.role.name)
    if isinstance(user_role.role.permissions, dict):
      collect_permissions(
          user_role.role.permissions, user_role.context_id, permissions)
  return source_contexts_to_rolenames

Example 17

Project: ggrc-core Source File: __init__.py
def load_implied_roles(permissions, source_contexts_to_rolenames,
                       all_context_implications):
  """Load roles from implied contexts

  Args:
      permissions (dict): dict where the permissions will be stored
      source_contexts_to_rolenames (dict): Role names for contexts
      all_context_implications (list): List of possible context implications
  Returns:
      None
  """
  # Gather all roles required by context implications
  implied_context_to_implied_roles = {}
  all_implied_roles_set = set()
  for context_implication in all_context_implications:
    for rolename in source_contexts_to_rolenames.get(
            context_implication.source_context_id, []):
      implied_role_names_list = implied_context_to_implied_roles.setdefault(
          context_implication.context_id, list())
      implied_role_names = lookup_role_implications(
          rolename, context_implication)
      all_implied_roles_set.update(implied_role_names)
      implied_role_names_list.extend(implied_role_names)
  # If some roles are required, query for them in bulk
  all_implied_roles_by_name = {}
  if implied_context_to_implied_roles and all_implied_roles_set:
    implied_roles = db.session.query(Role)\
        .filter(Role.name.in_(all_implied_roles_set))\
        .options(sqlalchemy.orm.undefer_group('Role_complete'))\
        .all()
    for implied_role in implied_roles:
      all_implied_roles_by_name[implied_role.name] = implied_role
  # Now aggregate permissions resulting from these roles
  for implied_context_id, implied_rolenames \
          in implied_context_to_implied_roles.items():
    if implied_context_id is None:
      continue
    for implied_rolename in implied_rolenames:
      implied_role = all_implied_roles_by_name[implied_rolename]
      collect_permissions(
          implied_role.permissions, implied_context_id, permissions)

Example 18

Project: indico Source File: management.py
    def _process(self):
        page = request.args.get('page', '1')
        order_columns = {'start_dt': Event.start_dt, 'title': db.func.lower(Event.title)}
        direction = 'desc' if request.args.get('desc', '1') == '1' else 'asc'
        order_column = order_columns[request.args.get('order', 'start_dt')]
        query = (Event.query.with_parent(self.category)
                 .options(joinedload('series'), undefer_group('series'),
                          load_only('id', 'category_id', 'created_dt',  'end_dt', 'protection_mode',  'start_dt',
                                    'title', 'type_', 'series_pos', 'series_count'))
                 .order_by(getattr(order_column, direction)())
                 .order_by(Event.id))
        if page == 'all':
            events = query.paginate(show_all=True)
        else:
            events = query.paginate(page=int(page))
        return WPCategoryManagement.render_template('management/content.html', self.category, 'content',
                                                    subcategories=self.category.children,
                                                    events=events, page=page,
                                                    order_column=request.args.get('order', 'start_dt'),
                                                    direction=direction)

Example 19

Project: langdev.org Source File: user.py
@user.route('/<user_login>/password-findings', methods=['POST'])
def request_find_password(user_login):
    user = get_user(user_login, orm.undefer_group('profile'))
    if user.email:
        token, expired_at = generate_token(user)
        url = url_for('.change_password_form',
                      user_login=user.login, token=token, _external=True)
        expired_at = datetime.datetime.utcfromtimestamp(expired_at)
        msg = Message('[LangDev.org] Change your password: ' + user.login,
                      recipients=[user.email])
        msg.body = textwrap.dedent('''
            You can change your password through the following link:
            {url}

            But the above link will be expired at {expired_at} UTC.
        ''').format(url=url, expired_at=expired_at)
        current_app.mail.send(msg)
        email = hide_email(user.email)
        result = Result(user=user, email=email)
        status_code = 201
    else:
        result = Result(user=user, error='Has no email address')
        status_code = 403
    response = render('user/request_find_password', result, **result)
    response.status_code = status_code
    return response