def call_resource(path, qs, per_page=5000):
    app = task_utils.get_app()
    endpoint, arguments = app.url_map.bind('').match(path)
    resource_type = app.view_functions[endpoint].view_class
    if resource_type not in RESOURCE_WHITELIST:
        raise ValueError('Downloads on resource {} not supported'.format(resource_type.__name__))
    resource = resource_type()
    fields, kwargs = parse_kwargs(resource, qs)
    kwargs = utils.extend(arguments, kwargs)
    for field in IGNORE_FIELDS:
        kwargs.pop(field, None)
    query, model, schema = unpack(resource.build_query(**kwargs), 3)
    count = counts.count_estimate(query, db.session, threshold=5000)
    index_column = utils.get_index_column(model or resource.model)
    query_kwargs = utils.extend(kwargs, {'per_page': per_page})
    paginator = utils.fetch_seek_paginator(query, query_kwargs, index_column, count=count, cap=None)
    return {
        'path': path,
        'qs': qs,
        'name': get_s3_name(path, qs),
        'paginator': paginator,
        'schema': schema or resource.schema,
        'resource': resource,
        'count': count,
        'timestamp': datetime.datetime.utcnow(),
        'fields': fields,
        'kwargs': kwargs,
    }

    def _check_filter(self, field, values, base_url, alt=None, **attrs):

        # Build fixtures
        factories.CommitteeFactory(**utils.extend(attrs, {field: alt}))
        [
            factories.CommitteeFactory(**utils.extend(attrs, {field: value}))
            for value in values
        ]

        # Assert that exactly one record is found for each single-valued search
        # (e.g. field=value1)
        for value in values:
            url = '{0}?{1}={2}'.format(base_url, field, value)
            results = self._results(url)
            self.assertEqual(len(results), 1)
            self.assertEqual(results[0][field], value)

        # Assert that `len(values)` records are found for multi-valued search
        # (e.g. field=value1,value2...valueN)
        url = '{0}?{1}'.format(
            base_url,
            urllib.parse.urlencode({field: values}, doseq=True)
        )
        results = self._results(url)
        self.assertEqual(len(results), len(values))
        for result in results:
            self.assertIn(result[field], values)

def make_schema(model, class_name=None, fields=None, options=None):
    class_name = class_name or '{0}Schema'.format(model.__name__)
    Meta = type(
        'Meta',
        (object, ),
        utils.extend(
            {
                'model': model,
                'sqla_session': models.db.session,
                'exclude': ('idx', ),
            },
            options or {},
        )
    )
    mapped_schema = (
        BaseSchema
        if not schema_map.get(model.__name__)
        else schema_map.get(model.__name__)

    )
    return type(
        class_name,
        (mapped_schema, ),
        utils.extend({'Meta': Meta}, fields or {}),
    )

def make_schema(model, class_name=None, fields=None, options=None):
    class_name = class_name or "{0}Schema".format(model.__name__)

    Meta = type(
        "Meta",
        (object,),
        utils.extend({"model": model, "sqla_session": models.db.session, "exclude": ("idx",)}, options or {}),
    )

    return type(class_name, (ModelSchema,), utils.extend({"Meta": Meta}, fields or {}))

