text:
import operator, weakref
from itertools import chain
import UserDict
from sqlalchemy import util
from sqlalchemy.orm import interfaces, collections
from sqlalchemy.orm.util import identity_equal
from sqlalchemy import exceptions

PASSIVE_NORESULT = util.symbol('PASSIVE_NORESULT')
ATTR_WAS_SET = util.symbol('ATTR_WAS_SET')
NO_VALUE = util.symbol('NO_VALUE')
NEVER_SET = util.symbol('NEVER_SET')

class InstrumentedAttribute(interfaces.PropComparator):
    """public-facing instrumented attribute, placed in the
    class dictionary.

    """

    def __init__(self, impl, comparator=None):
        """Construct an InstrumentedAttribute.
        comparator
          a sql.Comparator to which class-level compare/math events will be sent
        """

        self.impl = impl
        self.comparator = comparator

    def __set__(self, instance, value):
        self.impl.set(instance._state, value, None)

    def __delete__(self, instance):
        self.impl.delete(instance._state)

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return self.impl.get(instance._state)

    def get_history(self, instance, **kwargs):
        return self.impl.get_history(instance._state, **kwargs)

    def clause_element(self):
        return self.comparator.clause_element()

    def expression_element(self):
        return self.comparator.expression_element()

    def label(self, name):
        return self.clause_element().label(name)

    def operate(self, op, *other, **kwargs):
        return op(self.comparator, *other, **kwargs)

    def reverse_operate(self, op, other, **kwargs):
        return op(other, self.comparator, **kwargs)

    def hasparent(self, instance, optimistic=False):
        return self.impl.hasparent(instance._state, optimistic=optimistic)

    def _property(self):
        from sqlalchemy.orm.mapper import class_mapper
        return class_mapper(self.impl.class_).get_property(self.impl.key)
    property = property(_property, doc="the MapperProperty object associated with this attribute")

class ProxiedAttribute(InstrumentedAttribute):
    """Adds InstrumentedAttribute class-level behavior to a regular descriptor.

    Obsoleted by proxied_attribute_factory.
    """

    class ProxyImpl(object):
        accepts_scalar_loader = False

        def __init__(self, key):
            self.key = key

    def __init__(self, key, user_prop, comparator=None):
        self.user_prop = user_prop
        self._comparator = comparator
        self.key = key
        self.impl = ProxiedAttribute.ProxyImpl(key)

    def comparator(self):
        if callable(self._comparator):
            self._comparator = self._comparator()
        return self._comparator
    comparator = property(comparator)

    def __get__(self, instance, owner):
        if instance is None:
            self.user_prop.__get__(instance, owner)
            return self
        return self.user_prop.__get__(instance, owner)

    def __set__(self, instance, value):
        return self.user_prop.__set__(instance, value)

    def __delete__(self, instance):
        return self.user_prop.__delete__(instance)

def proxied_attribute_factory(descriptor):
    """Create an InstrumentedAttribute / user descriptor hybrid.

    Returns a new InstrumentedAttribute type that delegates descriptor
    behavior and getattr() to the given descriptor.
    """

    class ProxyImpl(object):
        accepts_scalar_loader = False
        def __init__(self, key):
            self.key = key

    class Proxy(InstrumentedAttribute):
        """A combination of InsturmentedAttribute and a regular descriptor."""

        def __init__(self, key, descriptor, comparator):
            self.key = key
            # maintain ProxiedAttribute.user_prop compatability.
            self.descriptor = self.user_prop = descriptor
            self._comparator = comparator
            self.impl = ProxyImpl(key)

        def comparator(self):
            if callable(self._comparator):
                self._comparator = self._comparator()
            return self._comparator
        comparator = property(comparator)

        def __get__(self, instance, owner):
            """Delegate __get__ to the original descriptor."""
            if instance is None:
                descriptor.__get__(instance, owner)
                return self
            return descriptor.__get__(instance, owner)

        def __set__(self, instance, value):
            """Delegate __set__ to the original descriptor."""
            return descriptor.__set__(instance, value)

        def __delete__(self, instance):
            """Delegate __delete__ to the original descriptor."""
            return descriptor.__delete__(instance)

        def __getattr__(self, attribute):
            """Delegate __getattr__ to the original descriptor."""
            return getattr(descriptor, attribute)
    Proxy.__name__ = type(descriptor).__name__ + 'Proxy'

    util.monkeypatch_proxied_specials(Proxy, type(descriptor),
                                      name='descriptor',
                                      from_instance=descriptor)
    return Proxy

class AttributeImpl(object):
    """internal implementation for instrumented attributes."""

    def __init__(self, class_, key, callable_, trackparent=False, extension=None, compare_function=None, **kwargs):
        """Construct an AttributeImpl.

        class_
          the class to be instrumented.

        key
          string name of the attribute

        callable_
          optional function which generates a callable based on a parent
          instance, which produces the "default" values for a scalar or
          collection attribute when it's first accessed, if not present
          already.

        trackparent
          if True, attempt to track if an instance has a parent attached
          to it via this attribute.

        extension
          an AttributeExtension object which will receive
          set/delete/append/remove/etc. events.

        compare_function
          a function that compares two values which are normally
          assignable to this attribute.

        """

        self.class_ = class_
        self.key = key
        self.callable_ = callable_
        self.trackparent = trackparent
        if compare_function is None:
            self.is_equal = operator.eq
        else:
            self.is_equal = compare_function
        self.extensions = util.to_list(extension or [])

    def hasparent(self, state, optimistic=False):
        """Return the boolean value of a `hasparent` flag attached to the given item.

        The `optimistic` flag determines what the default return value
        should be if no `hasparent` flag can be located.

        As this function is used to determine if an instance is an
        *orphan*, instances that were loaded from storage should be
        assumed to not be orphans, until a True/False value for this
        flag is set.

        An instance attribute that is loaded by a callable function
        will also not have a `hasparent` flag.
        """

        return state.parents.get(id(self), optimistic)

    def sethasparent(self, state, value):
        """Set a boolean flag on the given item corresponding to
        whether or not it is attached to a parent object via the
        attribute represented by this ``InstrumentedAttribute``.
        """

        state.parents[id(self)] = value

    def set_callable(self, state, callable_):
        """Set a callable function for this attribute on the given object.

        This callable will be executed when the attribute is next
        accessed, and is assumed to construct part of the instances
        previously stored state. When its value or values are loaded,
        they will be established as part of the instance's *committed
        state*.  While *trackparent* information will be assembled for
        these instances, attribute-level event handlers will not be
        fired.

        The callable overrides the class level callable set in the
        ``InstrumentedAttribute` constructor.
        """

        if callable_ is None:
            self.initialize(state)
        else:
            state.callables[self.key] = callable_

    def get_history(self, state, passive=False):
        raise NotImplementedError()

    def _get_callable(self, state):
        if self.key in state.callables:
            return state.callables[self.key]
        elif self.callable_ is not None:
            return self.callable_(state.obj())
        else:
            return None

    def initialize(self, state):
        """Initialize this attribute on the given object instance with an empty value."""

        state.dict[self.key] = None
        return None

    def get(self, state, passive=False):
        """Retrieve a value from the given object.

        If a callable is assembled on this object's attribute, and
        passive is False, the callable will be executed and the
        resulting value will be set as the new value for this attribute.
        """

        try:
            return state.dict[self.key]
        except KeyError:
            # if no history, check for lazy callables, etc.
            if self.key not in state.committed_state:
                callable_ = self._get_callable(state)
                if callable_ is not None:
                    if passive:
                        return PASSIVE_NORESULT
                    value = callable_()
                    if value is not ATTR_WAS_SET:
                        return self.set_committed_value(state, value)
                    else:
                        if self.key not in state.dict:
                            return self.get(state, passive=passive)
                        return state.dict[self.key]

            # Return a new, empty value
            return self.initialize(state)

    def append(self, state, value, initiator, passive=False):
        self.set(state, value, initiator)

    def remove(self, state, value, initiator, passive=False):
        self.set(state, None, initiator)

    def set(self, state, value, initiator):
        raise NotImplementedError()

    def get_committed_value(self, state):
        """return the unchanged value of this attribute"""

        if self.key in state.committed_state:
            if state.committed_state[self.key] is NO_VALUE:
                return None
            else:
                return state.committed_state.get(self.key)
        else:
            return self.get(state)

    def set_committed_value(self, state, value):
        """set an attribute value on the given instance and 'commit' it."""

        state.commit_attr(self, value)
        return value

class ScalarAttributeImpl(AttributeImpl):
    """represents a scalar value-holding InstrumentedAttribute."""

    accepts_scalar_loader = True

    def delete(self, state):
        if self.key not in state.committed_state:
            state.committed_state[self.key] = state.dict.get(self.key, NO_VALUE)

        # TODO: catch key errors, convert to attributeerror?
        del state.dict[self.key]
        state.modified=True

    def get_history(self, state, passive=False):
        return _create_history(self, state, state.dict.get(self.key, NO_VALUE))

    def set(self, state, value, initiator):
        if initiator is self:
            return

        if self.key not in state.committed_state:
            state.committed_state[self.key] = state.dict.get(self.key, NO_VALUE)

        state.dict[self.key] = value
        state.modified=True

    def type(self):
        self.property.columns[0].type
    type = property(type)

class MutableScalarAttributeImpl(ScalarAttributeImpl):
    """represents a scalar value-holding InstrumentedAttribute, which can detect
    changes within the value itself.
    """

    def __init__(self, class_, key, callable_, copy_function=None, compare_function=None, **kwargs):
        super(ScalarAttributeImpl, self).__init__(class_, key, callable_, compare_function=compare_function, **kwargs)
        class_._class_state.has_mutable_scalars = True
        if copy_function is None:
            raise exceptions.ArgumentError("MutableScalarAttributeImpl requires a copy function")
        self.copy = copy_function

    def get_history(self, state, passive=False):
        return _create_history(self, state, state.dict.get(self.key, NO_VALUE))

    def commit_to_state(self, state, value):
        state.committed_state[self.key] = self.copy(value)

    def check_mutable_modified(self, state):
        (added, unchanged, deleted) = self.get_history(state, passive=True)
        if added or deleted:
            state.modified = True
            return True
        else:
            return False

    def set(self, state, value, initiator):
        if initiator is self:
            return

        if self.key not in state.committed_state:
            if self.key in state.dict:
                state.committed_state[self.key] = self.copy(state.dict[self.key])
            else:
                state.committed_state[self.key] = NO_VALUE

        state.dict[self.key] = value
        state.modified=True

