def items(self, request):
middleware = request.app._handler.middleware
for map in middleware:
if isinstance(map, RouterMap):
url = request.absolute_uri(str(map.route))
_, last_modified = map.sitemap(request)
yield AttributeDictionary(loc=url, lastmod=last_modified)
def items(self, request):
for index, map in enumerate(self.cms.sitemaps):
if not index:
continue
url = request.absolute_uri(str(map.route))
_, last_modified = map.sitemap(request)
yield AttributeDictionary(loc=url, lastmod=last_modified)
def __init__(self, rule, *routes, **parameters):
Router._creation_count += 1
self._creation_count = Router._creation_count
if not isinstance(rule, Route):
rule = Route(rule)
self.route = rule
self._name = parameters.pop('name', rule.rule)
self.routes = []
for router in routes:
self.add_child(router)
# copy parameters
self.parameters = AttributeDictionary(self.parameters)
for name, rule_method in self.rule_methods.items():
rule, method, params, _, _ = rule_method
rparameters = params.copy()
handler = getattr(self, name)
if rparameters.pop('async', False): # asynchronous method
handler = async ()(handler)
handler.rule_method = rule_method
router = self.add_child(Router(rule, **rparameters))
setattr(router, method, handler)
for name, value in parameters.items():
if name in self.parameters:
self.parameters[name] = value
else:
setattr(self, name, value)
def testAssign(self):
a = AttributeDictionary()
a['ciao'] = 5
self.assertEqual(a.ciao, 5)
self.assertEqual(a['ciao'], 5)
self.assertEqual(list(a.values()), [5])
self.assertEqual(list(a.items()), [('ciao', 5)])
def __test_pickle(self):
# TODO: this fails at times
a = AttributeDictionary()
a['ciao'] = 5
b = pickle.dumps(a)
c = pickle.loads(b)
self.assertEqual(a, c)
def __init__(self, environ, name=None):
self.environ = environ
if 'pulsar.cache' not in environ:
environ['pulsar.cache'] = AttributeDictionary()
self.cache.mixins = {}
if name:
self.cache.mixins[name] = self
def before_test_function_run(self, test):
'''Called before the test run, in the test process domain.'''
test.plugins = plugins = {}
for p in self.plugins:
local = AttributeDictionary()
plugins[p.name] = local
test = p.before_test_function_run(test, local) or test
return test
def before_test_function_run(self, test):
'''Called just before the test is run'''
test.plugins = plugins = {}
for p in self.plugins:
local = AttributeDictionary()
plugins[p.name] = local
test = p.before_test_function_run(test, local) or test
return test
def __init__(self, url, version=None, data=None,
full_response=False, **kw):
self.__url = url
self.__version = version or self.__class__.default_version
self._full_response = full_response
self.__data = data if data is not None else {}
self.local = AttributeDictionary()
self.setup(**kw)
def init_parameters(self, tag=None, **parameters):
'''Called at the and of initialisation.
It fills the :attr:`parameters` attribute.
It can be overwritten to customise behaviour.
'''
self.tag = tag or self.tag
self.parameters = AttributeDictionary(parameters)
def __init__(self, environ, name=None):
self.environ = environ
if pulsar_cache not in environ:
environ[pulsar_cache] = AttributeDictionary()
self.cache.mixins = {}
self.cache.logger = LOGGER
if name:
self.cache.mixins[name] = self
def inner_html(self, request, page, self_comp=''):
'''Build page html content using json layout.
:param layout: json (with rows and components) e.g.
layout = {
'rows': [
{},
{cols: ['col-md-6', 'col-md-6']},
{cols: ['col-md-6', 'col-md-6']}
],
'components': [
{'type': 'text', 'id': 1, 'row': 0, 'col': 0, 'pos': 0},
{'type': 'gallery', 'id': 2, 'row': 1, 'col': 1, 'pos': 0}
]
}
:return: raw html
<div class="row">
<div class="col-md-6">
<render-component id="1" text></render-component>
</div>
<div class="col-md-6"></div>
</div>
<div class="row">
<div class="col-md-6"></div>
<div class="col-md-6">
<render-component id="2" gallery></render-component>
</div>
</div>
'''
layout = page.layout
if layout:
try:
layout = json.loads(layout)
except Exception:
request.app.logger.exception('Could not parse layout')
layout = None
if not layout:
layout = dict(rows=[{}])
components = layout.get('components') or []
if not components:
components.append(dict(type='self'))
inner = Html(None)
# Loop over rows
for row_idx, row in enumerate(layout.get('rows', ())):
row = AttributeDictionary(row)
if row.cols:
html = self._row(row, components, self_comp)
else:
html = self._component(components[0], self_comp)
html = super().inner_html(request, page, html)
inner.append(html)
return inner.render(request)
def items(self, request):
cms = request.app.cms
for item in cms.all(request, self.name):
html_url = request.absolute_uri(item['path'])
if html_url.endswith('/index'):
html_url = html_url[:-6]
page = AttributeDictionary(loc=html_url,
lastmod=item.get('modified'))
if cms.set_priority:
page.priority = item.get('priority', 1)
yield page
def __init__(self, app, content, metadata, path, src=None, **params):
self._app = app
self._content = content
self._path = path
self._src = src
self._meta = AttributeDictionary(params)
self._update_meta(metadata)
if not self._meta.modified:
if src:
self._meta.modified = modified_datetime(src)
else:
self._meta.modified = datetime.now()
self._meta.name = slugify(self._path, separator='_')
def process_request(self, request):
from django.http import HttpResponse
data = AttributeDictionary(request.__dict__)
environ = data.pop('environ')
environ['django.cache'] = data
response = self._web_socket(environ, None)
if response is not None:
# Convert to django response
if is_failure(response):
response.throw()
resp = HttpResponse(status=response.status_code,
content_type=response.content_type)
for header, value in response.headers:
resp[header] = value
return resp
def __init__(self, app, content, metadata, src, path=None, context=None,
**params):
self._app = app
self._content = content
self._context_for = context
self._additional_context = {}
self._src = src
self._path = path or src
self._meta = AttributeDictionary(params)
if src:
self._meta.modified = modified_datetime(src)
else:
self._meta.modified = datetime.now()
# Get the site meta data dictionary.
# Used to render Content metadata
self._update_meta(metadata)
meta = self._meta
if self.is_html:
dir, slug = os.path.split(self._path)
if not slug:
slug = self._path
dir = None
if not meta.slug:
meta.slug = slugify(slug, separator='_')
if dir:
meta.slug = '%s/%s' % (dir, meta.slug)
else:
if self.suffix: # Any other file
suffix = '.%s' % self.suffix
if not self._path.endswith(suffix):
self._path = self._path + suffix
if not meta.slug:
meta.slug = self._path
meta.name = slugify(meta.slug, separator='_')
for name in self.mandatory_properties:
if not meta.get(name):
raise BuildError("Property '%s' not available in %s"
% (name, self))
def __init__(self, rule, *routes, **parameters):
Router._creation_count += 1
self._creation_count = Router._creation_count
if not isinstance(rule, Route):
rule = Route(rule)
self._route = rule
self._name = parameters.pop('name', rule.name)
self.routes = []
# add routes specified via the initialiser first
for router in routes:
self.add_child(router)
# copy parameters
self.parameters = AttributeDictionary(self.parameters)
for name, rule_method in self.rule_methods.items():
rule, method, params, _, _ = rule_method
rparameters = params.copy()
handler = getattr(self, name)
router = self.add_child(self.make_router(rule, **rparameters))
setattr(router, method, handler)
for name, value in parameters.items():
if name in self.parameters:
self.parameters[name] = value
else:
setattr(self, slugify(name, separator='_'), value)
def testInit(self):
self.assertRaises(TypeError, AttributeDictionary, {}, {})
a = AttributeDictionary({'bla': 1}, foo='pippo')
self.assertEqual(dict(a), {'bla': 1, 'foo': 'pippo'})
self.assertEqual(len(a), 2)
def items(self, request):
model = self.content_router.model(request)
for item in model.all(request):
yield AttributeDictionary(loc=item['url'],
lastmod=item['modified'],
priority=item['priority'])
def __init__(self, *children, **params):
self.as_list = params.pop('as_list', False)
self.parameters = AttributeDictionary(params)
for child in children:
self.append(child)
'''
Constants used throughout pulsar.
'''
from pulsar.utils.structures import AttributeDictionary
# LOW LEVEL CONSTANTS - NO NEED TO CHANGE THOSE ###########################
ACTOR_STATES = AttributeDictionary(INITIAL=0X0,
INACTIVE=0X1,
STARTING=0x2,
RUN=0x3,
STOPPING=0x4,
CLOSE=0x5,
TERMINATE=0x6)
'''
.. _actor-states:
Actor state constants are access via::
from pulsar.api import ACTOR_STATES
They are:
* ``ACTOR_STATES.INITIAL = 0`` when an actor is just created, before the
:class:`pulsar.Actor.start` method is called.
* ``ACTOR_STATES.STARTING = 2`` when :class:`pulsar.Actor.start` method
is called.
* ``ACTOR_STATES.RUN = 3`` when :class:`pulsar.Actor._loop` is up
and running.
* ``ACTOR_STATES.STOPPING = 4`` when :class:`pulsar.Actor.stop` has been
called for the first time and the actor is running.
'''
def testCopy(self):
a = AttributeDictionary(foo=5, bla='ciao')
self.assertEqual(len(a), 2)
b = a.copy()
self.assertEqual(a, b)
self.assertNotEqual(id(a), id(b))
