def test_maybe_evaluate(self): x = PromiseProxy(lambda: 30) self.assertFalse(x.__evaluated__()) self.assertEqual(maybe_evaluate(x), 30) self.assertEqual(maybe_evaluate(x), 30) self.assertEqual(maybe_evaluate(30), 30) self.assertTrue(x.__evaluated__())
def test_maybe_evaluate(self): x = PromiseProxy(lambda: 30) assert not x.__evaluated__() assert maybe_evaluate(x) == 30 assert maybe_evaluate(x) == 30 assert maybe_evaluate(30) == 30 assert x.__evaluated__()
def test_only_evaluated_once(self): class X(object): attr = 123 evals = 0 def __init__(self): self.__class__.evals += 1 p = PromiseProxy(X) self.assertEqual(p.attr, 123) self.assertEqual(p.attr, 123) self.assertEqual(X.evals, 1)
def test_only_evaluated_once(self): class X(object): attr = 123 evals = 0 def __init__(self): self.__class__.evals += 1 p = PromiseProxy(X) assert p.attr == 123 assert p.attr == 123 assert X.evals == 1
def _create_task_cls(fun): if shared: cons = lambda app: app._task_from_fun(fun, **opts) cons.__name__ = fun.__name__ connect_on_app_finalize(cons) if not lazy or self.finalized: ret = self._task_from_fun(fun, **opts) else: # return a proxy object that evaluates on first use ret = PromiseProxy(self._task_from_fun, (fun, ), opts, __doc__=fun.__doc__) self._pending.append(ret) if _filt: return _filt(ret) return ret
def _create_task_cls(fun): if shared: cons = lambda app: app._task_from_fun(fun, **opts) cons.__name__ = fun.__name__ shared_task(cons) if self.accept_magic_kwargs: # compat mode task = self._task_from_fun(fun, **opts) if filter: task = filter(task) return task # return a proxy object that is only evaluated when first used promise = PromiseProxy(self._task_from_fun, (fun, ), opts) self._pending.append(promise) if filter: return filter(promise) return promise
def test_callbacks(self): source = Mock(name='source') p = PromiseProxy(source) cbA = Mock(name='cbA') cbB = Mock(name='cbB') cbC = Mock(name='cbC') p.__then__(cbA, p) p.__then__(cbB, p) assert not p.__evaluated__() assert object.__getattribute__(p, '__pending__') assert repr(p) assert p.__evaluated__() with pytest.raises(AttributeError): object.__getattribute__(p, '__pending__') cbA.assert_called_with(p) cbB.assert_called_with(p) assert p.__evaluated__() p.__then__(cbC, p) cbC.assert_called_with(p) with pytest.raises(AttributeError): object.__getattribute__(p, '__pending__')
def test_callbacks(self): source = Mock(name='source') p = PromiseProxy(source) cbA = Mock(name='cbA') cbB = Mock(name='cbB') cbC = Mock(name='cbC') p.__then__(cbA, p) p.__then__(cbB, p) self.assertFalse(p.__evaluated__()) self.assertTrue(object.__getattribute__(p, '__pending__')) self.assertTrue(repr(p)) self.assertTrue(p.__evaluated__()) with self.assertRaises(AttributeError): object.__getattribute__(p, '__pending__') cbA.assert_called_with(p) cbB.assert_called_with(p) self.assertTrue(p.__evaluated__()) p.__then__(cbC, p) cbC.assert_called_with(p) with self.assertRaises(AttributeError): object.__getattribute__(p, '__pending__')
def _create_task_cls(fun): if shared: cons = lambda app: app._task_from_fun(fun, **opts) cons.__name__ = fun.__name__ shared_task(cons) if self.accept_magic_kwargs: # compat mode task = self._task_from_fun(fun, **opts) if filter: task = filter(task) return task if self.finalized or opts.get('_force_evaluate'): ret = self._task_from_fun(fun, **opts) else: # return a proxy object that evaluates on first use ret = PromiseProxy(self._task_from_fun, (fun, ), opts) self._pending.append(ret) if _filt: return _filt(ret) return ret
def test_maybe_evaluate(self): x = PromiseProxy(lambda: 30) self.assertEqual(maybe_evaluate(x), 30) self.assertEqual(maybe_evaluate(x), 30) self.assertEqual(maybe_evaluate(30), 30)
from celery.task import PeriodicTask from celery.utils.log import get_task_logger from celery.local import PromiseProxy import numpy as np import pyvo.dal import requests from . import celery from .. import models log = get_task_logger(__name__) __all__ = ('ztf_references', 'ztf_obs', 'ztf_depot') client = PromiseProxy( pyvo.dal.TAPService, ('https://irsa.ipac.caltech.edu/TAP',)) @celery.task(base=PeriodicTask, shared=False, run_every=3600) def ztf_obs(start_time=None, end_time=None): if start_time is None: start_time = time.Time.now() - time.TimeDelta(1.0*u.day) if end_time is None: end_time = time.Time.now() obstable = client.search(""" SELECT field,rcid,fid,expid,obsjd,exptime,seeing,airmass,maglimit FROM ztf.ztf_current_meta_sci WHERE (obsjd BETWEEN {0} AND {1}) AND (field < 2000)
elif np.issubsctype(column, np.unicode): column.mask = (column == '') table['ra'].format = '%.04f' table['dec'].format = '%+.4f' return table def get_from_vizier(*args, **kwargs): result, = vizier.query_constraints(*args, **kwargs, cache=True) result.convert_bytestring_to_unicode() return fixup(result) def get_from_package(filename): filepath = os.path.join('catalog', filename) try: f = app.open_instance_resource(filepath) except IOError: f = pkg_resources.resource_stream(__name__, filepath) filepath = f.name f.close() result = Table.read(filepath) return fixup(result) twomass = PromiseProxy(get_from_vizier, ('J/ApJS/199/26/table3',)) galaxies = clu = PromiseProxy(get_from_package, ('CLU.hdf5',))
__author__ = "Michael Coughlin <*****@*****.**>" from flask import render_template from slack import WebClient from celery.local import PromiseProxy from ..flask import app from . import celery from .. import models def get_client(): return WebClient(token=app.config['SLACK_API_TOKEN']) client = PromiseProxy(get_client) @celery.task(ignore_result=True, shared=False) def slack_too(telescope, queue_name): body = render_template('too.email', telescope=telescope, queue_name=queue_name) response = client.chat_postMessage( channel='#general', username='******', as_user=False, icon_url= 'https://vignette.wikia.nocookie.net/mario/images/9/99/Grobot.png/revision/latest?cb=20130903151824', # noqa: E501 text=body)