class ScalarObjectAttributeImpl(ScalarAttributeImpl):
    """represents a scalar-holding InstrumentedAttribute, where the target object is also instrumented.

    Adds events to delete/set operations.
    """

    accepts_scalar_loader = False

    def __init__(self, class_, key, callable_, trackparent=False, extension=None, copy_function=None, compare_function=None, **kwargs):
        super(ScalarObjectAttributeImpl, self).__init__(class_, key,
          callable_, trackparent=trackparent, extension=extension,
          compare_function=compare_function, **kwargs)
        if compare_function is None:
            self.is_equal = identity_equal

    def delete(self, state):
        old = self.get(state)
        # TODO: catch key errors, convert to attributeerror?
        del state.dict[self.key]
        self.fire_remove_event(state, old, self)

    def get_history(self, state, passive=False):
        if self.key in state.dict:
            return _create_history(self, state, state.dict[self.key])
        else:
            current = self.get(state, passive=passive)
            if current is PASSIVE_NORESULT:
                return (None, None, None)
            else:
                return _create_history(self, state, current)

    def set(self, state, value, initiator):
        """Set a value on the given InstanceState.

        `initiator` is the ``InstrumentedAttribute`` that initiated the
        ``set()` operation and is used to control the depth of a circular
        setter operation.
        """

        if initiator is self:
            return

        if value is not None and not hasattr(value, '_state'):
            raise TypeError("Can not assign %s instance to %s's %r attribute, "
                            "a mapped instance was expected." % (
                type(value).__name__, type(state.obj()).__name__, self.key))

        # TODO: add options to allow the get() to be passive
        old = self.get(state)
        state.dict[self.key] = value
        self.fire_replace_event(state, value, old, initiator)

    def fire_remove_event(self, state, value, initiator):
        if self.key not in state.committed_state:
            state.committed_state[self.key] = value
        state.modified = True

        if self.trackparent and value is not None:
            self.sethasparent(value._state, False)

        instance = state.obj()
        for ext in self.extensions:
            ext.remove(instance, value, initiator or self)

    def fire_replace_event(self, state, value, previous, initiator):
        if self.key not in state.committed_state:
            state.committed_state[self.key] = previous
        state.modified = True

        if self.trackparent:
            if value is not None:
                self.sethasparent(value._state, True)
            if previous is not value and previous is not None:
                self.sethasparent(previous._state, False)

        instance = state.obj()
        for ext in self.extensions:
            ext.set(instance, value, previous, initiator or self)

class CollectionAttributeImpl(AttributeImpl):
    """A collection-holding attribute that instruments changes in membership.

    Only handles collections of instrumented objects.

    InstrumentedCollectionAttribute holds an arbitrary, user-specified
    container object (defaulting to a list) and brokers access to the
    CollectionAdapter, a "view" onto that object that presents consistent
    bag semantics to the orm layer independent of the user data implementation.
    """
    accepts_scalar_loader = False

    def __init__(self, class_, key, callable_, typecallable=None, trackparent=False, extension=None, copy_function=None, compare_function=None, **kwargs):
        super(CollectionAttributeImpl, self).__init__(class_,
          key, callable_, trackparent=trackparent, extension=extension,
          compare_function=compare_function, **kwargs)

        if copy_function is None:
            copy_function = self.__copy
        self.copy = copy_function

        if typecallable is None:
            typecallable = list
        self.collection_factory = \
          collections._prepare_instrumentation(typecallable)
        # may be removed in 0.5:
        self.collection_interface = \
          util.duck_type_collection(self.collection_factory())

    def __copy(self, item):
        return [y for y in list(collections.collection_adapter(item))]

    def get_history(self, state, passive=False):
        current = self.get(state, passive=passive)
        if current is PASSIVE_NORESULT:
            return (None, None, None)
        else:
            return _create_history(self, state, current)

    def fire_append_event(self, state, value, initiator):
        if self.key not in state.committed_state and self.key in state.dict:
            state.committed_state[self.key] = self.copy(state.dict[self.key])

        state.modified = True

        if self.trackparent and value is not None:
            self.sethasparent(value._state, True)
        instance = state.obj()
        for ext in self.extensions:
            ext.append(instance, value, initiator or self)

    def fire_pre_remove_event(self, state, initiator):
        if self.key not in state.committed_state and self.key in state.dict:
            state.committed_state[self.key] = self.copy(state.dict[self.key])

    def fire_remove_event(self, state, value, initiator):
        if self.key not in state.committed_state and self.key in state.dict:
            state.committed_state[self.key] = self.copy(state.dict[self.key])

        state.modified = True

        if self.trackparent and value is not None:
            self.sethasparent(value._state, False)

        instance = state.obj()
        for ext in self.extensions:
            ext.remove(instance, value, initiator or self)

    def delete(self, state):
        if self.key not in state.dict:
            return

        state.modified = True

        collection = self.get_collection(state)
        collection.clear_with_event()
        # TODO: catch key errors, convert to attributeerror?
        del state.dict[self.key]

    def initialize(self, state):
        """Initialize this attribute on the given object instance with an empty collection."""

        _, user_data = self._build_collection(state)
        state.dict[self.key] = user_data
        return user_data

    def append(self, state, value, initiator, passive=False):
        if initiator is self:
            return

        collection = self.get_collection(state, passive=passive)
        if collection is PASSIVE_NORESULT:
            state.get_pending(self.key).append(value)
            self.fire_append_event(state, value, initiator)
        else:
            collection.append_with_event(value, initiator)

    def remove(self, state, value, initiator, passive=False):
        if initiator is self:
            return

        collection = self.get_collection(state, passive=passive)
        if collection is PASSIVE_NORESULT:
            state.get_pending(self.key).remove(value)
            self.fire_remove_event(state, value, initiator)
        else:
            collection.remove_with_event(value, initiator)

    def set(self, state, value, initiator):
        """Set a value on the given object.

        `initiator` is the ``InstrumentedAttribute`` that initiated the
        ``set()` operation and is used to control the depth of a circular
        setter operation.
        """

        if initiator is self:
            return

        self._set_iterable(
            state, value,
            lambda adapter, i: adapter.adapt_like_to_iterable(i))

    def _set_iterable(self, state, iterable, adapter=None):
        """Set a collection value from an iterable of state-bearers.

        ``adapter`` is an optional callable invoked with a CollectionAdapter
        and the iterable.  Should return an iterable of state-bearing
        instances suitable for appending via a CollectionAdapter.  Can be used
        for, e.g., adapting an incoming dictionary into an iterator of values
        rather than keys.

        """
        # pulling a new collection first so that an adaptation exception does
        # not trigger a lazy load of the old collection.
        new_collection, user_data = self._build_collection(state)
        if adapter:
            new_values = list(adapter(new_collection, iterable))
        else:
            new_values = list(iterable)

        old = self.get(state)

        # ignore re-assignment of the current collection, as happens
        # implicitly with in-place operators (foo.collection |= other)
        if old is iterable:
            return

        if self.key not in state.committed_state:
            state.committed_state[self.key] = self.copy(old)

        old_collection = self.get_collection(state, old)

        state.dict[self.key] = user_data
        state.modified = True

        collections.bulk_replace(new_values, old_collection, new_collection)
        old_collection.unlink(old)

    def set_committed_value(self, state, value):
        """Set an attribute value on the given instance and 'commit' it.

        Loads the existing collection from lazy callables in all cases.
        """

        collection, user_data = self._build_collection(state)

        if value:
            for item in value:
                collection.append_without_event(item)

        state.callables.pop(self.key, None)
        state.dict[self.key] = user_data

        if self.key in state.pending:
            # pending items.  commit loaded data, add/remove new data
            state.committed_state[self.key] = list(value or [])
            added = state.pending[self.key].added_items
            removed = state.pending[self.key].deleted_items
            for item in added:
                collection.append_without_event(item)
            for item in removed:
                collection.remove_without_event(item)
            del state.pending[self.key]
        elif self.key in state.committed_state:
            # no pending items.  remove committed state if any.
            # (this can occur with an expired attribute)
            del state.committed_state[self.key]

        return user_data

    def _build_collection(self, state):
        """build a new, blank collection and return it wrapped in a CollectionAdapter."""

        user_data = self.collection_factory()
        collection = collections.CollectionAdapter(self, state, user_data)
        return collection, user_data

    def get_collection(self, state, user_data=None, passive=False):
        """retrieve the CollectionAdapter associated with the given state.

        Creates a new CollectionAdapter if one does not exist.

        """

        if user_data is None:
            user_data = self.get(state, passive=passive)
            if user_data is PASSIVE_NORESULT:
                return user_data
        try:
            return getattr(user_data, '_sa_adapter')
        except AttributeError:
            # TODO: this codepath never occurs, and this
            # except/initialize should be removed
            collections.CollectionAdapter(self, state, user_data)
            return getattr(user_data, '_sa_adapter')

class GenericBackrefExtension(interfaces.AttributeExtension):
    """An extension which synchronizes a two-way relationship.

    A typical two-way relationship is a parent object containing a
    list of child objects, where each child object references the
    parent.  The other are two objects which contain scalar references
    to each other.
    """

    def __init__(self, key):
        self.key = key

    def set(self, instance, child, oldchild, initiator):
        if oldchild is child:
            return
        if oldchild is not None:
            # With lazy=None, there's no guarantee that the full collection is
            # present when updating via a backref.
            impl = getattr(oldchild.__class__, self.key).impl
            try:
                impl.remove(oldchild._state, instance, initiator, passive=True)
            except (ValueError, KeyError, IndexError):
                pass
        if child is not None:
            getattr(child.__class__, self.key).impl.append(child._state, instance, initiator, passive=True)

    def append(self, instance, child, initiator):
        getattr(child.__class__, self.key).impl.append(child._state, instance, initiator, passive=True)

    def remove(self, instance, child, initiator):
        if child is not None:
            getattr(child.__class__, self.key).impl.remove(child._state, instance, initiator, passive=True)