def register_resource(resource, blueprint=None):
    key = resource.__name__.lower()
    if blueprint:
        key = '{0}.{1}'.format(blueprint, key)
    rules = app.url_map._rules_by_endpoint[key]
    resource_doc = getattr(resource, '__apidoc__', {})
    operations = {}
    for rule in rules:
        path = extract_path(rule.rule)
        path_params = [
            utils.extend({'required': True}, each)
            for each in resource_doc.get('path_params', [])
            if each['name'] in rule.arguments
        ]
        for method in [method.lower() for method in resource.methods or []]:
            view = getattr(resource, method)
            method_doc = getattr(view, '__apidoc__', {})
            docs = [method_doc, resource_doc]
            operations[method] = {
                'tags': resolve('tags', docs, []),
                'responses': resolve('responses', docs, {}),
                'description': resolve('description', docs, None),
                'parameters': resolve('parameters', docs, []) + path_params,
            }
            if os.getenv('PRODUCTION'):
                operations[method]['parameters'].insert(0, API_KEY_PARAM)
        spec.spec.add_path(path=path, operations=operations, view=view)

 def build_committee_query(self, kwargs, committee_id):
     query = self.build_query(utils.extend(kwargs, {'committee_id': [committee_id]}), join=False)
     sort, hide_null, nulls_large = kwargs['sort'], kwargs['sort_hide_null'], kwargs['sort_nulls_large']
     query, _ = sorting.sort(query, sort, model=models.ScheduleA, hide_null=hide_null, nulls_large=nulls_large)
     page_query = utils.fetch_seek_page(query, kwargs, self.index_column, count=-1, eager=False).results
     count = counts.count_estimate(query, models.db.session, threshold=5000)
     return page_query, count

    def test_Presidential_totals(self):
        committee_id = 'C8675309'
        history = factories.CommitteeHistoryFactory(
            committee_id=committee_id,
            committee_type='P',
        )
        presidential_fields = {
            'committee_id': 'C8675309',
            'cycle': 2016,
            'candidate_contribution': 1,
            'exempt_legal_accounting_disbursement': 2,
            'federal_funds': 3,
            'fundraising_disbursements': 4,
            'loan_repayments_made': 16,
            'loans_received': 5,
            'loans_received_from_candidate': 6,
            'offsets_to_fundraising_expenditures': 7,
            'offsets_to_legal_accounting': 8,
            'total_offsets_to_operating_expenditures': 9,
            'other_loans_received': 10,
            'other_receipts': 11,
            'repayments_loans_made_by_candidate': 12,
            'repayments_other_loans': 13,
            'transfers_from_affiliated_committee': 14,
            'transfers_to_other_authorized_committee': 15,

        }

        fields = utils.extend(shared_fields, presidential_fields)

        committee_total = factories.TotalsPresidentialFactory(**fields)
        results = self._results(api.url_for(TotalsView, committee_id=committee_id))

        self.assertEqual(results[0], fields)

    def test_House_Senate_totals(self):
        committee_id = 'C8675310'
        history = factories.CommitteeHistoryFactory(
            committee_id=committee_id,
            committee_type='S',
        )

        house_senate_fields = {
            'committee_id': committee_id,
            'cycle': 2016,
            'all_other_loans': 1,
            'candidate_contribution': 2,
            'loan_repayments': 3,
            'loan_repayments_candidate_loans': 4,
            'loan_repayments_other_loans': 5,
            'loans': 6,
            'loans_made_by_candidate': 7,
            'other_receipts': 8,
            'transfers_from_other_authorized_committee': 9,
            'transfers_to_other_authorized_committee': 10,
        }
        fields = utils.extend(house_senate_fields, shared_fields)

        committee_total = factories.TotalsHouseSenateFactory(**fields)
        results = self._results(api.url_for(TotalsView, committee_id=committee_id))

        self.assertEqual(results[0], fields)

 def args(self):
     return utils.extend(
         args.paging,
         args.Category,
         args.make_sort_args(
             default='primary_category_name',
         ),
     )

 def args(self):
     return utils.extend(
         args.paging,
         args.rad_analyst,
         args.make_sort_args(
             validator=args.IndexValidator(models.RadAnalyst),
         ),
     )

 def args(self):
     return utils.extend(
         args.paging,
         args.calendar_dates,
         args.make_sort_args(
             default='-start_date',
         ),
     )

 def args(self):
     return utils.extend(
         args.electioneering,
         args.make_seek_args(),
         args.make_sort_args(
             validator=args.IndexValidator(models.Electioneering),
         ),
     )

 def args(self):
     return utils.extend(
         args.paging,
         args.committee_history,
         args.make_sort_args(
             default='-cycle',
             validator=args.IndexValidator(self.model),
         ),
     )

 def args(self):
     return utils.extend(
         args.paging,
         args.efilings,
         args.make_sort_args(
             default='-receipt_date',
             # validator=args.IndexValidator(self.model),
         ),
     )

 def args(self):
     return utils.extend(
         args.itemized,
         args.schedule_c,
         args.paging,
         args.make_sort_args(
             default='incurred_date',
         ),
     )

 def args(self):
     return utils.extend(
         args.paging,
         args.schedule_b_efile,
         args.make_sort_args(
             default='-disbursement_date',
             validator=args.OptionValidator(['disbursement_date', 'disbursement_amount']),
         ),
     )

 def args(self):
     return utils.extend(
         args.paging,
         args.candidate_detail,
         args.make_sort_args(
             default='name',
             validator=args.IndexValidator(self.model),
         ),
     )

 def args(self):
     return utils.extend(
         args.itemized,
         args.schedule_b,
         args.make_seek_args(),
         args.make_sort_args(
             validator=args.OptionValidator(['disbursement_date', 'disbursement_amount']),
         ),
     )

 def build_committee_query(self, kwargs, committee_id):
     """Build a subquery by committee.
     """
     query = self.build_query(_apply_options=False, **utils.extend(kwargs, {'committee_id': [committee_id]}))
     sort, hide_null, nulls_large = kwargs['sort'], kwargs['sort_hide_null'], kwargs['sort_nulls_large']
     query, _ = sorting.sort(query, sort, model=self.model, hide_null=hide_null, nulls_large=nulls_large)
     page_query = utils.fetch_seek_page(query, kwargs, self.index_column, count=-1, eager=False).results
     count = counts.count_estimate(query, models.db.session, threshold=5000)
     return page_query, count

 def args(self):
     return utils.extend(
         args.itemized,
         args.schedule_f,
         args.paging,
         args.make_sort_args(
             default='expenditure_date',
         )
     )