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_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 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_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)