class ClassState(object):
    """tracks state information at the class level."""
    def __init__(self):
        self.mappers = {}
        self.attrs = {}
        self.has_mutable_scalars = False

import sets
_empty_set = sets.ImmutableSet()

class InstanceState(object):
    """tracks state information at the instance level."""

    def __init__(self, obj):
        self.class_ = obj.__class__
        self.obj = weakref.ref(obj, self.__cleanup)
        self.dict = obj.__dict__
        self.committed_state = {}
        self.modified = False
        self.callables = {}
        self.parents = {}
        self.pending = {}
        self.appenders = {}
        self.instance_dict = None
        self.runid = None
        self.expired_attributes = _empty_set

    def __cleanup(self, ref):
        # tiptoe around Python GC unpredictableness
        instance_dict = self.instance_dict
        if instance_dict is None:
            return

        instance_dict = instance_dict()
        if instance_dict is None or instance_dict._mutex is None:
            return

        # the mutexing here is based on the assumption that gc.collect()
        # may be firing off cleanup handlers in a different thread than that
        # which is normally operating upon the instance dict.
        instance_dict._mutex.acquire()
        try:
            try:
                self.__resurrect(instance_dict)
            except:
                # catch app cleanup exceptions.  no other way around this
                # without warnings being produced
                pass
        finally:
            instance_dict._mutex.release()

    def _check_resurrect(self, instance_dict):
        instance_dict._mutex.acquire()
        try:
            return self.obj() or self.__resurrect(instance_dict)
        finally:
            instance_dict._mutex.release()

    def get_pending(self, key):
        if key not in self.pending:
            self.pending[key] = PendingCollection()
        return self.pending[key]

    def is_modified(self):
        if self.modified:
            return True
        elif self.class_._class_state.has_mutable_scalars:
            for attr in _managed_attributes(self.class_):
                if hasattr(attr.impl, 'check_mutable_modified') and attr.impl.check_mutable_modified(self):
                    return True
            else:
                return False
        else:
            return False

    def __resurrect(self, instance_dict):
        if self.is_modified():
            # store strong ref'ed version of the object; will revert
            # to weakref when changes are persisted
            obj = new_instance(self.class_, state=self)
            self.obj = weakref.ref(obj, self.__cleanup)
            self._strong_obj = obj
            obj.__dict__.update(self.dict)
            self.dict = obj.__dict__
            return obj
        else:
            del instance_dict[self.dict['_instance_key']]
            return None

    def __getstate__(self):
        return {'committed_state':self.committed_state, 'pending':self.pending, 'parents':self.parents, 'modified':self.modified, 'instance':self.obj(), 'expired_attributes':self.expired_attributes, 'callables':self.callables}

    def __setstate__(self, state):
        self.committed_state = state['committed_state']
        self.parents = state['parents']
        self.pending = state['pending']
        self.modified = state['modified']
        self.obj = weakref.ref(state['instance'])
        self.class_ = self.obj().__class__
        self.dict = self.obj().__dict__
        self.callables = state['callables']
        self.runid = None
        self.appenders = {}
        self.expired_attributes = state['expired_attributes']

    def initialize(self, key):
        getattr(self.class_, key).impl.initialize(self)

    def set_callable(self, key, callable_):
        self.dict.pop(key, None)
        self.callables[key] = callable_

    def __call__(self):
        """__call__ allows the InstanceState to act as a deferred
        callable for loading expired attributes, which is also
        serializable.
        """
        instance = self.obj()
        unmodified = self.unmodified
        self.class_._class_state.deferred_scalar_loader(instance, [
            attr.impl.key for attr in _managed_attributes(self.class_) if
                attr.impl.accepts_scalar_loader and
                attr.impl.key in self.expired_attributes and
                attr.impl.key in unmodified
            ])
        for k in self.expired_attributes:
            self.callables.pop(k, None)
        self.expired_attributes.clear()
        return ATTR_WAS_SET

    def unmodified(self):
        """a set of keys which have no uncommitted changes"""

        return util.Set([
            attr.impl.key for attr in _managed_attributes(self.class_) if
            attr.impl.key not in self.committed_state
            and (not hasattr(attr.impl, 'commit_to_state') or not attr.impl.check_mutable_modified(self))
        ])
    unmodified = property(unmodified)

    def expire_attributes(self, attribute_names):
        self.expired_attributes = util.Set(self.expired_attributes)

        if attribute_names is None:
            for attr in _managed_attributes(self.class_):
                self.dict.pop(attr.impl.key, None)
                self.expired_attributes.add(attr.impl.key)
                if attr.impl.accepts_scalar_loader:
                    self.callables[attr.impl.key] = self

            self.committed_state = {}
        else:
            for key in attribute_names:
                self.dict.pop(key, None)
                self.committed_state.pop(key, None)
                self.expired_attributes.add(key)
                if getattr(self.class_, key).impl.accepts_scalar_loader:
                    self.callables[key] = self

    def reset(self, key):
        """remove the given attribute and any callables associated with it."""
        self.dict.pop(key, None)
        self.callables.pop(key, None)

    def commit_attr(self, attr, value):
        """set the value of an attribute and mark it 'committed'."""

        if hasattr(attr, 'commit_to_state'):
            attr.commit_to_state(self, value)
        else:
            self.committed_state.pop(attr.key, None)
        self.dict[attr.key] = value
        self.pending.pop(attr.key, None)
        self.appenders.pop(attr.key, None)

        # we have a value so we can also unexpire it
        self.callables.pop(attr.key, None)
        if attr.key in self.expired_attributes:
            self.expired_attributes.remove(attr.key)

    def commit(self, keys):
        """commit all attributes named in the given list of key names.

        This is used by a partial-attribute load operation to mark committed those attributes
        which were refreshed from the database.

        Attributes marked as "expired" can potentially remain "expired" after this step
        if a value was not populated in state.dict.
        """

        if self.class_._class_state.has_mutable_scalars:
            for key in keys:
                attr = getattr(self.class_, key).impl
                if hasattr(attr, 'commit_to_state') and attr.key in self.dict:
                    attr.commit_to_state(self, self.dict[attr.key])
                else:
                    self.committed_state.pop(attr.key, None)
                self.pending.pop(key, None)
                self.appenders.pop(key, None)
        else:
            for key in keys:
                self.committed_state.pop(key, None)
                self.pending.pop(key, None)
                self.appenders.pop(key, None)

        # unexpire attributes which have loaded
        for key in self.expired_attributes.intersection(keys):
            if key in self.dict:
                self.expired_attributes.remove(key)
                self.callables.pop(key, None)

    def commit_all(self):
        """commit all attributes unconditionally.

        This is used after a flush() or a regular instance load or refresh operation
        to mark committed all populated attributes.

        Attributes marked as "expired" can potentially remain "expired" after this step
        if a value was not populated in state.dict.
        """

        self.committed_state = {}
        self.modified = False
        self.pending = {}
        self.appenders = {}

        # unexpire attributes which have loaded
        for key in list(self.expired_attributes):
            if key in self.dict:
                self.expired_attributes.remove(key)
                self.callables.pop(key, None)

        if self.class_._class_state.has_mutable_scalars:
            for attr in _managed_attributes(self.class_):
                if hasattr(attr.impl, 'commit_to_state') and attr.impl.key in self.dict:
                    attr.impl.commit_to_state(self, self.dict[attr.impl.key])

        # remove strong ref
        self._strong_obj = None

class WeakInstanceDict(UserDict.UserDict):
    """similar to WeakValueDictionary, but wired towards 'state' objects."""

    def __init__(self, *args, **kw):
        self._wr = weakref.ref(self)
        # RLock because the mutex is used by a cleanup handler, which can be
        # called at any time (including within an already mutexed block)
        self._mutex = util.threading.RLock()
        UserDict.UserDict.__init__(self, *args, **kw)

    def __getitem__(self, key):
        state = self.data[key]
        o = state.obj()
        if o is None:
            o = state._check_resurrect(self)
        if o is None:
            raise KeyError, key
        return o

    def __contains__(self, key):
        try:
            state = self.data[key]
            o = state.obj()
            if o is None:
                o = state._check_resurrect(self)
        except KeyError:
            return False
        return o is not None

    def has_key(self, key):
        return key in self

    def __repr__(self):
        return "<InstanceDict at %s>" % id(self)

    def __setitem__(self, key, value):
        if key in self.data:
            self._mutex.acquire()
            try:
                if key in self.data:
                    self.data[key].instance_dict = None
            finally:
                self._mutex.release()
        self.data[key] = value._state
        value._state.instance_dict = self._wr

    def __delitem__(self, key):
        state = self.data[key]
        state.instance_dict = None
        del self.data[key]

    def get(self, key, default=None):
        try:
            state = self.data[key]
        except KeyError:
            return default
        else:
            o = state.obj()
            if o is None:
                # This should only happen
                return default
            else:
                return o

    def items(self):
        L = []
        for key, state in self.data.items():
            o = state.obj()
            if o is not None:
                L.append((key, o))
        return L

    def iteritems(self):
        for state in self.data.itervalues():
            value = state.obj()
            if value is not None:
                yield value._instance_key, value

    def iterkeys(self):
        return self.data.iterkeys()

    def __iter__(self):
        return self.data.iterkeys()

    def __len__(self):
        return len(self.values())

    def itervalues(self):
        for state in self.data.itervalues():
            instance = state.obj()
            if instance is not None:
                yield instance

    def values(self):
        L = []
        for state in self.data.values():
            o = state.obj()
            if o is not None:
                L.append(o)
        return L

    def popitem(self):
        raise NotImplementedError()

    def pop(self, key, *args):
        raise NotImplementedError()

    def setdefault(self, key, default=None):
        raise NotImplementedError()

    def update(self, dict=None, **kwargs):
        raise NotImplementedError()

    def copy(self):
        raise NotImplementedError()

    def all_states(self):
        return self.data.values()

class StrongInstanceDict(dict):
    def all_states(self):
        return [o._state for o in self.values()]

def _create_history(attr, state, current):
    original = state.committed_state.get(attr.key, NEVER_SET)

    if hasattr(attr, 'get_collection'):
        current = attr.get_collection(state, current)
        if original is NO_VALUE:
            return (list(current), [], [])
        elif original is NEVER_SET:
            return ([], list(current), [])
        else:
            collection = util.OrderedIdentitySet(current)
            s = util.OrderedIdentitySet(original)
            return (list(collection.difference(s)), list(collection.intersection(s)), list(s.difference(collection)))
    else:
        if current is NO_VALUE:
            if original not in [None, NEVER_SET, NO_VALUE]:
                deleted = [original]
            else:
                deleted = []
            return ([], [], deleted)
        elif original is NO_VALUE:
            return ([current], [], [])
        elif original is NEVER_SET or attr.is_equal(current, original) is True:   # dont let ClauseElement expressions here trip things up
            return ([], [current], [])
        else:
            if original is not None:
                deleted = [original]
            else:
                deleted = []
            return ([current], [], deleted)

class PendingCollection(object):
    """stores items appended and removed from a collection that has not been loaded yet.

    When the collection is loaded, the changes present in PendingCollection are applied
    to produce the final result.
    """

    def __init__(self):
        self.deleted_items = util.IdentitySet()
        self.added_items = util.OrderedIdentitySet()

    def append(self, value):
        if value in self.deleted_items:
            self.deleted_items.remove(value)
        self.added_items.add(value)

    def remove(self, value):
        if value in self.added_items:
            self.added_items.remove(value)
        self.deleted_items.add(value)

def _managed_attributes(class_):
    """return all InstrumentedAttributes associated with the given class_ and its superclasses."""

    return chain(*[cl._class_state.attrs.values() for cl in class_.__mro__[:-1] if hasattr(cl, '_class_state')])

def get_history(state, key, **kwargs):
    return getattr(state.class_, key).impl.get_history(state, **kwargs)

def get_as_list(state, key, passive=False):
    """return an InstanceState attribute as a list,
    regardless of it being a scalar or collection-based
    attribute.

    returns None if passive=True and the getter returns
    PASSIVE_NORESULT.
    """

    attr = getattr(state.class_, key).impl
    x = attr.get(state, passive=passive)
    if x is PASSIVE_NORESULT:
        return None
    elif hasattr(attr, 'get_collection'):
        return attr.get_collection(state, x, passive=passive)
    elif isinstance(x, list):
        return x
    else:
        return [x]

def has_parent(class_, instance, key, optimistic=False):
    return getattr(class_, key).impl.hasparent(instance._state, optimistic=optimistic)

def _create_prop(class_, key, uselist, callable_, typecallable, useobject, mutable_scalars, impl_class, **kwargs):
    if impl_class:
        return impl_class(class_, key, typecallable, **kwargs)
    elif uselist:
        return CollectionAttributeImpl(class_, key, callable_, typecallable, **kwargs)
    elif useobject:
        return ScalarObjectAttributeImpl(class_, key, callable_,**kwargs)
    elif mutable_scalars:
        return MutableScalarAttributeImpl(class_, key, callable_, **kwargs)
    else:
        return ScalarAttributeImpl(class_, key, callable_, **kwargs)

def manage(instance):
    """initialize an InstanceState on the given instance."""

    if not hasattr(instance, '_state'):
        instance._state = InstanceState(instance)

def new_instance(class_, state=None):
    """create a new instance of class_ without its __init__() method being called.

    Also initializes an InstanceState on the new instance.
    """

    s = class_.__new__(class_)
    if state:
        s._state = state
    else:
        s._state = InstanceState(s)
    return s

def _init_class_state(class_):
    if not '_class_state' in class_.__dict__:
        class_._class_state = ClassState()

def register_class(class_, extra_init=None, on_exception=None, deferred_scalar_loader=None):
    _init_class_state(class_)
    class_._class_state.deferred_scalar_loader=deferred_scalar_loader

    oldinit = None
    doinit = False

    def init(instance, *args, **kwargs):
        if not hasattr(instance, '_state'):
            instance._state = InstanceState(instance)

        if extra_init:
            extra_init(class_, oldinit, instance, args, kwargs)

        try:
            if doinit:
                oldinit(instance, *args, **kwargs)
            elif args or kwargs:
                # simulate error message raised by object(), but don't copy
                # the text verbatim
                raise TypeError("default constructor for object() takes no parameters")
        except:
            if on_exception:
                on_exception(class_, oldinit, instance, args, kwargs)
            raise

    # override oldinit
    oldinit = class_.__init__
    if oldinit is None or not hasattr(oldinit, '_oldinit'):
        init._oldinit = oldinit
        class_.__init__ = init
    # if oldinit is already one of our 'init' methods, replace it
    elif hasattr(oldinit, '_oldinit'):
        init._oldinit = oldinit._oldinit
        class_.__init = init
        oldinit = oldinit._oldinit

    if oldinit is not None:
        doinit = oldinit is not object.__init__
        try:
            init.__name__ = oldinit.__name__
            init.__doc__ = oldinit.__doc__
        except:
            # cant set __name__ in py 2.3 !
            pass

def unregister_class(class_):
    if hasattr(class_, '__init__') and hasattr(class_.__init__, '_oldinit'):
        if class_.__init__._oldinit is not None:
            class_.__init__ = class_.__init__._oldinit
        else:
            delattr(class_, '__init__')

    if '_class_state' in class_.__dict__:
        _class_state = class_.__dict__['_class_state']
        for key, attr in _class_state.attrs.iteritems():
            if key in class_.__dict__:
                delattr(class_, attr.impl.key)
        delattr(class_, '_class_state')

def register_attribute(class_, key, uselist, useobject, callable_=None, proxy_property=None, mutable_scalars=False, impl_class=None, **kwargs):
    _init_class_state(class_)

    typecallable = kwargs.pop('typecallable', None)
    if isinstance(typecallable, InstrumentedAttribute):
        typecallable = None
    comparator = kwargs.pop('comparator', None)

    if key in class_.__dict__ and isinstance(class_.__dict__[key], InstrumentedAttribute):
        # this currently only occurs if two primary mappers are made for the same class.
        # TODO:  possibly have InstrumentedAttribute check "entity_name" when searching for impl.
        # raise an error if two attrs attached simultaneously otherwise
        return

    if proxy_property:
        proxy_type = proxied_attribute_factory(proxy_property)
        inst = proxy_type(key, proxy_property, comparator)
    else:
        inst = InstrumentedAttribute(_create_prop(class_, key, uselist, callable_, useobject=useobject,
                                       typecallable=typecallable, mutable_scalars=mutable_scalars, impl_class=impl_class, **kwargs), comparator=comparator)

    setattr(class_, key, inst)
    class_._class_state.attrs[key] = inst

def unregister_attribute(class_, key):
    class_state = class_._class_state
    if key in class_state.attrs:
        del class_._class_state.attrs[key]
        delattr(class_, key)

def init_collection(instance, key):
    """Initialize a collection attribute and return the collection adapter."""
    attr = getattr(instance.__class__, key).impl
    state = instance._state
    user_data = attr.initialize(state)
    return attr.get_collection(state, user_data)

redpajama_set_name: RedPajamaGithub


Autoignited lifted flames of dimethyl ether (DME) in laminar nonpremixed jets with high-temperature coflow air have been studied experimentally. When the initial temperature was elevated to over 860 K, an autoignition occurred without requiring an external ignition source. A planar laser-induced fluorescence (PLIF) technique for formaldehyde (CH2O) visualized qualitatively the zone of low temperature kinetics in a premixed flame. Two flame configurations were investigated; (1) autoignited lifted flames with tribrachial edge having three distinct branches of a lean and a rich premixed flame wings with a trailing diffusion flame and (2) autoignited lifted flames with mild combustion when the fuel was highly diluted. For the autoignited tribrachial edge flames at critical autoignition conditions, exhibiting repetitive extinction and re-ignition phenomena near a blowout condition, the characteristic flow time (liftoff height scaled with jet velocity) was correlated with the square of the ignition delay time of the stoichiometric mixture. The liftoff heights were also correlated as a function of jet velocity times the square of ignition delay time. Formaldehydes were observed between the fuel nozzle and the lifted flame edge, emphasizing a low-temperature kinetics for autoignited lifted flames, while for a non-autoignited lifted flame, formaldehydes were observed near a thin luminous flame zone.For the autoignited lifted flames with mild combustion, especially at a high temperature, a unique non-monotonic liftoff height behavior was observed; decreasing and then increasing liftoff height with jet velocity. This behavior was similar to the binary mixture fuels of CH4/H2 and CO/H2 observed previously. A transient homogeneous autoignition analysis suggested that such decreasing behavior with jet velocity can be attributed to partial oxidation characteristics of DME in producing appreciable amounts of CH4/CO/H2 ahead of the edge flame region.
Al-Noman SM, Choi BC, Chung SH (2018) Autoignited lifted flames of dimethyl ether in heated coflow air. Combustion and Flame. Available: http://dx.doi.org/10.1016/j.combustflame.2018.04.020.
This work was supported by King Abdullah University of Science and Technology (KAUST).


text:
  Name of AppThwack device pool to use.

  Examples:

  Top 10 devices

  Top 25 devices

  My Custom Tablet Pool


Miles M.C.§ and Fuxjager, M.J. in press. Phenotypic diversity arises from secondary signal loss in the elaborate visual displays of toucans and barbets. The American Naturalist.
Rieger, N. S., Fuxjager, M.J., Trainor, B.C., Zhao, X., and Marler, C.A. in press. Behavioral and neuroendocrine plasticity in the form of the winner and loser effects. In: O.C. Schultheiss and P.H. Mehta (Eds.). Routledge International Handbook of Social Neuroendocrinology. Abingdon, UK: Routledge.
Vitousek, M.N., Johnson, M.A., Downs, C.J., Miller, E.T., Martin, L.B., Francis, C.D., Donald, J.W., Fuxjager, M.J., Goymann, W., Hau, M., Husak, J.F., Kircher, B.K., Knapp, R., Schoenle, L.A., and Williams, T.D. in press. Macroevolutionary patterning in glucocorticoids suggests different selective pressures shape baseline and stress-induced levels. The American Naturalist.
Miles, M.C.§ and Fuxjager, M.J. 2019. Social context modulates how the winner effect restructures territorial behavior in free-living woodpeckers. Animal Behaviour. 150: 209-218.
Schlinger, B.A., Chiver, I., and Fuxjager, M.J. 2019. Hormonal and neuromuscular control of courtship displays. In J.C. Choe (Ed.) Encyclopedia of Animal Behavior (2nd ed). Cambridge, USA: Academic Press.
Fuxjager MJ, Xiao X, Riger N, and CA Marler. 2017. Why animals fight: uncovering the function and mechanisms of territorial aggression. American Psychological Association Handbook of Comparative Psychology. American Psychological Association: Washington DC., pg. 853-875.
Mangiamele, L.A.*, Fuxjager, M.J.*, Schuppe, E.R.§, Taylor, R.S., Hödl, W., and Preininger, D. 2016. Increased androgenic sensitivity in the hind limb muscular system marks the evolution of a derived gestural display. Proceedings of the National Academy of Sciences, USA. 113: 5664-5669. doi: 10.1073/pnas.1603329113 (Cover Article) *Authors contributed equally to this work.
Fuxjager MJ*, Lee J*, Chan T, Bahn J, Chew J‡, Xiao X, and BA Schlinger. 2016. Hormones, genes and athleticism: effect of androgens on the avian muscular transcriptome. Molecular Endocrinology. 30: 254-271. doi: doi.org/10.1210/me.2015-1270 *Authors contributed equally to this work.
Fuxjager, MJ, Alger SJ, and CA Marler. 2014. Hormones and Social Behavior. In: Animal Behavior, Vol. I: History, Causation, and Development (Eds. K. Yasukawa and Z. Tang-Martinez). Praeger.
Fuxjager, M.J., Longpre, K.M., Chew, J.G‡, Fusani, L. and Schlinger, B.A. 2013. Peripheral androgen receptors sustain the acrobatics and fine motor skill of elaborate male courtship. Endocrinology, 154: 3168-3177.
Schlinger, B.A., Barske, J., Day, L., Fusani, L. and Fuxjager, M.J. 2013. Hormones and the neuromuscular control of courtship in the golden-collared manakin (Manacus vitellinus). Frontiers in Neuroendocrinology, 34: 143-156.
Fuxjager, M.J., Barske, J., Du, S., Day, L. and Schlinger, B.A.. 2012. Androgens regulate gene expression in avian skeletal muscles. PLoS One, 7: e51482.
M.J. Fuxjager, J.D. Schultz, J Barske, N.Y. Feng, L. Fusani, A. Mirzatoni, L.B. Day, M. Hau and B.A. Schlinger. 2012. Spinal motor and sensory neurons are androgen targets in an acrobatic bird. Endocrinology, 153: 3780-3791.
Lopez, J.K. and Fuxjager, M.J. 2012. Self-deception's adaptive value: effects of positive thinking and the winner effect. Consciousness and Cognition, 21: 315-324.
Fuxjager, M.J., Montgomery, J.L.‡, and Marler, C.A. 2011. Species differences in the winner effect disappear in response to post-victory testosterone manipulations. Proceedings of the Royal Society of London, Series B, 278: 3497-3503.
Fuxjager, M.J., Oyegbile, T.O. and C.A. Marler. 2011. Independent and additive contributions of post-victory testosterone and social experience to the development of the winner effect. Endocrinology, 152: 3422-3429.
Fuxjager, M.J., Foufopoulos, J., Díaz-Uriarte, R. and Marler, C.A. 2011. Functionally opposing effects of testosterone on two different types of parasite: implications of for the immunocompetence handicap hypothesis. Functional Ecology, 25: 132-138.
Fuxjager, M.J., Montgomery, J.L.‡, Becker, E.A. and Marler, C.A. 2010. Deciding to win: interactive effects of residency, resources, and 'boldness' on contest outcome in white-footed mice. Animal Behaviour, 80: 921-927.
Fuxjager, M.J., Forbes-Lorman, R.L., Coss, D.J., Auger, C.J., Auger, A.P. and Marler, C.A. 2010. Winning territorial disputes selectively enhances androgen sensitivity in neural pathways related to motivation and social aggression. Proceedings of the National Academy of Sciences, USA, 107: 12393-12398.
Fuxjager, M.J. and Marler, C.A. 2010. How and why the winner effect forms: influences of contest environment and species differences. Behavioral Ecology, 21: 37-45.


text:
Round 1 teams: Intrust Super Cup
Kalifa Faifai Loa has been given one final chance to press for selection in the Gold Coast Titans team for Round 1 after being named in the centres for Tweed Heads Seagulls in the opening round of the Intrust Super Cup this weekend.
The opening round of 2014 marks an exciting new chapter in the Intrust Super Cup with the PNG Hunters to make their debut against the Redcliffe Dolphins in Redcliffe. The Hunters have been impressive in pre-season trial matches to date and the entire competition will be on tenterhooks seeing how they perform first up away from home.
For fringe NRL players such as Faifai Loa, this weekend's matches also act as a final opportunity to impress in the lead-up to Round 1 of the NRL Telstra Premiership.
Since arriving on the Gold Coast Faifai Loa has impressed players and coaching staff alike with his work ethic and remains in contention for a centre spot as coach John Cartwright juggles five players vying for two positions.
Siuatonga Likiliki is another endeavouring to force his way into Cartwright's 17 for Round 1, named in the centres for Burleigh Bears in their clash with Central Queensland Capras at Pizzey Park on Sunday.
Another player looking to impress is former Parramatta Eel Matt Keating, brother of the Bulldogs' Kris Keating, who will line up in his preferred role at hooker for the Burleigh Bears.
Keating will be hoping to find himself on Titans' coach John Cartwright's radar after being told he was not wanted at the Eels for season 2014 by then coach Ricky Stuart and could be the beneficiary of an injury crisis in the Titans' hooking ranks.
Then there are the fringe Broncos, with Liam Georgetown, Aaron Whitchurch, David Hala (Redcliffe Dolphins) and Francis Molo (Norths Devils) all looking to begin their seasons strongly to increase their chances of seeing NRL football during the State of Origin period where the Broncos are notoriously short on troops.
The PNG Hunters have named four players who featured for the Kumuls in the 2013 World Cup, five-eighth Israel Eliab will captain the side which also features Roger Laka (halfback), Joe Bruno (prop) and lock Sebastien Pandia.
Let's not forget the coaches, with the main talking point in the coaching arena the return of former Broncos coach Ivan Henjak, who will be looking to improve the fortunes of the Sunshine Coast Falcons, who finished in bottom place last season with only two victories.
There are also a handful of ex-NRL players at the helm of ISC teams, with former Broncos Ben and Shane Walker (Ipswich Jets), Bulldogs hooker Jason Hetherington (Central Queensland Capras) and former Cowboys centre Josh Hannay making his coaching debut at the helm of the Souths Logan Magpies.
For the complete list of Intrust Super Cup Round 1 teams click here.
Easts Tigers' shot at grand final revenge.

redpajama_set_name: RedPajamaCommonCrawl


He's a decorated Olympian whose natural habitat is slap-bang in the middle of a competition. Greg Rutherford is more than ready for Strictly!
"I'm looking forward to the spray-tan if I'm honest. I've been pasty all my life"
Born in Milton Keynes in 1986, Greg was one of three kids. Sport was always very much in his blood – his great-grandfather played for England, and Greg himself had trials for Aston Villa. But the lure of the long jump had a greater pull than that of football, and he became the youngest ever winner of the AAA Championships at just 18.
It was London 2012 that saw him truly leap into the limelight, with his gold medal-winning jump making up a crucial part of the now-infamous Super Saturday. Four years on, he did Team GB proud yet again, taking the bronze in Rio.
Thankfully, he goes get some downtime, but Strictly is eating into that: "At this time of year I normally completely switch off for six weeks," Greg explains. "I stay at home a lot sitting around in my pants eating cakes because I don't really get to do that the rest of the year and this is going to be one of the first years in a long time that I'm training through."
Clearly, Greg loves a challenge, further proven by the fact he's competed in the Great Sport Relief Bake Off and the Channel 4 immersive history series Time Crashers, as well as celebrity editions of The Cube and Million Pound Drop.
With Olympic gold and bronze, European Championships gold and silver, World Championships gold, Commonwealth gold, an MBE and even a 26ft tall statue erected in his honour, Greg's already got quite the collection of metallic awards. How d'you reckon the Glitterball Trophy would look alongside that little lot?


Meet in the restaurant at 10:00am.
Breakfast at 10.30am, Santa reads a story, Santa hands out presents.
Each child has breakfast, and then story time with Santa, and finishes with special gift being given to each child!


My daughter is a very sweet and happy go lucky person. She has done MBA & working as a Consultant. She is also a Bhartnatyam Dancer and somewhere down the line wants to pursue her career in it and we are looking for a guy who can always keep her smile on.
Belongs to nuclear family, a doctor by profession, looking suitable groom who can support my career after marriage.
My daughters name is Shweta Pawar and she have completed her MBBS. She belongs to aMiddle Class, Nuclear Family with Traditional Values.
I am looking for my life partner who would be a great companion and friend.m from teachers family.i hv complited BAMS in Pune,working as an assi.Dr.My partner should be Dr or well educated .I prefer middle class family.
My name is Sukanya Parte and I am working as a Interior Designer in the Private sector. I have completed my Diploma. I grew up in a Middle class, Joint family with Moderate values.
My name is NILAM VINYAK MANE and I have completed my B.Com.. I belong to a Middle Class, Joint Family with Traditional Values.
I am putting up this profile on behalf of my daughter. She did her M.Sc. (Computer Science) from Pune University and is currently working in Cognizant, Pune. She is born and raised in Pune. Although Konkani is her mother tongue she can speak fluent Marathi. Her friends describe her as simple, caring and adjusting in nature. Her mother is a homemaker, father is retired government employee. She has one elder sister who is married. We are looking for a simple, smart, well educated and understanding groom for her.
My name is Nikita Chavan. I have completed my PGDM. I grew up in a Upper Middle Class, Nuclear family with Moderate.
I am good-looking, down to earth, confident person belonging to a well-respected family. I believe in living in the present but with an eye on the future and believe in enjoying every moment of my life. Live in Mumbai. Native place Kolhapur.
My name is Baban Mane and I am working in Reliance Jio Pune as a Manager in the Private sector. I have completed my Bachelor Degree in Computer Engineering. I grew up in a Middle Class Nuclear family with Traditional values.
Hi! I'm Ashutosh from Satara. I've done my Masters in Transportation Engineering from BITS Pilani, Pilani campus. Worked for 3 years as Assistant professor, left it recently to pursue civil services. I'm an ambivert who loves dogs, to go on long drives, outdoor sports & adventurous activities. I also like to enjoy good movies and TV shows. If you too, happen to have similar interests, text me & well talk. Have a nice day..& happy searching!!
My son has a bachelor's degree and he is employed in private sector as a software professional currently based in Mumbai. We belong to an upper middle class, nuclear family with moderate values.
My name is Chetan vishwas patil and I am working as a Professor / SET exam pass..class 1 post..shivaji university under .. in the Government sector. I have completed my M.Ed.. I grew up in a Upper Middle Class class, Joint family with Traditional values.
Green Card Holder working in a reputed company in San Jose.
My name is Vedant Ankushrao Dalvi and I run my own Business. I have completed my B.Com.. I grew up in a Rich / Affluent, Nuclear Family with Traditional Values.
Good looking, fair, down to earth, confident person belonging to a well-respected family. I believe in living in the present but with an eye on the future and believe in enjoying every moment of my life. I love to travel a lot & i wish my partner also love to travel.


text:
The Goat (Dir. Buster Keaton/Mal St Clair, US, 1921) + Sailors Beware (Dir. Fred Guiol/Hal Yates, US, 1927) (Screening format – not Known, 27/20mins) In The Goat, Buster Keaton is already on the run from the cops when he's mistaken for murderer Dead Shot Dan (portrayed, incidentally, by Keaton's co-director Mal St. Clair). Keaton has eluded the previous group of policeman, but he's no match for the ill-tempered, heavyweight detective Joe Roberts who's hot on his trail…or is he? The battle of wits and punishing physical stunts is a pleasure to behold — Keaton wrings every bit of mirth from props such as an old-fashioned dump truck, an elevator, windows and, of course, the passing train. A delightful, fast-moving film.Find out more at wikipedia.org. Sailors Beware Stan is an honest cab driver, unaware that his current fares are a couple of slick con artists: Anita Garvin and her midget husband who dresses as a baby. When they leave the cab with their fare unpaid and the meter running, Stan gives chase when they board an ocean liner and comedy follows. This is not yet a Laurel and Hardy film but a Stan Laurel film with Oliver Hardy in an important supporting role. Many cite this film as being the one that opened many eyes to the potential Laurel and Hardy had as a team. While they share but a few moments together, it is those moments that are charged with a bit of extra comic electricity and a hint of what was to follow. Find out more at imdb.com. With live musical accompaniment by The Harcourt Players. The Electric Cinema, Birmingham Link
Pandora's Box (Dir. G W Pabst, Ger, 1929) (Screening format – DCP, 135mins) Based on two plays by the German author Frank Wedekind, Erdgeist (Earth Spirit, 1895), which Pabst himself had directed for the stage, and Die Büchse der Pandora (Pandora's Box, 1904), the silent drama follows the tumultuous life of the showgirl Lulu whose unselfconscious sexuality brings about the ruin of all those that fall for her and eventually her own. In a daring move, Pabst chose a little known American actress over the more experienced Marlene Dietrich for the part of Lulu, a decision that made the young Louise Brooks an international star. Her innocent looks paired with her natural erotic allure and sense of movement – Brooks was also a dancer – perfectly matched Pabst's idea of his heroine as unwitting seductress. Subjected to cuts to eliminate some of its "scandalous" content and unfavourably reviewed by critics at the time, it is now considered one of the boldest and most modern films of the Weimar era highlighting Pabst's command of camera language and montage. Find out more at silentlondon.co.uk . With recorded soundtrack. Artrix Arts Centre, Bromsgrove Link
Pandora's Box (Dir. G W Pabst, Ger, 1929) (Screening format – DCP, 135mins) For film details see 17 July above. With recorded soundtrack. Artrix Arts Centre, Bromsgrove Link
The Lodger: A Story of the London Fog (Dir. Alfred Hitchcock, UK, 1927) (Screening format – not known, 91 mins ) In The Lodger, a serial killer known as "The Avenger" is on the loose in London, murdering blonde women. A mysterious man (Ivor Novello) arrives at the house of Mr. and Mrs. Bunting looking for a room to rent. The Bunting's daughter (June Tripp) is a blonde model and is seeing one of the detectives (Malcolm Keen) assigned to the case. The detective becomes jealous of the lodger and begins to suspect he may be the #avenger. Based on a best-selling novel by Marie Belloc Lowndes, first published in 1913, loosely based on the Jack the Ripper murders, The Lodger was Hitchcock's first thriller, and his first critical and commercial success. Made shortly after his return from Germany, the film betrays the influence of the German expressionist tradition established in such films as The Cabinet of Dr. Caligari (1919) and Nosferatu (1922). Find out more at silentfilm.org . With live musical accompaniment by acclaimed musicians Minima. Martley Fringe Festival, Worcester Link
Pandora's Box (Dir. G W Pabst, Ger, 1929) (Screening format – DCP, 135mins) For film details see 17 July above. With recorded soundtrack. Broadway Cinema, Nottingham Link
NB. Whilst every effort has been taken to ensure that the information contained in these listings is accurate, silentfilmcalendar.org can take no responsibility for any errors or inaccuracies. You are strongly advised to confirm with the venue that the event remains as detailed, particularly if traveling any distance to attend.


We are excited to announce that we will soon have an online shopping service allowing us to market goods with a fixed price. Just click on the "Online Shop" tab of this website to see what is available. We also use local Facebook buy swap & sell sites to promote items for sale and forthcoming auctions.
Valuations are often required for legal purposes, financial prudency, insurance or self affirmation. We can provide written valuations to satisfy all needs.
Steve Graham is accredited by the Auctioneers & Valuers Association of Australia as a Valuer and has been doing formal valuations for many years.
We frequently use & gladly recommend Gisborne Taxi Trucks for efficient & cost friendly transportation of goods bought & sold at auction.
Natural Grace is a most caring & understanding Funeral business that provides unique end of life care.


text:
Encore Careers
All Mindset
All Dating
How to Live Emotionally Well with Serious Illness After 60
By	Ellen Rand	• 5 months ago	• Mindset
As a hospice volunteer, one of the many things I've come to understand is that everyone faces serious illness and the prospect of death differently. There's simply no "right way" or "wrong way" to approach it.
But I've also come to understand that it is possible to be at peace with oneself through the end of life, having experienced moments of real joy along the way.
I've certainly seen ample examples of the alternative, though, and it is heartbreaking. There was "Bobby," who was suffering with ALS (Lou Gehrig's disease), who railed angrily about the fact that there was no hope for him, and for whom there was no pleasure to be found in day-to-day life.
He lived his last months in his brother's home, where he didn't have the company of his three beloved dogs, and he died without having a chance to say goodbye to them.
And there was "Jane," a widow declining quickly from cancer that had spread to her bones, who was in a literal race against time trying to make living arrangements for her two adopted teenage daughters.
Often refusing pain medication because she hated the way it made her feel, refusing family and friends' offers to help until she was desperate, "Jane" badly wanted to tie up all the loose ends in her life but fell into a coma before she could.
Anger, sadness, resentment, shock, denial, resignation, isolation – or some combination of all of these intense reactions – are not unusual when people learn of a life-limiting illness.
And, just as we cannot simply advise anyone suffering depression to "snap out of it," we cannot simply persuade those, like "Bobby" and "Jane," that there still remain moments worth savoring and life is yet full of meaning.
Changing the Personal Narrative
In spite of much evidence to the contrary, though, I believe that repair, resolution, reconciliation, and even redemption are possible through the end of life. And working to achieve them is an important way to enable us to live emotionally and spiritually well in the face of serious illness.
For those whose lives have been particularly difficult, it can help to work on changing perspectives on old, painful narratives that continue to hurt and haunt the present. Toward that end, consulting with a geriatric psychiatrist or psychologist could be especially fruitful.
The best example of how a person can live so emotionally well is writer Ronni Bennett, who blogs at Time Goes By. Now in her late 70s, Bennett learned a year ago that her pancreatic cancer had metastasized and that there were treatment options but no cure for her condition.
So, Bennett decided to write about it and to keep on writing as long as she can, because for her that was a way of better understanding herself.
Her hope was to approach the last chapter of her life "alert, aware, and lucid," she said. Besides being great company on the page, she is honest above all, sharing the good, the bad, the ugly, and the amusing elements of her life.
Finding Ways to Express Yourself
Writing is certainly one way to understand and express who we are. But we can also choose other invaluable creative outlets: doing audio or video messages for family or friends; reviewing photo albums and talking about those special moments and memories; listening to the music that pleases us.
Or we can quietly reflect about our life, about what has given it meaning and purpose.
The hospice and palliative care pathfinder Ira Byock, founder and chief medical officer for the Institute for Human Caring of Providence St. Joseph Health, often says, "Death has a lot to teach us, if we let it."
Specifically, he advises focusing on what matters most and communicating it to your loved ones. That can be summarized in four key phrases: I love you. I forgive you. Please forgive me. Thank you.
In other words, to quote the singer John Mayer, we should say what we need to say to the people we need to say it to – while we can.
Whatever form of creative expression or communication we choose, let's keep in mind Ronni Bennett's basic insight:
"However short or long my remaining days may be, it is a great gift I have received, knowing my death is near. It led to what I think is the most important question in the circumstance: what do you want to do with the time that remains?"
That's a great question for all of us. If our aim is to reach the end of our lives feeling at peace, then asking that question is the first step we need to take.
What do you want to do with the rest of your life? Are you, or a loved one, living with serious illness? How do you express yourself knowing that life's end is drawing near? Please share your thoughts in the comments below.
Let's Have a Conversation!
Dealing with Grief and Fears Finding Happiness
Ellen Rand
A journalist for more than 40 years, Ellen Rand is a hospice volunteer and author of "Last Comforts: Notes from the Forefront of Late Life Care." Inveterate optimist, aging baby boomer and besotted grandmother, she is passionate about sharing news and guidance about finding excellent care for ourselves and our loved ones. You can visit her blog https://lastcomforts.com and follow Ellen on Twitter @EllenRandNJ
9 Unique Ways to Remember Your Loved Ones
Introducing Death Café: How Talking Can Help You Overcome Your Fear of Dyin...
Introducing Death Café: How Talking Can Help You Overcome Your Fear of Dying
Subscribe to Our Newsletter Watch Sixty and Me TV
Losing Weight After 60 is Possible! Just Get Rid of These 8 Things
8 Makeup Treasures Mature Women Will Love in 2020
5 Thoughtful 60th Birthday Gift Ideas for Women
How to Tie a Scarf Like a Pro: Older Women Rock the Style
18 Ridiculously Simple Ways to Eat Healthy and Avoid Dieting After 60
Dealing with Depression Doesn't Mean You're Crazy
5 Ways to Prepare for the Terrifying and Exciting Transition to Retirement
5 Simple Tips for Finding Financial Freedom after 60 from a Former Stockbroker
Losing a Pet After 60 is Especially Hard. Here's How to Recover
9 Pro Makeup Artist Tips for Women 50+ That Can Really Make a Difference (Video)
Nothing on this website should be considered medical advice. Always consult a doctor before making any changes to your diet, medical plan, or exercise routine. Likewise, we do not offer legal or financial advice. Click to see our full disclaimer.
Retire Different
She Cruises
If you purchased one of our products and need help or would like to reach our news contributors you can contact us here.
If you are interested in advertising with Sixty and Me, please contact us here.
Write for Sixty and Me
If you are looking to submit your guest post ideas - we look forward to hearing from you! Click here for more information.
(C) 2013 – present, Sixty and Me GmbH. All rights reserved.


text:
A FLORENTINE FROST FAIR AND FIREWORK FESTIVAL
[FRANCESCHINI, Pietro (editor).]
Florence, Libreria Popolare, Tipografia Righi, 1885.
8vo, pp. 15, [1]; paper uniformly toned, as in all copies, but a fine copy; in the original printed green wrappers.
Originally published by Bartolomeo Sermartelli in 1604, and reprinted shortly after in the same year by Alessandro Guiducci, the anonymous account describes the magnificent festival on the ice organised by Don Virgilio Orsini, held on 31 December 1604, during an extremely cold winter which had resulted in long stretches of the river Arno being frozen over.
On the day, thousands of spectators crowded on the bridges of Carraia and of Santa Trinita, and on the banks between the two. At an appointed hour, from behind heavy curtains strung up beneath the bridge of Santa Trinita, a long procession emerged. The parade opened with drummers and trumpeters, followed by a series of barefoot characters wearing the strangest masks (carefully described in the account). These were followed by a group of youngsters sitting on small wooden footstools, who were to later race each other with hilarious consequences. Last to appear were a group of noblemen, each on decorated sledges shaped as chariots pulled by four men, who would take part in a mock joust following the parade, and each holding a sign with either a motto, a madrigal, or a sonnet. The description of the extravagant costumes of the noblemen is detailed and fascinating, ranging from fantasy costumes, such as magicians, to costume inspired by foreign courts, including Fillipo Valori dressed like a Turkish woman, and Don Virginio Orsini, the organiser of the festival, dressed as a Pasha. Last among the jousters was Manfredi Malaspina, dressed as Pluto, holding fireworks and on a sledge in the shape of a dragon, also spewing fire. The procession was closed by the Della Fonte brothers, on a float shaped as a boat, with fireworks shooting from every corner.
After the parade had reached the bridge of Carraia, the competitions started: first the palio of the barefoot characters, where the contestants kept slipping and falling, to general hilarity; next came the race of the youngsters on footstools, barely able to control their direction; and finally the Saracen joust, where the contestants on chariots would face the traditional armour-plated dummy representing a Saracen. After dusk, the whole show ended with a spectacular firework display in honour of the Medici.
Both the original 1604 edition and the 1885 reprint are exceedingly rare outside of Italy: OCLC finds copies of the 1604 edition at Tufts University, British Library, and BnF, while the 1885 reprint can be found at Illinois, BnF, and Cologne.
Early Modern Festival Books Database (University of Oxford) 1236.
FARMERS AND RULERS	CAIROL, M. de.
Réflexions historiques et politiques, sur les revolutions qu'a essuyé l'agriculture sous différens gouvernemens, principalement dans le Languedoc, sur son état actuel dans cette province, & sur les moyens de l'améliorer.
Very rare essay on the state of agriculture in France, and in particular in the Languedoc, examining the ways in which the policies of various governments (from the Romans and Visigoths onwards) have affected agricultural production, the current situation, and the ways in which matters could be improved. Throughout, the author's concerns, although concentrated on agricultural production, are broader: he constantly reminds the reader of the extent to which the rural people of the Languedoc, although blessed with a clement climate and fertile land, are nonetheless at the mercy of the whims of their rulers, whether through the imposition of taxation or arbitrary and ill-informed decisions made de haut en bas about the crops to be produced and the methods to be employed. A lengthy set of notes, taking up the second half of the book, quote Montesquieu and Hume, describe agricultural practice in England, and present a number of statistical tables. We have found no information about the author, but it would be reasonable to assume that he was not unsympathetic to the events of the end of the decade.


Members of the board meet the second Wednesday of the month at 5:00 PM in the Ford Building Mezzanine Conference Room, 505 N Broadway Dr, Fargo, ND 58102. Stop by and meet us!
Arlette Preston, Secretary Arlette and her husband, Richard, have been living in downtown Fargo for the past 11 years. She works in the same building that she lives and loves the convenience of leaving her car in the garage and never having to worry about the weather when going to work!! Living downtown allows her to walk everywhere which has a side benefit of getting to know the neighbors as she meets them on the sidewalks. Arlette, an R.N., owns Home Instead Senior Care and is very active in the community. Besides being involved on the Downtown Neighborhood Association's Board of Directors, she chairs the City of Fargo Art & Culture Commission. She also serves on the Board for African Soul, American Heart.
Carol Schlossman, Vice Chair Carol Schlossman has lived and worked in the downtown neighborhood for the past 6 years. For the past 14 years she has owned and operated Insight To Action, LLC, a management consulting firm specializing in small business, retail development, and non-profits. She is a graduate of both NDSU and UND (MBA). Prior to consulting she worked in the technology; shopping center retail development; and government relations industries. She has served as Board Chair of the Arts Partnership, the FMA Area Foundation, and the Women's Fund Committee of the FM Area Foundation. She loves living in Fargo's downtown, along with her husband, Brad. She loves being a mom and "nana:; and is an avid sailor and painter. She is committed to the Downtown Neighborhood Association and the City of Fargo's Downtown Plan, and their work in making the downtown a diverse, greener, and a family-friendly environment in which to thrive.
Cody J. Schuler Cody J. Schuler has lived and worked downtown for 7 years. He thinks downtown is the best neighborhood in the city and its walkability and convince rivals or surpasses larger urban areas where he's lived. He proudly makes his home in the southern end of downtown and is enthusiastic about the SoMA (south of Main Ave) community. He is the executive director of the FM Coalition to End Homelessness, a local solutions based advocacy and education organization. Cody is a graduate of Dakota Wesleyan University and Duke University, is a trained community organizer, and is passionate about issues of social justice and systems change. He also serves on the North Dakota Coalition for Homeless People's Board of Directors and has acted as that organization's legislative coordinator. A self-identified NPR nerd, coffee addict, and craft beer snob, Cody enjoys cooking, kayaking, snowshoeing, and Blue Devil basketball.
Kay Schwarzwalter Kay Schwarzwalter, who spent her youth on a farm on the North Dakota-South Dakota border south of Reeder, North Dakota, has lived in Fargo for the past 30 years, the last 12 in downtown Fargo. Kay recently retired from her position at the Center for Social Research at NDSU. She formerly served on the Fargo Theater Board of Directors and is currently the volunteer coordinator for the Cooper Community Garden on the edge of downtown Fargo. Kay is passionate about women's and children's issues and is committed to making Downtown Fargo a family-friendly environment where she can bring her grandchildren to partake of the shops and delicacies on Broadway and the surrounding area. She is in the final stages of restoring her historic home, in the Milton Earl Beebe National Register Historic District in downtown Fargo, to its 1906 splendor. She enjoys travel and appreciates the diversity that different cultures bring to the Fargo community.
Kirsten Peterson Since moving back to Fargo in 2016, Kirsten has been connecting with her community by joining the 2017-2018 Chamber FMWF Leadership Program. Her Community Change Initiative project is now a reoccurring event which pairs professionals who wish to volunteer their skills for nonprofits. This event is called "Professionally Paired". Kirsten has served on the board for the Powderhorn Park Neighborhood Association (PPNA) and the Artist Panel for the Minneapolis Institute of Arts, Minnesota Artist Exhibition Program. She currently serves on the board for the North Dakota chapter of the Association For Talent Development. In 2017, Kirsten and her husband, Chris, purchased a home in downtown Fargo. Kirsten is excited to serve on the DNA Board and advocate for the residents of downtown Fargo.
Murphy Anderson Murphy is the DNA's social media/website coordinator and newsletter writer. A Fargo native and a proud Penn State Nittany Lion, she is a lifelong learner and passionate about this community. Murphy works at a family foundation and is pursuing a graduate degree in Public Health at NDSU. She is also a Rourke Art Gallery board member. In her few moments of spare time, she enjoys writing, creating and traveling with family and friends. Murphy is looking forward to the 2019 Downtown Home Tour and expanding DNA membership!
Paul Gleye, Chair Paul Gleye is a city planner and faculty member in the NDSU school of architecture. A California native, he has lived in downtown Fargo for nearly 20 years after having lived in Chicago, Santa Fe, Pasadena and Bozeman, as well as France, Belgium, and Germany. Currently he leads the NDSU architecture program's term abroad program, spending three months a year guiding students through Europe, but believes the quality of urban living in downtown Fargo to be second to none. He brings to the Downtown Neighborhood Association a lifelong passion for historic city centers, believing that the city center embodies the vision of the entire city that is projected to the world. His 1906 historic house in downtown is on the National Register of Historic Places as part of the Milton Earl Beebe Historic District. In 2018 he serves as president of the Fargo Downtown Neighborhood Association.


text:
Q: Possible to programatically specify Windows Explorer display columns and column order? I have a program that creates a large and complex file structure from information in a database.  The folders have cryptic names so to assist the user I add a Title attribute for each folder (using desktop.ini).  When the Title column is the first column of the listing in Windows Explorer the display is perfect.
The problem is that each user must understand how turn on the display of the Title column and reorder the columns so that Title is the first column, otherwise they see only the cryptic name of the folder.
Is there anyway I can have my program write information into the root folder (or anywhere else) that will configure each copy of Windows Explorer, by default, to present the custom view of the folder that I want?

redpajama_set_name: RedPajamaStackExchange


I also wanted a dedicated server (a WordPress requirement anyhow) where I could have full freedom to utilize my domain names. Frankly, for years I've hestitated to have a domain using my name. It comes across to me as egocentric and haughty, yet after speaking with friends, web-techies and other pastors, it seems having your name as your URL is the most intuitive step to take for people who want to discover your blog. That wasn't a problem for me since I did not promote my blog to anyone. It was primarily for me to record my thoughts. However, over time I've had more than enough people chastise me for keeping it on the down-low. In recent days I've acknowleged that response by putting name in my blog. Now I will put my name on my blog.
YAY! Congrats on the new domain.
I look forward to your blogs–your messages always inspire and intrigue (and confuse) me.
Definitely a good thing–makes me do my research and really think about things and helps me see things in a different light.
Thanks Kara. I have a feeling it will be a long learning curve, but only time will tell.


Bitcoin is now considered the "most crowded trade," as measured by sentiment in the monthly Bank of America Merrill Lynch Fund Managers survey.
The two other so-called crowded trades have done very well this year, with the Nasdaq surging just shy of 20 percent and the dollar tumbling nearly 10 percent.
In a year that has seen digital currency prices go higher not by percentages but multiples, investors are starting to worry that things have gone a bit too far.
Bitcoin is now considered the "most crowded trade," as measured by sentiment in the monthly global Bank of America Merrill Lynch Fund Managers survey. That means investors believe there are too many people on one side of the trade and it could be due for a reversal.
Bitcoin's price has surged about 330 percent this year, the beneficiary of a jump in interest for the cryptocurrency and a growing field of competitors, as well as a flight to alternative assets and, some fear, a speculative bubble.
The Merrill survey is one of the most followed and respected on Wall Street. Conducted during the week that ended Thursday, more than 200 global fund managers with at least $600 billion under management were surveyed.
Of course, a crowded trade doesn't have to mean it's nearing an end.
In the BofA survey, bitcoin supplanted the Nasdaq and the short dollar trade as the most crowded. Bitcoin got 26 percent of the vote, edging out the Nasdaq, with 22 percent and the bet against the greenback, which took 21 percent of the vote.
The two other "crowded trades" have done very well this year, with the Nasdaq surging just shy of 20 percent and the dollar tumbling nearly 10 percent against a basket of its global competitors.
In addition to worries over the bitcoin trade, fund managers are backing away from U.S. stocks. The collective allocation to domestic equities fell to a net 28 percent underweight, which is the highest level since November 2007, shortly after the market hit its precrisis highs.
Investors also are beginning to fret about global growth, even as economists are upgrading their expectations. Just 25 percent expect a stronger global picture over the next 12 months, down from 62 percent at the beginning of 2017.


text:
HARS Orion airborne
RAAF Orion pilot Capt Matt Jurkens hauls the HARS Lockheed AP-3C, A9-753/VH-ORI, off the Illawarra runway for its first flight as a civilian aeroplane on 6 March.
Almost 40 years after it was built, the Historical Aircraft Restoration Society (HARS) Lockheed AP-3C Orion, A9-753/VH-ORI, made its first flight in preservation at Illawarra Regional Airport, New South Wales on 6 March. The maritime patroller had formally been handed over to HARS on 3 November 2017, after which a small team set to work preparing the Orion for a new life as a civilian display aircraft.
At the controls was Capt Matt Jurkens, a current Royal Australian Air Force P-3 qualified flying instructor. He flew the Orion out over the Tasman Sea at 7,000ft for one hour 45 minutes of aircraft integrity checks. A dozen touch-and-goes were then completed back at Illawarra to give three HARS co-pilots some circuit time. The following day three further flights, totalling one hour 40 minutes, were completed, after which the only 'write-ups' were two blown bulbs.
Also back in the air is HARS' Lockheed SP-2H (P2V-7) Neptune, A89-273/VH-IOY, which made its first flight for more than a year from Illawarra on 13 March following an overhaul. Representing the previous generation of maritime patrol aircraft to the Orion, this example of the Neptune was delivered to No 10 Squadron, RAAF in March 1962, and was retired from use by the air arm at Townsville in May 1977. It was acquired by HARS in the spring of 1988, and underwent a major rebuild between November 1996 and January 1998.
Originally published in Aeroplane Magazine
Find out more about Aeroplane magazine
Subscribe to Key.aero online
Subscribe to Key.aero now to access the wealth of information on offer completely ad free.
Quiz Content
Aero Events
Jet, Set, GROW
Former RAAF Orion to Fly Again
Retired Lockheed Orion to fly again in Australia
RAAF Orion presented to HARS


text:
How marketers are planning to use the new customisable AR filters on Instagram
Farzanah Farveen
To read the full article, simply create a login account via the link below. Thank you for supporting our newsroom!
Instagram Stories has expanded the use of its customisable augmented reality (AR) effects, which was earlier in the year made available on the platform exclusively to its community of Spark AR creators, to the rest of its audience. The new offering will come as an addition to what is already available under its "effects gallery" on the platform.According to Facebook, prior to opening up the platform to users across the globe, more than one billion users had already signed up to use the customisable AR effects and filters powered by Spark AR on its platform as well as sister brands Instagram, Messenger and Portal.In a statement to Marketing, a spokesperson said this is "strictly an organic experience" and are no customisable AR ads on Instagram Stories at this time. With the opening of the platform, the social media giant aims for users to create more ways to interact with people and brands on Instagram.Speaking on the new offering, Juliana Chua, general manager marketing, Pavilion KL said the new customisable AR effects will certainly ensure more entertaining engagement between brands and audiences given"likes" no longer hold much brand value."This will be good for us. With this feature, consumers can create AR effects that are customised to a marketer's brand – resulting in consumers creating more content for me," she said. She added that with the new feature, more user generated content will also be created with added variation.Instead of marketing teams taking a long time to create content, consumers can create it for us. More importantly, the content is created based on what our target audiences like because they know best.According to Chua, in this day and age, brands need to learn how to let consumers curate content. "Right now, consumers' interests and desires are so diverse, it's no longer viable to just use one type of content for all consumers across platforms," she said.Apart from shopping malls such as Pavilion, she was of the view that companies such as luxury brands and mass consumer brands with strict brand guidelines will be able to benefit from this AR effects. Since luxury brands sometimes have limitations and are not always able to create customised content at speed, this form of user generated content could also be utilised by them."As for mass consumer brands, they target a huge population and hence, it is very hard to customise content. So, it would be easier to let their own fans customise the content and reach out to the wider audience," she added.Getting in with the youths Joyce Tan, senior director of marketing and innovation at Pizza Hut Singapore also had a positive view of the offering given its ability to resonate with the younger consumers – a segment she is keen on gaining prominence with."AR effects allows creatives to find new ways of tying the brand and consumers," she said.Agreeing with Tan, Merisant's regional marketing director, Asia Pacific, Shreyas Subbaraya who previously worked with P&G said Instagram AR filters from select creators have been gaining popularity since late last year, and is "exciting" to let anyone create more such effects. He also added that this will enable brands in driving consideration among Millennial and Gen Z audiences and be a part of popular conversation.Eugene Lee, marketing director of McDonald's Malaysia said that his team has already been utilising the offering on the Facebook Stories platform – starting with the Portuguese Chicken Burger promotion."We were the first company in Malaysia (according to Facebook) to adopt the technology, and hack it to create an AR game for the public," he said. He added that the campaign drove one of the highest engaged consumer activation to date on digital, with over 70,000 users registering and 10,000+ active daily players.These were numbers we had never seen before, proving that being able to adopt new tech and at the same time be relevant to consumers drives real consumer engagement.[Digital Marketing Asia Conference 2019 in Singapore is back! Join us on 8-9 October as we hear from experienced practitioners and thought-leaders on how they are managing complex digital transitions and reimagining new ways for their marketing to become more customer focused, agile and interactive.Check out the agenda and book your seats today.]Agency takeAccording to Pavilion's Chua, the possible downside to allowing consumers to build their own effects for brands to use could result on a hit on the agencies. She added that digital media agencies will now need to figure out how their role evolves. "These agencies will have to find out if they are going to be the leader in telling consumers how to create AR effects, or create the filters for the brands themselves so consumers can use them," Chua said.Nonetheless, James Chua, founder and managing director of GERMS told Marketing, that such a feature is a clear opportunity for "engagement hungry" marketers to harness and possibly monetise. But marketers would need to ensure that the adoption is done in a proper manner to drive high engagement levels and grow brand and product awareness.On the view of the offering alone, he said Snapchat clearly in competition with Instagram over similar features and target segment, Chua said that the latter is playing catch-up to retain and/or regain users.(Read more: Why brands should pay attention to Snapchat's gender swap filter)"With the feature doing a lot of good for Snapchat's resurgence in app downloads, Instagram definitely wants to ensure it doesn't lose engagement with the base that is straddling between the two platforms. So it is clearly another catch-up move to retain or regain users. As for those that are only on Instagram, it clearly will help to drive further engagements," he added.Meanwhile, Prantik Mazumdar, managing partner at Happy Marketer, a Merkle Company said the creative power and empowerment in Instagram users is likely to create more ad inventory for the platform. Users are able to custom create their own effects for posts and stories, which will then be shared by many, eventually leading to more advertising revenue for Instagram.According to Mazumdar however, Instagram has often followed and copied Snapchat's innovative products but has been "better and quicker" in monetising it by leveraging the access it has to Facebook's resources.
More articles from Analysis
What the removal of IG shop tab says about its commerce priorities
What are some ways to build loyalty for your brand through CX?
Rezwana Manjur
How ChatGPT exploded onto the scene with so little marketing spend