text:
CALCO 2021 and MFPS 2021 - hosted by the University of Salzburg, Austria
CALCO & MFPS 2021 Salzburg 30 Aug – 3 Sep
The 9th Conference on Algebra and Coalgebra in Computer Science (CALCO 2021) and the 37th Conference on the Mathematical Foundations of Programming Semantics (MFPS 2021) take place together as online/hybrid event from Salzburg, Austria on August 30 – September 3, 2021. MFPS runs August 30 – September 2, 2021, while CALCO will run August 31 – September 3, 2021.
The conferences are hosted by the University of Salzburg and organised by Ana Sokolova and a team of "local" organisers; Ana Sokolova is also a PC Chair for MFPS; PC Chairs for CALCO are Fabio Gaducci (University of Pisa) and Alexandra Silva (Cornell University and UCL).
Check CALCO & MFPS 2021 for more information.


Discussion in 'Humor - Jokes - Games and Diversions' started by ghostrider, Sep 26, 2005.
A major research institution has recently announced the discovery of the heaviest element known to science.
The new element has been named "Governmentium." Governmentium has one neutron, 12 assistant neutrons, 75 deputy neutrons, and 224 assistant deputy neutrons, giving it an atomic mass of 312.
These 312 particles are held together by forces called morons, which are surrounded by vast quantities of particles called peons.
A minute amount of Governmentium causes one reaction to take over four days to complete, when it would normally take less than a second.
Governmentium has a normal half-life of four years; it does not decay, but instead undergoes a reorganization in which a portion of the assistant neutrons and deputy neutrons exchange places.
In fact, Governmentium's mass will actually increase over time, since each reorganization will cause more morons to become neutrons, forming isodopes.
This characteristic of moron promotion leads some scientists to believe that Governmentium is formed whenever morons reach a certain quantity in concentration.
This hypothetical quantity is referred to as "Critical Morass." When catalyzed with money, Governmentium becomes Administratium -an element which radiates just as much energy as the Governmentium since it has half as many peons but twice as many morons.
Hmm, I thought this would have to do with women's butts!
Smart man...better stay in that chimney a little while longer...or be very careful when stepping out..
Valkman, after being bombarded by the gamma ray gaze of Cathode Ray Connie, can now pop popcorn without a microwave, simply by holding it in his hand, and can save big bucks on flashlight batteries because he now glows in the dark.
Just think how handy he'll be to have around on Halloween!


205 Seclusion Valley Way features stunning western views from the large covered outdoor living area. 12' ceiling and open concept living, hardwood flooring, goumet kitchen with Thermdor appliances. Private master suite with 2 walkin closets, his & her vanity, lg. walkin shower. Den with french drs to patio Designer selections including hardwood flooring are set to be installed and this home will be ready for its new family in later March 2019. Hylands Lafayette offers 15 new semi-custom homes for sale in Lafayette, CA. This new home community is located among rolling hillsides and open space in Lafayette. This new luxurious East Bay community is conveniently located near parks and more than 16 miles of trails. Homes will offers inspiring views of Broines ridge, Mt. Diablo and the surrounding hills. Residences will offer up to five bedrooms, large elevated lots and open floor plans. Children will attend schools in the acclaimed Lafayette Schools and Acalanes High School.
Bay East ©2019. CCAR ©2019. bridgeMLS ©2019. Information Deemed Reliable But Not Guaranteed. This information is being provided by the Bay East MLS, or CCAR MLS, or bridgeMLS. The listings presented here may or may not be listed by the Broker/Agent operating this website. This information is intended for the personal use of consumers and may not be used for any purpose other than to identify prospective properties consumers may be interested in purchasing. Data last updated at 4/24/19 10:02 AM PDT.


text:
Q: How to enable Arabic support in reportlab.pdfgen using drawString()? I have qr code in PIL Image and some Arabic text and trying to put the qr Image on a pdf file.
I'm using reportlab.pdfgen's canvas.
After a lot of searching I found arabic_reshaper, someone's project that didn't work, and after reading the source code of textobject.py I found that I need to install pyfribidi, installed it, and used drawString(x,y,"مربحا",RTL) nothing happens.
I'm using arabic_reshaper as described in the repository, and the RTL from pyfribidi
import arabic_reshaper

reshaped = arabic_reshaper.reshape(exam_name)
c.drawString(x - 100, y - 20, reshaped, direction=RTL)

The result is always the same, as you can see on the right the English strings appear normally, the Arabic ones appear as black pixels :

If you have any other recommendations for another library that will be also appreciated.

A: Thanks to some developers who noted that the problem is caused by the font I was able to fix it.
First I downloaded an Arabic TTF font, and as I'm using linux I placed it in '/usr/share/fonts' then I did the following:
import reportlab
import arabic_reshaper
from bidi.algorithm import get_display
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
// BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

reportlab.rl_config.TTFSearchPath.append(str(settings.BASE_DIR))
pdfmetrics.registerFont(TTFont('Arabic', '/usr/share/fonts/tradbdo.TTF'))

ar = arabic_reshaper.reshape(u'العربية')
ar = get_display(ar)
canvas.setFont('Arabic', 32)
canvas.drawString(x - 100, y, ar)

and now everything is working just fine.
Read this answer carefully.

redpajama_set_name: RedPajamaStackExchange


text:
Lester Orville Krampitz (July 9, 1909, Maple Lake, Minnesota – May 18, 1993, Cleveland, Ohio) was an American microbiologist.

Biography
After graduating from high school in Buffalo Lake, Minnesota, Krampitz matriculated in 1927 at Macalester College, where he graduated in 1931 with a bachelor's degree with a joint major in biology and chemistry. From 1931 to 1938 he taught high school and occasionally worked at miscellaneous jobs. In 1938 he became a graduate student at Iowa State College (now named Iowa State University). There he did research on microbial metabolism and graduated in 1942 with a Ph.D. in microbiology. His Ph.D. thesis The fixation of carbon dioxide in oxalacetic acid and its relationship to bacterial inspiration was supervised by C. H. Werkman. For the academic year 1942–1943 as a postdoc in D. W. Woolley's laboratory at the Rockefeller Institute, Krampitz did research on vitamin antagonists that occur in nature. From 1943 to 1946 he was an assistant professor of bacteriology at Iowa State.

In 1946 Krampitz became a member of the biochemistry department of Case Western Reserve University School of Medicine. There he was from 1946 to 1948 an associate professor in the biochemistry department and from 1948 to 1978 a full professor and director of the microbiology department (which was formed in 1948). He did some research on penicillin's mode of action. As director of the microbiology department, he hired a number of noteworthy faculty members, including L. Leon Campbell, Howard Gest, and Charles Yanofsky. Krampitz, in a 1956 letter to Joshua Lederberg, proposed Yanofsky for the Eli Lilly and Company-Elanco Research Award, which Yanofsky received in 1959.

For the academic year 1955–1956, the Fulbright Program enabled Krampitz for seven months to conduct research on tartrates in Feodor Lynen's laboratory, where he met Otto Warburg.

Krampitz was one the of most important participants in the reorganization of Case Western Reserve's medical school curriculum. Traditionally, course material was taught by specific discipline (such as anatomy, immunology, toxicology, and so on) — in the new approach the courses were taught in terms of organ systems in integrated explanations. Clinical studies were introduced in the first year of medical school. Medical students were required to pursue research projects. This innovative approach significantly influenced medical schools in the United States.

Krampitz's research involved the use of isotopes in the study of the carbon metabolism of bacteria, until his research switched to biohydrogen in the context of the 1973 oil crisis. In 1978 he resigned his positions and retired. He kept a small laboratory and visited it every day until he fell ill in the early 1990s.

Krampitz was awarded in 1958 an honorary doctorate from Macalester College. He was elected in 1968 a foreign member of the Bayerische Akademie der Wissenschaften and in 1978 a member of the United States National Academy of Sciences.

He married Norma Peterson in 1931. They had a daughter Joyce.

Selected publications

References

1909 births
1993 deaths
American biochemists
American microbiologists
Macalester College alumni
Iowa State University alumni
Iowa State University faculty
Case Western Reserve University faculty
Members of the United States National Academy of Sciences
People from Renville County, Minnesota

redpajama_set_name: RedPajamaWikipedia


text:
Football By Jason Romano Jun 22, 2017
Raiders QB Derek Carr Becomes NFL's Highest Paid Player
Derek Carr playing for the Oakland Raiders. (Photo Courtesy: Erik Drost (Flickr) [CC BY 2.0 (http://creativecommons.org/licenses/by/2.0)], via Wikimedia Commons)
Oakland Raiders quarterback Derek Carr agreed to a new five year contract extension today worth $125 million, making him the NFL's highest paid player according to NFL.com.
The deal, reported by ESPN's Adam Schefter, means Carr, at 26 years old, is signed with Oakland through the 2022 season.
Carr tweeted his excitement about the new deal and stated that he can now move his focus to on the field and the upcoming 2017 season.
Now it's done ?! From the jump I've wanted to be a Raider 4 life. One step closer to that! Blessed!!! Business done! Let's just play now!!!
— Derek Carr (@derekcarrqb) June 22, 2017
Raiders offensive coordinator Todd Downing tweeted his happiness for his quarterback.
You won't find a harder working or more deserving man than @derekcarrqb. Congrats! I am happy for you & your fam & excited for what is next! https://t.co/511hyZVOo9
— Todd Downing (@CoachTD) June 22, 2017
Carr, a follower of Jesus, has always been vocal about his faith in Christ, as witnessed in this instagram post back in February.
What an amazing day it was last Sunday! Literally saw person after person set free, give their lives to Christ, and be physically healed right in front of our eyes! No "smart person" will ever be able to argue what happened that day and what Jesus did in the lives of many. People walked in one way and left another. And you don't have to just take my word for it. The people that were there can tell you. He is real. He loves you. He still heals today. We saw it happen. #JesusWins #Again #ByHisStripes #WeAreHealed
A post shared by Derek Carr (@derekcarrqb) on Feb 16, 2017 at 5:18pm PST
Oakland opens up the 2017 season on September 10 at the Tennessee Titans.
NFL's 2020 Super Bowl Breakfast to feature faith and football, honor Giants QB Eli Manning
49ers RB Tevin Coleman says he's 'blessed by God to be here' after premature birth
THE INCREASE: You May Be The Only 'Bible' People Experience – Kelvin Beachum

redpajama_set_name: RedPajamaCommonCrawl


text:
Motivational Zachary Levi Quotes And Sayings
Home » Author Quotes » Motivational Zachary Levi Quotes And Sayings
Inspirational Zachary Levi Quotes
Zachary Levi Quotes:- Zachary Levi (born September 29, 1980) is an American actor and singer. He received critical acclaim for starring as Chuck Bartowski in the series Chuck, and as the title character in Shazam!, as a part of the DC Extended Universe.
I believe that as an entertainer, you're only as good as your audience and the people who support you.
There has been a kind of stereotypical 'gamer dude' that has been representative of the gamer community in the years past. But I want to spearhead or be a part of changing that.
Being nerdy just means being passionate about something, including everyone – the coolest people on Earth are passionate and therefore nerdy about something whatever it is, whether it's sports, or gaming, or technology, or fashion, or beauty, or food, or whatever.
If I have my way, I want to go start making really interactive television. Stuff where you can sit and watch real actors do a real series and they can get into some kind of gun battle and all of a sudden your television prompts you to pick up your controller and all of a sudden, you're playing a first-person shooter.
If somebody says 'singer-songwriter' to me, the first person I think of is James Taylor. There are plenty of modern singer-songwriters, but there is something about James Taylor that has always resonated with me.
I think that 'Family Guy' is hysterical. It's edgy and hip – and they can do whatever they want to do because it's animated and they're not limited by budget.
Famous Quotes by Zachary Levi
'Aladdin' was probably my favorite Disney animation when I was a kid. The animation was great and Robin Williams was unbelievable as the Genie. 'Aladdin' was an amazing adventure and the lead character was a hero for guys, which I loved. It wasn't a princess or a girl beating the odds; it was a street rat. That seemed really cool to me.
My high school experience was pretty good, but my middle school experience was god awful. It was horrible. I got picked on like no tomorrow.
My whole background, my whole life was just lots and lots of theater, a lot of that being musical theater.
I get a lot that people have a hard time believing that I'm a nerd… but I grew up with a Nintendo controller in my hand.
I want to go create my own independent content and entertainment, in new models and in new ways, and essentially show studios and networks that people are good.
Fans will treat something preciously if they're given the opportunity to do so.
Films are really cool because, every couple of months, or however many times you can get a job because there's a lot of luck involved in that, you're playing a different character.
Best Quotes by Zachary Levi
Oh, I've done bungee jumping. Skydiving, I have motorcycles that I ride. I'm a little bit of an adrenaline junkie in that way.
I'll watch a Pixar movie over and over and over again. I'll be with friends of mine who have kids, that want to watch 'Finding Nemo,' and I'm like, 'Yeah, okay, let's watch 'Nemo' again, for the seven billionth time!' because they're amazing movies.
I started in theater, and I love to go back to the theater, just to have the experience and recharge my batteries, creatively.
I'm a huge Disney nut. I have been since I was a little kid.
There are a lot of people who consider themselves 'spiritual,' but that can mean a lot of things to a lot of people. I don't really talk about it that often, because there's too much talk in the world. Especially with Christians, there's more proselytizing than there is actual living proof of it. That's kind of sad.
People don't talk about religion a lot in Hollywood because it's not an incredibly safe place to do it.
A lot of people, especially Christians, want to put you in this box of being a Christian actor, and I don't believe in it. You do yourself and everyone else a big disservice when you start thinking about it as 'Christian art.' That's why most Christian art is bad. They don't put a premium on the 'art.'
Tags: Images for Zachary Levi Quotes, Inspirational Quotes by Zachary Levi, Motivational Quotes by Zachary Levi, Quotes by Zachary Levi Quotes, Zachary Levi Quotations, Zachary Levi Quotes And Sayings
Previous PostMotivational Zachary Knighton Quotes And Sayings
Next PostMotivational Zachary Quinto Quotes and Sayings
Motivational Zara Phillips Quotes And Sayings
Motivational B Wayne Hughes Quotes and Sayings
List of Best Motivational Quotes on Aristotle


text:
Items where Author is "Parker, CC"
James, ND and Sydes, MR and Clarke, NW and Mason, MD and Dearnaley, DP and Spears, MR and Ritchie, AWS and Parker, CC and Russell, JM and Attard, G and De Bono, J and Cross, W and Jones, RJ and Thalmann, G and Amos, C and Matheson, D and Millman, R and Alzouebi, M and Beesley, S and Birtle, AJ and Brock, S and Cathomas, R and Chakraborti, P and Chowdhury, S and Cook, A and Elliott, T and Gale, J and Gibbs, S and Graham, JD and Hetherington, J and Hughes, R and Laing, R and McKinna, F and McLaren, DB and O'Sullivan, JM and Parikh, O and Peedell, C and Protheroe, A and Robinson, AJ and Srihari, N and Srinivasan, R and Staffurth, J and Sundar, S and Tolan, S and Tsang, D and Wagstaff, J and Parmar, MKB (2015) Addition of docetaxel, zoledronic acid, or both to first-line long-term hormone therapy in prostate cancer (STAMPEDE): Survival results from an adaptive, multiarm, multistage, platform randomised controlled trial. The Lancet, 387 (10024). 1163 - 1177. ISSN 0140-6736 DOI: https://doi.org/10.1016/S0140-6736(15)01037-5
James, ND and Spears, MR and Clarke, NW and Dearnaley, DP and Mason, MD and Parker, CC and Ritchie, AWS and Russell, JM and Schiavone, F and Attard, G and others (2015) Failure-free survival and radiotherapy in patients with newly diagnosed nonmetastatic prostate cancer: data from patients in the control arm of the STAMPEDE trial. JAMA oncology. 1 - 10. DOI: https://doi.org/10.1001/jamaoncol.2015.4350
Attard, G and Sydes, MR and Mason, MD and Clarke, NW and Aebersold, D and de Bono, JS and Dearnaley, DP and Parker, CC and Ritchie, AWS and Russell, JM and Thalmann, G and Cassoly, E and Millman, R and Matheson, D and Schiavone, F and Spears, MR and Parmar, MKB and James, ND (2014) Combining Enzalutamide with Abiraterone, Prednisone, and Androgen Deprivation Therapy in the STAMPEDE Trial. European Urology. ISSN 0302-2838 DOI: https://doi.org/10.1016/j.eururo.2014.05.038


text:
"""
This module defines modified versions of some classes and functions defined in
:mod:`multiprocessing.managers` to support OpenMDAO distributed simulations.

Channel communication can be secured by setting `authkey` to 'PublicKey'.
When `authkey` is 'PublicKey', an additional session establishment protocol
is used between the Proxy and Server:

1. Proxy sends session request containing the proxy's public key, encrypted with
   the server's public key (obtained when told what server to connect to).

2. Server responds with random session key, encrypted with proxy's public key.

3. Subsequent communication is encrypted with the session key (which presumably
   is quicker than public/private key encryption).

If `authkey` is not 'PublicKey', then the above session protocol is not used,
and channel data is in the clear.

Public methods of an object are determined by a role-based access control
attribute associated with the method. The server will verify that the current
role is allowed access. The current role is determined by an
:class:`AccessController` based on a :class:`Credentials` object received from
the proxy.

Assuming the credentials check passes, the server will set its credentials
to those specified by the :class:`AccessController` during the execution of the
method.
"""

# Unfortunately, there's a lot of multiprocessing package code duplication here.
# And a lot of this should be done at a lower layer. But then we'd be
# duplicating connection.py code as well as (more) managers.py code. Another
# alternative is to just use our own conection.py and managers.py (and whatever
# else might bleed in) as our private multiprocessing package.
# No obvious 'best' alternative.

import errno
import glob
import hashlib
import inspect
import logging
import os
import socket
import sys
import threading
import time
import traceback
from multiprocessing import Process, current_process, connection, util
from multiprocessing.forking import Popen
from multiprocessing.managers import BaseManager, BaseProxy, RebuildProxy, \
    Server, State, Token, convert_to_error, \
    dispatch, RemoteError

from Crypto import Random

if sys.platform == 'win32':  # pragma no cover
    from _multiprocessing import win32

from traits.trait_handlers import TraitDictObject

from openmdao.main.interfaces import obj_has_interface
from openmdao.main.mp_util import decrypt, encrypt, is_legal_connection, \
    keytype, make_typeid, public_methods, \
    tunnel_address, SPECIALS
from openmdao.main.rbac import AccessController, RoleError, check_role, \
    need_proxy, Credentials, \
    get_credentials, set_credentials

from openmdao.util.log import install_remote_handler, remove_remote_handlers, \
    logging_port, LOG_DEBUG2, LOG_DEBUG3

from openmdao.util.publickey import decode_public_key, encode_public_key, \
    get_key_pair, HAVE_PYWIN32, \
    pk_encrypt, pk_decrypt

# Classes which require proxying (used by default AccessController)
# Used to break import loop between this and openmdao.main.container.
CLASSES_TO_PROXY = []

# Cache of proxies created by _make_proxy_type().
_PROXY_CACHE = {}

def is_instance(obj, type_info):
    """
    :func:`isinstance` replacement for when `obj` might be a proxy.

    obj: object
        Object to be tested.

    type_info: class or tuple of classes
        Class(es) to be tested against.

    Returns True if `obj` is an instance of `type_info` or the object `obj`
    refers to is an instance of `type_info`.
    """
    if isinstance(obj, OpenMDAO_Proxy):
        try:
            type_info[0]
        except TypeError:
            type_info = (type_info,)
        for typ in type_info:
            typename = '%s.%s' % (typ.__module__, typ.__name__)
            if obj.__is_instance__(typename):
                return True
        return False
    else:
        return isinstance(obj, type_info)

def has_interface(obj, *ifaces):
    """
    :func:`obj_has_interface` replacement for when `obj` might be a proxy.

    obj: object
        Object to be tested.

    ifaces: list[Interface]
        Interfaces to be tested against.

    Returns True if `obj` or the object `obj` refers to supports at least one
    :class:`Interface` in `ifaces`.
    """
    if isinstance(obj, OpenMDAO_Proxy):
        for typ in ifaces:
            typename = '%s.%s' % (typ.__module__, typ.__name__)
            try:
                if obj.__has_interface__(typename):
                    return True
            except RemoteError:
                return False
        return False
    else:
        return obj_has_interface(obj, *ifaces)

class OpenMDAO_Server(Server):
    """
    A :class:`Server` that supports dynamic proxy generation and credential
    checking.

    registry: dict
        Manager's proxy registry.

    address: tuple or string
        A :mod:`multiprocessing` address specifying an Internet address or
        a pipe.

    authkey: string
        Authorization key. Inherited from the current :class:`Process`
        object if not specified.

    serializer: string
        Which serialization method to use.

    name: string
        Name for server, used in log files, etc.

    allowed_hosts: list(string)
        Host address patterns to check against.
        Optional if `allowed_users` is specified.

    allowed_users: dict
        Dictionary of users and corresponding public keys allowed access.
        If None, any user may access. If empty, no user may access.
        The host portions of user strings are used for address patterns.

    allow_tunneling: bool
        If True, allow connections from the local host, even if not listed
        otherwise.
    """

    def __init__(self, registry, address, authkey, serializer, name=None,
                 allowed_hosts=None, allowed_users=None, allow_tunneling=False):
        super(OpenMDAO_Server, self).__init__(registry, address, authkey,
                                              serializer)
        self.name = name or ('OMS_%d' % os.getpid())
        self._logger = logging.getLogger(self.name)
        self._logger.info('OpenMDAO_Server process %d started, %r',
                          os.getpid(), keytype(authkey))

        Random.atfork()  # Get our own PRNG.

        self.host = socket.gethostname()
        self._allowed_users = allowed_users
        if self._allowed_users is not None:
            hosts = set()
            for user_host in self._allowed_users.keys():
                user, host = user_host.split('@')
                try:
                    ip_addr = socket.gethostbyname(host)
                except socket.gaierror:
                    self._logger.warning('No address for %r', host)
                else:
                    hosts.add(ip_addr)
                if host == socket.getfqdn() or host == socket.gethostname():
                    hosts.add('127.0.0.1')  # localhost
            if allowed_hosts:
                hosts |= set(allowed_hosts)
            self._allowed_hosts = list(hosts)
        else:
            self._allowed_hosts = allowed_hosts or []

        self._allow_tunneling = allow_tunneling
        if allow_tunneling:
            self._allowed_hosts.append('127.0.0.1')  # localhost
            self._allowed_hosts.append(socket.gethostbyname(address[0]))

        if self._allowed_users is None:
            self._logger.warning('    allowed_users: ANY')
        else:
            self._logger.info('    allowed_users: %s',
                              sorted(self._allowed_users.keys()))
        if self._allowed_hosts:
            self._logger.info('    allowed_hosts: %s',
                              sorted(self._allowed_hosts))
        else:
            self._logger.warning('    allowed_hosts: ANY')

        self._authkey = authkey
        if authkey == 'PublicKey':
            # While we may be 'owned' by some remote user, use default
            # credentials for getting our key pair. This avoids generation
            # overhead and also issues with propagating our public key
            # back through a proxy.
            self._key_pair = get_key_pair(Credentials.user_host, self._logger)
        else:
            self._key_pair = None
        self._id_to_controller = {}
        self._access_controller = AccessController()
        for cls in CLASSES_TO_PROXY:
            self._access_controller.class_proxy_required(cls)
        self._address_type = connection.address_type(self.address)

    @property
    def public_key(self):
        """ Public key for session establishment. """
        if self._authkey == 'PublicKey':
            return self._key_pair.publickey()
        # Just being defensive.
        else:  # pragma no cover
            raise RuntimeError('No public key available')

    # This happens on the remote server side and we'll check when connecting.
    @property
    def public_key_text(self):  # pragma no cover
        """ Text representation of public key. """
        if self._authkey == 'PublicKey':
            return encode_public_key(self.public_key)
        else:
            return ''

    def serve_forever(self):
        """
        Run the server forever.
        This version supports host connection filtering.
        Connection filtering allows for PublicKey servers which aren't
        accessible by just any host.
        """
        current_process()._manager_server = self
        try:
            try:
                while not self.stop:
                    try:
                        conn = self.listener.accept()
                        # Comment-out the line above and use this equivalent
                        # to debug connectivity issues.
                        # conn = self.listener._listener.accept()
                        # self._logger.critical('connection attempt from %r',
                        #                      self.listener.last_accepted)
                        # if self.listener._authkey:
                        #    connection.deliver_challenge(conn, self.listener._authkey)
                        #    connection.answer_challenge(conn, self.listener._authkey)

                    # Hard to cause this to happen.
                    except (OSError, IOError):  # pragma no cover
                        if self.stop:
                            break
                        else:
                            continue

                    address = self.listener.last_accepted
                    if address:
                        if not is_legal_connection(address, self._allowed_hosts,
                                                   self._logger):
                            conn.close()
                            continue

                    t = threading.Thread(target=self.handle_request,
                                         args=(conn,))
                    t.daemon = True
                    try:
                        t.start()
                    # Don't want to cause this to happen.
                    except Exception as exc:  # pragma no cover
                        self._logger.error("Can't start server thread: %r", exc)
                        conn.close()
                        continue
            # Don't want to cause this to happen.
            except (KeyboardInterrupt, SystemExit):  # pragma no cover
                pass
        finally:
            self.stop = 999
            try:
                self.listener.close()
            except Exception as exc:
                self._logger.error('Exception closing listener: %r', exc)

    def handle_request(self, conn):
        """
        Handle a new connection.

        conn: socket or pipe
            Connection to process.

        This version filters host connections and avoids getting upset if it
        can't deliver a challenge. This is to deal with immediately closed
        connections caused by :meth:`manager_is_alive` which are used to avoid
        getting hung trying to connect to a manager which is no longer there.
        """
        funcname = result = request = None

        try:
            connection.deliver_challenge(conn, self.authkey)
        except (EOFError, IOError) as exc:
            conn.close()
            return
        # Hard to cause this to happen. It rarely happens, and then at shutdown.
        except Exception as exc:  # pragma no cover
            msg = ('#TRACEBACK', 'Exception delivering challenge: %r' % exc)
            try:
                conn.send(msg)
            except Exception as exc:
                pass
            util.info('Failure to send message: %r', msg)
            util.info(' ... request was %r', request)
            util.info(' ... exception was %r', exc)
            conn.close()
            return

        try:
            connection.answer_challenge(conn, self.authkey)
            request = conn.recv()
            ignore, funcname, args, kwds = request
            assert funcname in self.public, '%r unrecognized' % funcname
            func = getattr(self, funcname)
        # Hard to cause this to happen. It rarely happens, and then at shutdown.
        except Exception as exc:  # pragma no cover
            msg = ('#TRACEBACK', 'Exception answering challenge: %r' % exc)
        else:
            try:
                result = func(conn, *args, **kwds)
            # Hard to cause this to happen. It rarely happens, and then at shutdown.
            except Exception as exc:  # pragma no cover
                try:  # Sometimes at shutdown 'traceback' is None!?
                    msg = ('#TRACEBACK', traceback.format_exc())
                except Exception:
                    msg = ('#TRACEBACK',
                           'Exception from %r: %r' % (funcname, exc))
            else:
                msg = ('#RETURN', result)

        try:
            conn.send(msg)
        # Hard to cause this to happen. It rarely happens, and then at shutdown.
        except Exception as exc:  # pragma no cover
            try:
                conn.send(('#TRACEBACK', 'Exception sending reply: %r' % exc))
            except Exception:
                pass
            util.info('Failure to send message: %r', msg)
            util.info(' ... request was %r', request)
            util.info(' ... exception was %r', exc)

        conn.close()

    def serve_client(self, conn):
        """
        Handle requests from the proxies in a particular process/thread.

        conn: socket or pipe
            Connection to process.

        This version supports dynamic proxy generation and credential checking.
        """
        self._logger.log(LOG_DEBUG2, 'starting server thread to service %r, %s',
                         threading.current_thread().name, keytype(self._authkey))
        recv = conn.recv
        send = conn.send
        id_to_obj = self.id_to_obj
        id_to_controller = self._id_to_controller

        if self._authkey == 'PublicKey':
            client_key, session_key = self._init_session(conn)
        else:
            client_key = ''
            session_key = ''

        while not self.stop:

            try:
                ident = methodname = args = kwds = credentials = None
                obj = exposed = gettypeid = None
                data = recv()
                try:
                    request = decrypt(data, session_key)
                except Exception as exc:
                    trace = traceback.format_exc()
                    msg = "Can't decrypt/unpack request. This could be the" \
                          " result of referring to a dead server."
                    self._logger.error(msg)
                    self._logger.error(trace)
                    raise RuntimeError(msg)

                ident, methodname, args, kwds, credentials = request
                self._logger.log(LOG_DEBUG3, 'request %s %s', ident, methodname)
                #                self._logger.log(LOG_DEBUG3, 'credentials %s', credentials)
                #                self._logger.log(LOG_DEBUG3, 'id_to_obj:\n%s',
                #                                 self.debug_info(conn))

                # Decode and verify valid credentials.
                try:
                    credentials = Credentials.verify(credentials,
                                                     self._allowed_users)
                except Exception as exc:
                    self._logger.error('%r' % exc)
                    raise

                try:
                    obj, exposed, gettypeid = id_to_obj[ident]
                # Hard to cause this to happen.
                except KeyError:  # pragma no cover
                    msg = 'No object for ident %s' % ident
                    self._logger.error(msg)
                    raise KeyError('%s %r: %s' % (self.host, self.name, msg))

                if methodname not in exposed:
                    # Try to raise with a useful error message.
                    if methodname == '__getattr__':
                        try:
                            val = getattr(obj, args[0])
                        except AttributeError:
                            raise AttributeError(
                                'attribute %r of %r object does not exist'
                                % (args[0], type(obj)))
                        if inspect.ismethod(val):
                            methodname = args[0]
                        else:
                            raise AttributeError(
                                'attribute %r of %r is not accessible'
                                % (args[0], type(obj)))
                    raise AttributeError(
                        'method %r of %r object is not in exposed=%r'
                        % (methodname, type(obj), exposed))

                # Set correct credentials for function lookup.
                set_credentials(credentials)
                function = getattr(obj, methodname)

                # Proxy pass-through only happens remotely.
                if isinstance(obj, BaseProxy):  # pragma no cover
                    role = None
                    access_controller = None
                else:
                    # Check for allowed access.
                    role, credentials, access_controller = \
                        self._check_access(ident, methodname, function, args,
                                           credentials)
                if methodname != 'echo':
                    # 'echo' is used for performance tests, keepalives, etc.
                    self._logger.log(LOG_DEBUG2, "Invoke %s %s '%s'",
                                     methodname, role, credentials)
                    self._logger.log(LOG_DEBUG3, '       %s %s', args, kwds)

                # Invoke function.
                try:
                    try:
                        res = function(*args, **kwds)
                        self._logger.log(LOG_DEBUG3, '       res %r', res)
                    except AttributeError as exc:
                        if isinstance(obj, BaseProxy) and \
                                        methodname == '__getattribute__':
                            # Avoid an extra round-trip.
                            res = obj.__getattr__(*args, **kwds)
                        else:
                            raise
                except Exception as exc:
                    self._logger.exception('%s %s %s failed:',
                                           methodname, role, credentials)
                    msg = ('#TRACEBACK', traceback.format_exc())
                else:
                    msg = self._form_reply(res, ident, methodname, function,
                                           args, access_controller, conn)

            except AttributeError:
                # Just being defensive, this should never happen.
                if methodname is None:  # pragma no cover
                    msg = ('#TRACEBACK', traceback.format_exc())
                else:
                    orig_traceback = traceback.format_exc()
                    try:
                        fallback_func = self.fallback_mapping[methodname]
                        self._logger.log(LOG_DEBUG2, 'Fallback %s', methodname)
                        result = fallback_func(self, conn, ident, obj,
                                               *args, **kwds)
                        msg = ('#RETURN', result)
                    except Exception:
                        msg = ('#TRACEBACK', orig_traceback)

            except EOFError:
                util.debug('got EOF -- exiting thread serving %r',
                           threading.current_thread().name)
                sys.exit(0)

            # Just being defensive, this should never happen.
            except Exception:  # pragma no cover
                trace = traceback.format_exc()
                self._logger.error('serve_client exception, method %s',
                                   methodname)
                self._logger.error(trace)
                msg = ('#TRACEBACK', trace)

            try:
                try:
                    send(encrypt(msg, session_key))
                except Exception:
                    send(encrypt(('#UNSERIALIZABLE', repr(msg)), session_key))
            # Just being defensive, this should never happen.
            except Exception as exc:  # pragma no cover
                self._logger.error('exception in thread serving %r',
                                   threading.current_thread().name)
                self._logger.error(' ... message was %r', msg)
                self._logger.error(' ... exception was %r', exc)
                conn.close()
                sys.exit(1)

    def _init_session(self, conn):
        """ Receive client public key, send session key. """
        # Hard to cause exceptions to happen where we'll see them.
        try:
            client_data = conn.recv()
        except Exception as exc:  # pragma no cover
            self._logger.error("Can't receive client data: %r", exc)
            raise

        client_version = client_data[0]
        if client_version != 1:  # pragma no cover
            msg = 'Expected client protocol version 1, got %r' % client_version
            self._logger.error(msg)
            raise RuntimeError(msg)

        n, e, encrypted = client_data[1:]
        if e != self._key_pair.e or n != self._key_pair.n:  # pragma no cover
            msg = 'Server key mismatch'
            self._logger.error(msg)
            raise RuntimeError(msg)

        try:
            text = pk_decrypt(encrypted, self._key_pair)
            client_key = decode_public_key(text)
        except Exception as exc:  # pragma no cover
            self._logger.error("Can't recreate client key: %r", exc)
            raise

        server_version = 1
        try:
            session_key = hashlib.sha1(str(id(conn))).hexdigest()
            data = client_key.encrypt(session_key, '')
            conn.send((server_version, data))
        except Exception as exc:  # pragma no cover
            self._logger.error("Can't send session key: %r", exc)
            raise

        return (client_key, session_key)

    def _check_access(self, ident, methodname, function, args, credentials):
        """ Check for valid access, return (role, credentials, controller). """
        obj, exposed, gettypeid = self.id_to_obj[ident]

        # Get access controller for obj.
        access_controller = self._id_to_controller.get(ident)
        if access_controller is None:
            try:
                get_access_controller = getattr(obj, 'get_access_controller')
            except AttributeError:
                access_controller = self._access_controller
            # Only happens on remote protected object.
            else:  # pragma no cover
                if get_access_controller is None:
                    access_controller = self._access_controller
                else:
                    access_controller = get_access_controller()
            self._id_to_controller[ident] = access_controller

        # Get role based on credentials.
        role = access_controller.get_role(credentials)

        if methodname in SPECIALS:
            # Check for valid access based on role.
            access_controller.check_access(role, methodname, obj, args[0])
        else:
            # Check for valid role.
            try:
                check_role(role, function)
            except RoleError as exc:
                raise RoleError('%s(): %s' % (methodname, exc))

            # Set credentials for execution of function. Typically
            # these are just the credentials of the caller, but
            # sometimes a function needs to execute with different
            # credentials.
            credentials = \
                access_controller.get_proxy_credentials(function, credentials)
            set_credentials(credentials)

        return (role, credentials, access_controller)

    def _form_reply(self, res, ident, methodname, function, args,
                    access_controller, conn):
        """ Return reply message for `res`. """
        obj, exposed, gettypeid = self.id_to_obj[ident]
        msg = None
        typeid = None

        if inspect.ismethod(res) and \
                (methodname == '__getattribute__' or methodname == '__getattr__'):
            # More informative for common case of missing RBAC.
            raise AttributeError('method %r of %r object is not in exposed=%r'
                                 % (args[0], type(obj), exposed))

        # Proxy pass-through only happens remotely.
        if isinstance(res, OpenMDAO_Proxy):  # pragma no cover
            res_address = res._token.address
            res_type = connection.address_type(res_address)
            proxy_proxy = False
            if res_type != self._address_type:
                proxy_proxy = True  # Different type of connection.
            elif res_type == 'AF_INET':
                if res_address[0] != self.address[0]:
                    proxy_proxy = True  # Different network.
                elif res_address[0] == '127.0.0.1' and self._allow_tunneling:
                    proxy_proxy = True  # Access through tunnel.
            if proxy_proxy:
                # Create proxy for proxy.
                typeid = res._token.typeid
                proxyid = make_typeid(res)
                self._logger.log(LOG_DEBUG2, 'Creating proxy for proxy %s',
                                 proxyid)
                if proxyid not in self.registry:
                    self.registry[proxyid] = (None, None, None, _auto_proxy)
            else:
                # Propagate the proxy info.
                res._close.cancel()  # Don't decref when reaped.
                msg = ('#PROXY', (res._exposed_, res._token, res._pubkey))

        elif access_controller is not None:
            # Check if the value must be proxied.
            if methodname in SPECIALS:
                if access_controller.need_proxy(obj, args[0], res):
                    # Create proxy if in declared proxy types.
                    typeid = make_typeid(res)
                    proxyid = typeid
                    if typeid not in self.registry:
                        self.registry[typeid] = (None, None, None, None)
            elif need_proxy(function, res, access_controller):
                # Create proxy if in declared proxy types.
                typeid = make_typeid(res)
                proxyid = typeid
                if typeid not in self.registry:
                    self.registry[typeid] = (None, None, None, None)

            elif hasattr(res, '_parent') and res._parent is not None:
                # Check if the value must be copied (VariableTree).
                # Odd that it isn't being proxied (though we don't want one).
                res = res.copy()

        # Proxy pass-through only happens remotely.
        else:  # pragma no cover
            # Create proxy if registered.
            typeid = gettypeid and gettypeid.get(methodname, None)
            proxyid = typeid

        if msg is None:
            if typeid:
                rident, rexposed = self.create(conn, proxyid, res)
                token = Token(typeid, self.address, rident)
                self._logger.log(LOG_DEBUG2, 'Returning proxy for %s at %s',
                                 typeid, self.address)
                if self._key_pair is None:
                    pubkey = None
                else:
                    pubkey = self._key_pair.publickey()
                msg = ('#PROXY', (rexposed, token, pubkey))
            else:
                msg = ('#RETURN', res)

        return msg

    def _fallback_isinstance(self, conn, ident, obj, typename):
        """ Check if `obj` is an instance of `typename`. """
        # It's very difficult to get an arbitrary `typename` here.
        dot = typename.rfind('.')
        module_name = typename[:dot]
        class_name = typename[dot + 1:]
        try:
            module = __import__(module_name)
        except ImportError:  # pragma no cover
            return False
        module = sys.modules[module_name]
        try:
            cls = getattr(module, class_name)
        except AttributeError:  # pragma no cover
            return False
        return isinstance(obj, cls)

    Server.fallback_mapping['__is_instance__'] = _fallback_isinstance

    def _fallback_hasinterface(self, conn, ident, obj, typename):
        """ Check if `obj` supports `typename`. """
        # It's very difficult to get an arbitrary `typename` here.
        dot = typename.rfind('.')
        module_name = typename[:dot]
        class_name = typename[dot + 1:]
        try:
            module = __import__(module_name)
        except ImportError:  # pragma no cover
            return False
        module = sys.modules[module_name]
        try:
            cls = getattr(module, class_name)
        except AttributeError:  # pragma no cover
            return False
        return obj_has_interface(obj, cls)

    Server.fallback_mapping['__has_interface__'] = _fallback_hasinterface

    # This is for low-level debugging of servers.
    def debug_info(self, conn):  # pragma no cover
        """
        Return string representing state of id_to_obj mapping.

        conn: socket or pipe
            Unused.

        This version handles proxies in a special manner.
        """
        self.mutex.acquire()
        try:
            result = []
            keys = self.id_to_obj.keys()
            keys.sort()
            for ident in keys:
                if ident != '0':
                    obj = self.id_to_obj[ident][0]
                    if isinstance(obj, BaseProxy):
                        obj_str = '%s proxy for %s %s' \
                                  % (keytype(obj._authkey), obj._id,
                                     obj._token.typeid)
                    else:
                        obj_str = str(obj)[:75]
                    result.append('  %s:       refcount=%s\n    %s' %
                                  (ident, self.id_to_refcount[ident], obj_str))
            return '\n'.join(result)
        finally:
            self.mutex.release()

    def create(self, conn, typeid, *args, **kwds):
        """
        Create a new shared object and return its id.

        conn: socket or pipe
            Connection to process.

        typeid: string
            Identifier string for type of object to be created.

        This version uses :func:`public_methods`.
        """
        self.mutex.acquire()
        try:
            try:
                callable, exposed, method_to_typeid, proxytype = \
                    self.registry[typeid]
            # Just being defensive.
            except KeyError:  # pragma no cover
                logging.error('mp_support.create: %r registry', typeid)
                for key, value in self.registry.items():
                    logging.error('    %s: %s', key, value)
                raise

            if callable is None:
                assert len(args) == 1 and not kwds
                obj = args[0]
            else:
                obj = callable(*args, **kwds)

            if exposed is None:
                exposed = public_methods(obj)
            if method_to_typeid is not None:
                assert type(method_to_typeid) is dict
                exposed = list(exposed) + list(method_to_typeid)

            ident = '%x' % id(obj)  # convert to string because xmlrpclib
            # only has 32 bit signed integers
            util.debug('%r callable returned object with id %r', typeid, ident)

            self.id_to_obj[ident] = (obj, set(exposed), method_to_typeid)
            if ident not in self.id_to_refcount:
                self.id_to_refcount[ident] = 0
            # increment the reference count immediately, to avoid
            # this object being garbage collected before a Proxy
            # object for it can be created.  The caller of create()
            # is responsible for doing a decref once the Proxy object
            # has been created.
            self.incref(conn, ident)
            return ident, tuple(exposed)
        finally:
            self.mutex.release()

    # Will only be seen on remote.
    def shutdown(self, conn):  # pragma no cover
        """ Shutdown this process. """
        self.stop = 888
        msg = 'received shutdown request, running exit functions'
        print msg
        sys.stdout.flush()
        self._logger.info(msg)
        remove_remote_handlers()

        # Deprecated, but marginally better than atexit._run_exitfuncs()
        # Don't try to log here, logging shuts-down via atexit.
        if hasattr(sys, 'exitfunc'):
            try:
                sys.exitfunc()
            except Exception as exc:
                print 'sys.exitfunc(): %s' % exc
                sys.stdout.flush()

        print '    exit functions complete'
        sys.stdout.flush()

        super(OpenMDAO_Server, self).shutdown(conn)

class OpenMDAO_Manager(BaseManager):
    """
    Uses :class:`OpenMDAO_Server`, retains the public key, and puts some slack
    in shutdown timing.

    address: tuple or string
        A :mod:`multiprocessing` address specifying an Internet address or
        a pipe.

    authkey: string
        Authorization key. Inherited from the current :class:`Process`
        object if not specified.

    serializer: string
        Which serialization method to use.

    pubkey: public key
        Public portion of server's public/private key pair.
        Needed for client/proxy side.

    name: string
        Name for server, used in log files, etc.

    allowed_hosts: list(string)
        Host address patterns to check against.

    allowed_users: dict
        Dictionary of users and corresponding public keys allowed access.
        If None, any user may access. If empty, no user may access.

    allow_tunneling: bool
        If True, allow connections from 127.0.0.1 (localhost), even if not
        listed otherwise.
    """

    _Server = OpenMDAO_Server

    def __init__(self, address=None, authkey=None, serializer='pickle',
                 pubkey=None, name=None, allowed_hosts=None, allowed_users=None,
                 allow_tunneling=False):
        super(OpenMDAO_Manager, self).__init__(address, authkey, serializer)
        self._pubkey = pubkey
        self._name = name
        self._allowed_hosts = allowed_hosts
        self._allowed_users = allowed_users
        self._allow_tunneling = allow_tunneling

    def get_server(self):
        """
        Return a server object with :meth:`serve_forever` and address attribute.
        """
        assert self._state.value == State.INITIAL
        return OpenMDAO_Server(self._registry, self._address, self._authkey,
                               self._serializer, self._name,
                               self._allowed_hosts, self._allowed_users,
                               self._allow_tunneling)

    def start(self, cwd=None, log_level=logging.DEBUG):
        """
        Spawn a server process for this manager object.

        cwd: string
            Directory to start in.

        log_level: int
            Initial root logging level for the server process.

        This version retrieves the server's public key.
        """
        assert self._state.value == State.INITIAL

        # Pipe over which we will retrieve address of server.
        reader, writer = connection.Pipe(duplex=False)

        if sys.platform == 'win32':  # pragma no cover
            # Make registry pickleable.
            registry = {}
            for typeid, info in self._registry.items():
                callable, exposed, method_to_typeid, proxytype = info
                if proxytype and proxytype != _auto_proxy:
                    registry[typeid] = \
                        (callable, exposed, method_to_typeid, 'rebuild')
        else:
            registry = self._registry

        # Flush logs before cloning.
        for handler in logging._handlerList:
            try:
                handler.flush()
            except AttributeError:
                h = handler()  # WeakRef
                if h:
                    h.flush()

        # Spawn process which runs a server.
        credentials = get_credentials()
        log_port = logging_port('localhost', 'localhost')
        self._process = Process(
            target=type(self)._run_server,
            args=(registry, self._address, self._authkey,
                  self._serializer, self._name, self._allowed_hosts,
                  self._allowed_users, self._allow_tunneling,
                  writer, credentials, cwd, log_port, log_level),
        )
        ident = ':'.join(str(i) for i in self._process._identity)
        self._process.name = type(self).__name__ + '-' + ident
        self._process.start()
        pid = self._process.pid

        # Get address of server.
        if self._authkey == 'PublicKey':
            if sys.platform == 'win32' and not HAVE_PYWIN32:  # pragma no cover
                timeout = 120
            else:
                timeout = 10
        else:
            timeout = 10

        writer.close()
        start = time.time()
        error_msg = None
        for retry in range(timeout):
            if reader.poll(1):
                break
            if not self._process.is_alive():
                error_msg = 'Server process %d exited: %s' \
                            % (pid, self._process.exitcode)
                break
        # Hard to cause a timeout.
        else:  # pragma no cover
            if error_msg is None:
                et = time.time() - start
                self._process.terminate()
                error_msg = 'Server process %d startup timed-out in %.2f' \
                            % (pid, et)
        if error_msg is None:
            try:
                reply = reader.recv()
            except Exception as exc:  # str(Exception()) is null, repr() isn't.
                error_msg = 'Server process %d read failed: %s' \
                            % (pid, str(exc) or repr(exc))
            else:
                if isinstance(reply, Exception):
                    error_msg = 'Server process %d startup failed: %s' \
                                % (pid, str(reply) or repr(reply))
        if error_msg:
            logging.error(error_msg)
            if cwd:
                logging.error('    in dir %r', cwd)
                for name in ('stdout', 'stderr', 'openmdao_log*.txt'):
                    for path in glob.glob(os.path.join(cwd, name)):
                        name = os.path.basename(path)
                        with open(path, 'r') as inp:
                            logging.error('    %s:\n%s', name, inp.read())
            raise RuntimeError(error_msg)

        self._address = reply
        if self._authkey == 'PublicKey':
            self._pubkey = reader.recv()
        reader.close()
        et = time.time() - start
        logging.debug('Server process %d startup in %.2f', pid, et)

        # Register a finalizer.
        self._state.value = State.STARTED
        self.shutdown = util.Finalize(
            self, type(self)._finalize_manager,
            args=(self._process, self._address, self._authkey,
                  self._state, self._Client),
            exitpriority=0
        )

    # This happens on the remote server side and we'll check when using it.
    @classmethod
    def _run_server(cls, registry, address, authkey, serializer, name,
                    allowed_hosts, allowed_users, allow_tunneling,
                    writer, credentials, cwd, log_port, log_level):  # pragma no cover
        """
        Create a server, report its address and public key, and run it.
        """
        try:
            if sys.platform == 'win32':
                set_credentials(credentials)
                # Recreate registry proxytypes.
                for typeid, info in registry.items():
                    callable, exposed, method_to_typeid, proxytype = info
                    if proxytype == 'rebuild':
                        registry[typeid] = (callable, exposed, method_to_typeid,
                                            _make_proxy_type(typeid, exposed))

            # If specified, move to new directory.
            if cwd is not None:
                os.chdir(cwd)

                # Cleanup cloned logging environment.
                del logging.root.handlers[:]
                del logging._handlerList[:]
                logging._handlers.clear()

                # Reset stdout & stderr.
                sys.stdout.flush()
                sys.stderr.flush()
                sys.stdout = open('stdout', 'w')
                sys.stderr = open('stderr', 'w')

                # Reset logging.
                logging.basicConfig(level=log_level,
                                    datefmt='%b %d %H:%M:%S',
                                    format='%(asctime)s %(levelname)s %(name)s: %(message)s',
                                    filename='openmdao_log.txt', filemode='w')

                # Connect to remote logging server.
                if log_port:
                    install_remote_handler('localhost', log_port, name)

            # Create server.
            server = cls._Server(registry, address, authkey, serializer, name,
                                 allowed_hosts, allowed_users, allow_tunneling)
        except Exception as exc:
            traceback.print_exc()
            writer.send(exc)
            return
        else:
            # Inform parent process of the server's address.
            writer.send(server.address)
            if authkey == 'PublicKey':
                writer.send(server.public_key)
        finally:
            writer.close()

        # Run the manager.
        util.info('manager serving at %r', server.address)
        server.serve_forever()

    @staticmethod
    def _finalize_manager(process, address, authkey, state, _Client):
        """
        Shutdown the manager process; will be registered as a finalizer.
        This version uses relaxed timing.
        """
        if process.is_alive():
            logging.debug('sending shutdown message to manager')
            try:
                conn = _get_connection(_Client, address, authkey)
                try:
                    dispatch(conn, None, 'shutdown')
                finally:
                    conn.close()
            # Just being defensive here.
            except Exception:  # pragma no cover
                pass

            process.join(timeout=2)
            # No good way to cause process to not shut down.
            if process.is_alive():  # pragma no cover
                logging.warning('manager still alive after shutdown request')
                if hasattr(process, 'terminate'):
                    logging.warning('trying to `terminate()` manager process')
                    process.terminate()
                    process.join(timeout=1)
                    if process.is_alive():
                        logging.warning('manager still alive after terminate')
                if process.is_alive():
                    if sys.platform != 'win32':
                        os.kill(process.pid.signal.SIGKILL)
                        process.join(timeout=1)
                        if process.is_alive():
                            logging.warning('manager still alive after kill')

        state.value = State.SHUTDOWN
        try:
            del BaseProxy._address_to_local[address]
        # Just being defensive here.
        except KeyError:  # pragma no cover
            pass

class ObjectManager(object):
    """
    Provides a multiprocessing interface for an existing object.

    obj: object
        Object to provide remote access to.

    address: tuple or string
        A :mod:`multiprocessing` address specifying an Internet address or
        a pipe.

    serializer: string
        Which serialization method to use.

    authkey: string
        Authorization key. Inherited from the current :class:`Process`
        object if not specified.

    name: string
        Name for server, used in log files, etc.

    allowed_hosts: list(string)
        Host address patterns to check against.

    allowed_users: dict
        Dictionary of users and corresponding public keys allowed access.
        If None, any user may access. If empty, no user may access.
    """

    def __init__(self, obj, address=None, serializer='pickle', authkey=None,
                 name=None, allowed_hosts=None, allowed_users=None):
        self._typeid = make_typeid(obj)
        self._ident = '%x' % id(obj)
        logging.debug('ObjectManager address %s, %r, name %r, ident %r',
                      address, keytype(authkey), name, self._ident)
        self._manager = OpenMDAO_Manager(address=address, serializer=serializer,
                                         authkey=authkey, name=name,
                                         allowed_hosts=allowed_hosts,
                                         allowed_users=allowed_users)
        self._server = self._manager.get_server()
        self._exposed = public_methods(obj)

        with self._server.mutex:
            self._server.id_to_obj[self._ident] = (obj, self._exposed, None)
            self._server.id_to_refcount[self._ident] = 1

        self._server_thread = threading.Thread(target=self._run_server)
        self._server_thread.daemon = True
        self._server_thread.start()

        self._proxy = None

    @property
    def proxy(self):
        """ Proxy for our object server. """
        if self._proxy is None:
            token = Token(self._typeid, self._server.address, self._ident)
            authkey = self._server._authkey
            pubkey = self._server.public_key if authkey == 'PublicKey' else None
            self._proxy = _auto_proxy(token, self._manager._serializer,
                                      authkey=authkey, exposed=self._exposed,
                                      pubkey=pubkey)
            self._server.incref(None, self._ident)
        return self._proxy

    def _run_server(self):
        """ Run a manager server (in a separate thread!). """
        self._server.serve_forever()

class OpenMDAO_Proxy(BaseProxy):
    """
    Proxy for a remote object.

    args: tuple
        Passed to :class:`BaseProxy`.

    kwds: dict
        If it contains `pubkey`, then that value is used for the remote public
        key, and the entry is removed before being passed to :class:`BaseProxy`.

    This version sends credentials and provides dynamic result proxy generation.

    .. note::

        :meth:`BaseProxy.__str__` (used by :meth:`str` and the ``%s`` format)
        will return :meth:`__repr__` of the remote object.  To avoid the
        network round-trip delay, use :meth:`repr` or the ``%r`` format.

    """

    def __init__(self, *args, **kwds):
        try:
            pubkey = kwds['pubkey']
        except KeyError:
            pubkey = None
        else:
            del kwds['pubkey']

        super(OpenMDAO_Proxy, self).__init__(*args, **kwds)

        if self._manager is None:
            self._pubkey = pubkey
        else:
            self._pubkey = self._manager._pubkey

    def _connect(self):
        """ This version translates tunneled addresses. """
        util.debug('making connection to manager')
        name = current_process().name
        if threading.current_thread().name != 'MainThread':
            name += '|' + threading.current_thread().name
        address = tunnel_address(self._token.address)
        conn = self._Client(address, authkey=self._authkey)
        dispatch(conn, None, 'accept_connection', (name,))
        self._tls.connection = conn

    def _callmethod(self, methodname, args=None, kwds=None):
        """
        Try to call a method of the referrent and return a copy of the result.
        This version optionally encrypts the channel and sends the current
        thread's credentials with method arguments.
        """
        args = args or ()
        kwds = kwds or {}

        try:
            conn = self._tls.connection
        except AttributeError:
            curr_thread = threading.current_thread()
            util.debug('thread %r does not own a connection', curr_thread.name)
            try:
                self._connect()
            except Exception as exc:
                msg = "Can't connect to server at %r for %r: %r" \
                      % (self._token.address, methodname, exc)
                logging.error(msg)
                raise RuntimeError(msg)
            conn = self._tls.connection
            if self._authkey == 'PublicKey':
                self._init_session(conn)
            else:
                self._tls.session_key = ''

        session_key = self._tls.session_key

        # FIXME: Bizarre problem evidenced by test_extcode.py (Python 2.6.1)
        # For some reason pickling the env_vars dictionary causes:
        #    PicklingError: Can't pickle <class 'openmdao.main.mp_support.ObjServer'>:
        #                     attribute lookup openmdao.main.mp_support.ObjServer failed
        # The reported type is not in the (current) Dict items.
        # Apparently this is some Traits 'feature'.
        new_args = []
        for arg in args:
            if isinstance(arg, TraitDictObject):
                new_args.append(dict(arg))
            else:
                new_args.append(arg)

        try:
            conn.send(encrypt((self._id, methodname, new_args, kwds,
                               get_credentials().encode()), session_key))
        except IOError as exc:
            msg = "Can't send to server at %r for %r: %r" \
                  % (self._token.address, methodname, exc)
            logging.error(msg)
            raise RuntimeError(msg)

        kind, result = decrypt(conn.recv(), session_key)

        if kind == '#RETURN':
            return result

        elif kind == '#PROXY':
            exposed, token, pubkey = result

            # Proxy passthru only happens remotely.
            if self._manager is None:  # pragma no cover
                self._manager = OpenMDAO_Manager(token.address, self._authkey,
                                                 pubkey=pubkey)
            try:
                proxytype = self._manager._registry[token.typeid][-1]
            except KeyError:
                proxytype = None
            if proxytype is None:
                self._manager.register(token.typeid, None, _auto_proxy)
                proxytype = self._manager._registry[token.typeid][-1]

            if token.address != self._manager.address:
                # Proxy to different server than request was sent to.
                manager = OpenMDAO_Manager(token.address, self._authkey,
                                           pubkey=pubkey)
            else:
                manager = self._manager

            proxy = proxytype(token, self._serializer, manager=manager,
                              authkey=self._authkey, exposed=exposed,
                              pubkey=pubkey)

            conn = _get_connection(self._Client, token.address, self._authkey)
            dispatch(conn, None, 'decref', (token.id,))
            return proxy

        raise convert_to_error(kind, result)

    def _init_session(self, conn):
        """ Send client public key, receive session key. """
        key_pair = get_key_pair(Credentials.user_host)
        public_key = key_pair.publickey()
        text = encode_public_key(public_key)

        server_key = self._pubkey
        encrypted = pk_encrypt(text, server_key)
        client_version = 1
        conn.send((client_version, server_key.n, server_key.e, encrypted))

        server_data = conn.recv()
        server_version = server_data[0]
        # Just being defensive, this should never happen.
        if server_version != 1:  # pragma no cover
            msg = 'Expecting server protocol version 1, got %r' % server_version
            logging.error(msg)
            if server_version == '#TRACEBACK':
                try:
                    logging.error(''.join(server_data[1]))
                except Exception:
                    pass
            raise RuntimeError(msg)

        self._tls.session_key = key_pair.decrypt(server_data[1])

    def _incref(self):
        """
        Tell server to increment its reference count.
        This version avoids a hang in _Client if the server no longer exists.
        """
        # Hard to cause this to happen.
        if not OpenMDAO_Proxy.manager_is_alive(self._token.address):  # pragma no cover
            raise RuntimeError('Cannot connect to manager at %r'
                               % (self._token.address,))

        conn = _get_connection(self._Client, self._token.address, self._authkey)
        dispatch(conn, None, 'incref', (self._id,))
        # Enable this with care. While testing CaseIteratorDriver it can cause a
        # deadlock in logging (called via BaseProxy._after_fork()).
        # util.debug('INCREF %r', self._token.id)

        self._idset.add(self._id)

        state = self._manager and self._manager._state

        self._close = util.Finalize(
            self, OpenMDAO_Proxy._decref,
            args=(self._token, self._authkey, state,
                  self._tls, self._idset, self._Client),
            exitpriority=10
        )

    @staticmethod
    def _decref(token, authkey, state, tls, idset, _Client):
        """
        Tell server to decrement its reference count.
        This version avoids a hang in _Client if the server no longer exists.
        """
        idset.discard(token.id)

        # check whether manager is still alive
        if state is None or state.value == State.STARTED:
            # Avoid a hang in _Client() if the server isn't there anymore.
            if OpenMDAO_Proxy.manager_is_alive(token.address):
                # tell manager this process no longer cares about referent
                try:
                    util.debug('DECREF %r', token.id)
                    conn = _get_connection(_Client, token.address, authkey)
                    dispatch(conn, None, 'decref', (token.id,))
                # Hard to cause this to happen.
                except Exception as exc:  # pragma no cover
                    util.debug('... decref failed %s', exc)
        else:
            util.debug('DECREF %r -- manager already shutdown', token.id)

        # check whether we can close this thread's connection because
        # the process owns no more references to objects for this manager
        if not idset and hasattr(tls, 'connection'):
            util.debug('thread %r has no more %r proxies so closing conn',
                       threading.current_thread().name, token.typeid)
            tls.connection.close()
            del tls.connection

    @staticmethod
    def manager_is_alive(address):
        """
        Check whether manager is still alive.

        address: tuple or string
            A :mod:`multiprocessing` address specifying an Internet address or
            a pipe.
        """
        addr_type = connection.address_type(address)
        if addr_type == 'AF_PIPE':  # pragma no cover
            try:
                win32.WaitNamedPipe(address, 10)  # 0.01 sec
            except WindowsError:
                alive = False
            else:
                alive = True
        else:
            if addr_type == 'AF_INET':
                sock = socket.socket(socket.AF_INET)
            elif addr_type == 'AF_UNIX':
                sock = socket.socket(socket.AF_UNIX)

            address = tunnel_address(address)
            try:
                sock.connect(address)
            except socket.error as exc:
                if exc.args[0] == errno.ECONNREFUSED or \
                                exc.args[0] == errno.ENOENT:
                    alive = False
                # Just being defensive.
                else:  # pragma no cover
                    raise
            else:
                sock.close()
                alive = True
        return alive

    def __reduce__(self):
        """ For unpickling.  This version uses :func:`_auto_proxy`. """
        kwds = {}
        kwds['pubkey'] = self._pubkey
        # Happens on other side of fork().
        if Popen.thread_is_spawning():  # pragma no cover
            kwds['authkey'] = self._authkey
        elif self._pubkey:
            # Can't pickle an AuthenticationString.
            kwds['authkey'] = 'PublicKey'

        kwds['exposed'] = self._exposed_
        return (RebuildProxy,
                (_auto_proxy, self._token, self._serializer, kwds))

def register(cls, manager, module=None):
    """
    Register class `cls` proxy info with `manager`. The class will be
    registered under it's full path, with '.' replaced by '_'.
    Not typically called by user code.

    cls: class
        Class to be registered.

    manager: :class:`OpenMDAO_Manager`
        Manager to register with.

    module: string
        Module name for registration. Necessary if `cls` might be defined
        by module '__main__'.
    """
    if module is None:
        module = cls.__module__
    typeid = '%s.%s' % (module, cls.__name__)
    typeid = typeid.replace('.', '_')
    exposed = public_methods(cls)
    proxytype = _make_proxy_type(typeid, exposed)
    manager.register(typeid, callable=cls, exposed=exposed, proxytype=proxytype)

def _make_proxy_type(name, exposed):
    """
    Return a proxy type whose methods are given by `exposed`.
    This version supports special attribute access methods.
    """
    exposed = tuple(exposed)
    try:
        return _PROXY_CACHE[(name, exposed)]
    except KeyError:
        pass

    dic = {'_instance_names': {}, '_interface_names': {}}

    for meth in exposed:
        if meth == '__is_instance__':
            # Call remote if we don't have the answer in cache.
            exec """
def __is_instance__(self, *args, **kwds):
    try:
        return self._instance_names[args[0]]
    except KeyError:
        yes_no = self._callmethod('__is_instance__', args, kwds)
        self._instance_names[args[0]] = yes_no
        return yes_no
""" in dic

        elif meth == '__has_interface__':
            # Call remote if we don't have the answer in cache.
            exec """
def __has_interface__(self, *args, **kwds):
    try:
        return self._interface_names[args[0]]
    except KeyError:
        yes_no = self._callmethod('__has_interface__', args, kwds)
        self._interface_names[args[0]] = yes_no
        return yes_no
""" in dic

        elif meth == '__getattr__':
            pass  # Avoid recursion loop, but must be in 'exposed'.

        elif meth == '__getattribute__':
            # Call remote if not private or defined locally (proxied methods).
            exec """
def __getattr__(self, *args, **kwds):
    if args[0][0] == '_':
        return object.__getattribute__(self, *args, **kwds)
    try:
        return object.__getattribute__(self, *args, **kwds)
    except AttributeError:
        try:
            return self._callmethod('__getattribute__', args, kwds)
        except AttributeError:
            return self._callmethod('__getattr__', args, kwds)
""" in dic

        elif meth == '__setattr__' or meth == '__delattr__':
            # Call remote if not private.
            exec """
def %s(self, *args, **kwds):
    if args[0][0] == '_':
        return object.%s(self, *args, **kwds)
    return self._callmethod(%r, args, kwds)
""" % (meth, meth, meth) in dic

        elif meth == '__exit__':
            # Can't pickle traceback argument.
            exec """
def __exit__(self, exc_type, exc_value, traceback):
    return self._callmethod('__exit__', (exc_type, exc_value, None))
""" in dic

        else:
            # Normal method always calls remote.
            exec """
def %s(self, *args, **kwds):
    return self._callmethod(%r, args, kwds)
""" % (meth, meth) in dic

    ProxyType = type(name, (OpenMDAO_Proxy,), dic)
    ProxyType._exposed_ = exposed
    _PROXY_CACHE[(name, exposed)] = ProxyType
    return ProxyType

def _auto_proxy(token, serializer, manager=None, authkey=None,
                exposed=None, incref=True, pubkey=None):
    """
    Return an auto-proxy for `token`.
    This version uses :func:`_make_proxy_type`.
    """
    ProxyType = _make_proxy_type('OpenMDAO_AutoProxy[%s]' % token.typeid,
                                 exposed)
    try:
        proxy = ProxyType(token, serializer, manager=manager, authkey=authkey,
                          incref=incref, pubkey=pubkey)
    except Exception:
        logging.exception('Auto proxy creation failed for %s at %s:',
                          token.typeid, token.address)
        raise
    proxy._isauto = True
    return proxy

def _get_connection(_client, address, authkey):
    """
    Get client connection to `address` using `authkey`.
    Avoids dying on 'Interrupted system call'. (Should be in lower layer)
    """
    address = tunnel_address(address)
    for retry in range(3):
        try:
            conn = _client(address, authkey=authkey)
        except IOError as exc:
            if exc.errno != 4 or retry >= 2:
                raise
        except Exception:
            raise
        else:
            return conn

    raise RuntimeError('Too many connection attempts')

redpajama_set_name: RedPajamaGithub


text:
The 2021 European Pairs Speedway Championship was the 18th edition of the European Pairs Speedway Championship. the final was held in Mâcon, France on 24 July.

The title was won by France for the first time.

Final

See also
 2021 Speedway European Championship

References

2021
European Championship Pairs
Speedway European Championship
European Pairs Speedway
European Pairs Speedway Championship


text:
Sound Of The Hound
careful, he nips a bit
Daly, Kevin (1942 – 1989) Decca engineer, Producer and Record Company Executive.
Derbyshire, Delia 1937 – 2001
Gaisberg, Fred (1873 – 1951)
Nichols, Roger (1944-2011) Steely Dan's recording man
Rushent, Martin (1948 to 2011)
Sir John Read (1918 – April 4 2015) chairman of EMI
Sterling, Louis (1879-1958)
Wallace, Roy Decca Engineer (1927-2007)
Wallich Isabella (1917 – 2001) Niece of Fred Gaisberg
Engineers & Producers
Fred Gaisberg's progress
HMV 363 Oxford Street
J. Hollier's Phonograph & Record Supply, Bristol, England 1909
Jazz Record Mart, 27 East Illinois, Chicago
Now that's what I call a record shop. Amoeba Music on Sunset Boulevard, Hollywood.
Probe Records, The Culture Bunker
Spillers Records: the oldest record shop in the world?
1. Recording studio logos
Herne Place Studios
The Townhouse Studios Cutting Department
Abbey Road Studio 3 circa 1973 where Pink Floyd recorded Dark Side of the Moon
Bob Dylan (again) at The Power Plant in the 1980's
Bob Dylan in Columbia Records Studio August 1963, making The Times They Are A Changing
Elvis Presley. Sun Studios. February 5th 1955
Joe Meek working in his studio at 304 Holloway Road, London circa 1961
Olympic Studios, London, 2008. U2 are the final artists in Studio 1 before Olympic Studios close.
Sometimes a recording is perfect
The Rolling Stones in Olympic Studios 1968
When the last recording studio goes, what will go with it? From Word Magazine March 2010
Trident Studios Control Rooms late 1970's
Tag Archives: british electrical foundation
"No place for a woman in a recording studio". Delia Derbyshire denied by Decca invents (soundtrack to) time travel.
Posted on May 30, 2011 by Nipper
There are not that many prominent women in the history of recorded sound. Indeed there are not that many women working in recording studios even today. Boffins and creatives have tended to have the odd Y chromosone or two. The recording studio can be like a gang hut. A step from Lord of the Flies in one direction and a hop and a skip from a soldering iron in the other. Not a place for a lady then….at least that was what the head of Decca Recording Studios in London thought in the late 1950's. When recording enthusiast Delia Derbyshire applied for a job, she was told unequivocably that Decca did not employ women in their recording studios. (An executive from Decca Records would also famously turn down The Beatles a couple of years later as they thought guitar bands were on the way out…..)
Like The Beatles, Delia was not one to be put off easily. She landed herself a job at the BBC Radiophonic Workshop in 1962 and went on to create some of the most experimental music of the 1960's and in doing so turned the recording studio itself into a star. The workshop is best known for having created the most famous theme music on British TV, Doctor Who. But there was way more to its story and that of Delia Derbyshire, one of its central characters.
In 1966, she founded a music entity/pop group called Unit Delta Plus with fellow Radiophonic Workshop member Brian Hodgson and EMS founder Peter Zinovieff. This organisation pre-dated the British Electrical Foundation by 15 years and Kraftwerk by 4 years and was a vehicle to create and promote electronic music. They played at The Million Volt Light and Sound Rave at which The Beatles' "Carnival of Light" had its only public performance in 1967. Delia also helped set up the Kaleidophon studio in Camden Town with Hodson and fellow electronic musician David Vorhaus. The studio produced electronic music for various London theatres and, in 1968, the three founders made an album as the band White Noise.
Here is part one of an excellent radio documentary about Delia with appropriate images (you can find the other parts on youtube)
And here is a fascinating snippet of Delia playing the tape machines:
And finally here is Electric Storm by White Noise.
Posted in 1962, HISTORY OF RECORDED MUSIC, PEOPLE, RECORDING EQUIPMENT, recording legends, synthesisers	| Tagged 1962, 1967, 1968, bbc, bbc radiophonic workshop, brian hodgson, british electrical foundation, camden, david vorhaus, decca, decca recording studios, delia derbyshire, doctor who, electric storm, ems, kaleidophon studio, kraftwerk, peter zinovieff, the beatles, the million volt light and sound rave, unit delta plu, white noise	| Leave a reply
Welcome to The Sound Of The Hound
This dog blog is dedicated to the history of recorded music. We are specifically interested in the fine work of the EMI Group Archive Trust but we want to look wider at how the sound got on the rounds and all the widgets that made the digits.
Add your bark to The Sound of the Hound
We're on Facebook.
And we are all of a Twitter!
tags!
alfred clark
brian oakley
christopher proudfoot
Columbia Graphophone Company
eldridge johnson
EMI Archive
emi archive trust
emi group archive trust
emile berliner
fred gaisberg
harry lauder
Mystery object
nellie melba
ogilvie mitchell
roger neill
russell hunting
setting up a record company
the columbia phonograph company
the gramophone company
the talking machine industry
tony locantro
united states gramophone company
victor talking machine company
william barry owen
william sinkler darby
Topics!
HISTORY OF RECORDED MUSIC (145)
MEDIA ABOUT RECORDED MUSIC (11)
recording legends (45)
Record Shops (4)
RECORDING EQUIPMENT (41)
gramophones (21)
phonographs (9)
synthesisers (5)
early recordings (33)
great recordings (17)
making a recording (16)
Podcasts soundofthehound.com/2020/01/19/pod… 8 hours ago
Actual record taken on the front line, France, near Lille, November 1918 soundofthehound.com/2018/11/09/act… 1 year ago
A Personal History of the British Records Business #16 part 1 soundofthehound.com/2017/08/23/a-p… https://t.co/LEmNxpk8Si 2 years ago
Inventor of Stereo Sound Alan Dower Blumlein to be Honoured with Posthumous Grammy® soundofthehound.com/2017/02/27/inv… https://t.co/sAHhsAHwQR 2 years ago
Mystery Object of the week #13 Answer soundofthehound.com/2016/12/14/mys… https://t.co/RocRXqIXHR 3 years ago
City of London Phonograph and Gramophone Society
Delia Derbyshire
Historic Masters
Johnson Victrola Museum
Music Preserved
Shorpy's Vintage Photographs
The official site of EMI Group Archive Trust
The Rocking Vicar
The Sound Archive at the British Library
George Martin on Abbey Road Studios
"...one can sense the presence of the great engineers and producers of the past, long since gone. Names which may mean little to the average man, but great people such as Arthur Clarke, Dougie Larter, Bob Beckett, Charlie Anderson, Walter Legge, Charlie Thomas and my dear own mentor, Oscar Preuss, who taught me so much. These men flew the record industry in open cockpits by the seat of their pants, and paved the way for the modern, jetstream, computerised machine that today's young talents have to guide."


NEW YORK (CelebrityAccess MediaWire) — The winners of the 2006 Billboard Touring Awards at the Roosevelt Hotel in New York City on November 9 were based on actual box office figures reported to Billboard Boxscore from December 1, 2005–September 30, 2006. The Rolling Stones' A Bigger Bang tour was recognized as the Top Tour based on gross dollars, and Top Draw based on ticket sales. The tour grossed nearly $230 million for the period that the awards cover and drew nearly 2 million fans to shows all over the world.
Madonna was a finalist in four categories and won in two: Top Boxscore Award for her $22 million, eight-sellout stand at London's Wembley Arena on her Confessions tour while her management team of Guy Oseary and Angela Becker picked up the Top Manager award.
Nickelback won the Breakthrough Act award, given to a band still in its first decade of touring that breaks the Billboard top 25 tours for the first time. Kenny Chesney (with Dierks Bentley and others) received the Top Package nod for the second consecutive year. In addition, Billboard's two new awards, Top Comedy Tour and Creative Content, went to Larry the Cable Guy and Cirque Du Soleil's Delirium, respectively.


text:
Home Venues Archives Walker Art Gallery Archive Look11: Walker – Like You've Never Been Away
Venues Archives
Walker Art Gallery Archive
Look11: Walker – Like You've Never Been Away
13 May – 25 September 2011. 'Like you've never been away' Paul Trevor photo exhibition of 1970s Liverpool at the Walker Art Gallery.
A moving exhibition featuring 60 photographs of children playing on the streets of 1970s Liverpool.
Paul Trevor came to the city in 1975 initially as part of a project called "Survival Programmes" which documented inner city deprivation. The young photographer spent several months recording family life across Liverpool on the fringes of the city centre.
Among the terraced streets and high rise flats, Paul captured vibrant images which portrayed a community defiant and in high spirits despite a backdrop of unemployment and poverty.
He said: "The time I spent in Liverpool in 1975 was special for me. My street photography was a spontaneous approach to capturing life as it was lived.
"Despite initially worrying whether I would be accepted into the community, people were very friendly and happy to be photographed. Britain's inner cities were difficult places to live in during that era. Opportunities to progress in life were limited. There simply were not the jobs for people. Life was hard.
"But it was not all doom and gloom. I found people who were good humoured, cheerful and full of energy."
Like you've never been away forms part of Look11 – Liverpool International Photography Festival. Launched in May, this is the first photography festival to be held in the city.
Annie Lord, National Museums Liverpool, head of Museum Exhibitions, said: "Paul Trevor's work in Liverpool in the 1970s was remarkable. The black and white images give us a real glimpse of family life in the city during that era.
"We are absolutely thrilled about exhibiting Paul's images at the Walker Art Gallery. This will be an extremely warm and moving exhibition about childhood, life and Liverpool."
Paul Trevor re-visited the Everton and Granby areas of Liverpool last summer (August 2010) in a bid to track down some of the youngsters he photographed nearly four decades earlier.
As he was leaving the Everton Community Centre a resident recognised him immediately and said: "Paul, it's like you've never been away" – which has inspired the title of the exhibition.
Paul has been successful in contacting many of the faces in the photographs. The children are now in their 40s with families of their own. Unfortunately he has found some sad stories too. A youngster who features on the lead image for the exhibition, died in his 20s through an overdose.
Paul said: "I was really sad to hear that this particular youngster had died young. I was looking forward to hearing about what he was doing with this life now."
In the long term Paul wants to make new pictures of the people who appeared in his photographs and hear from them about their lives since they last met.
He added: "The image freezes the moment but life goes on. And I'm keen to make fresh photographs of those kids as adults wherever they are today."
More details about Like you've never been away: photographs by Paul Trevor can be found at: http://www.liverpoolmuseums.org.uk/paultrevor/
www.look2011.co.uk
Image: Alley Kids – Paul Trevor
look11
Previous articleLook11: Two Exhibitions at University VGM
Next articleLook11: Behind Closed Doors at St Luke's
Walker Art Gallery: Pre-Raphaelites: Beauty and Rebellion
Walker Art Gallery: Display – "Inspired by Liverpool's Past"
Walker Art Gallery: Pug Virus
Walker Art Gallery: Picasso On Paper
Walker Art Gallery: REALITY: Modern and Contemporary British Painting
Walker Art Gallery: Only in England exhibition tour
Walker Art Gallery- David Jacques: The Irlam House Bequest
Walker – George Always
Walker – Art in Revolution: Liverpool 1911
The Walker: Art as Autobiography: The early work of David Hockney
The Walker: In Seven Days, by Nicola Green
Walker Art Gallery: Art as Autobiography


We understand that the average person spends up to 90% of their life indoors. According to the Environmental Protection Agency, 72% of the total chemical exposure experienced in a lifetime comes from indoor sources. Products that make up a building's construction can be sources of that exposure.
We believe it is in the best interest of public welfare and the environment to eliminate and reduce negative impacts associated with building materials. That's why we are proud to be the first US company to provide a formaldehyde-free bio-based binder for all of our insulation products.
Our number one priority is to provide products that conserve energy and preserve natural resources for a sustainable future.
Throughout all the life cycle stages, we are committed to making our products greener and more sustainable. Below you'll find some of the things we do to fulfill this commitment.
Our plants use 60 – 80% recycled content – which translates to about 10 railcars of recycled glass cullet a day. By leveraging so much recycled content, we reduce the energy required to form glass fibers by 20%. If we use even 60% recycled content, then mining impacts are reduced proportionately.
Manson and Knauf's bio-based ECOSE Technology is derived from corn. On average, the Knauf Family Farm produces one half the amount of corn we use to make our products on an annual basis, which is equal to 5,000 acres. While we don't grow the corn used in our products, the use of corn has a significant carbon sequestration impact on our processes. For instance, the use of corn actually offsets the carbon impact of some of the ancillary facers used on our products.
In 2008, Manson and Knauf Insulation launched perhaps the nation's largest formaldehyde-free green chemistry initiative called ECOSE Technology. Offering this into the building materials marketplace quickly transformed the entire glass mineral fiber industry toward bio-based chemistries. Today phenol-formaldehyde (PF) based resins are largely a thing of the past with regard to large volume mineral fiber based insulation products. Manson and Knauf have also launched a new business venture to assist other industries in accessing ECOSE Technology for their processes.
In a given year, using corn-based ECOSE Technology instead of phenol & formaldehyde avoids the equivalent of more than 100,000 barrels of oil in North America alone.
Following the launch of our ECOSE Technology in 2009, we had transformed all of our products and processes to this new technology. Using our bio-based ECOSE Technology has removed phenol and formaldehyde from our stack emissions. By 2012, the entire industry had followed our lead. This initiative not only established Manson and Knauf Insulation in a leadership position, but it had a transformative impact on our industry in general.
1. Regenerative thermal oxidizers Manson and Knauf Insulation use regenerative thermal oxidizers (RTO) to capture and recycle much of the energy we used to cure our products. RTO is equipment used for the treatment of exhaust air. Our ovens exhaust into a ceramic heat exchange media to capture and reuse the heat in the exhausted air. Therefore, the amount of energy required to cure our product is reduced substantially.
2. Recycling As you can see below, everything we do starts with recycling. Our plant uses as much as 80% recycled content. While our only option is to landfill our products at end of life, that doesn't stop us from encouraging consumers to recycle other products, particularly glass bottles.
Continuous improvement is key to our sustainable development. Globally, we maintain the following Bureau Veritas certifications: ISO 9000, 14000, and 50001. These certifications relate to quality management systems, energy management and environmental management efforts. For more information on our current continuous improvement efforts, please review our global sustainability report.
In the past, a label regarding the carcinogenic potential of insulation made from glass fibers was required on all packaging. Following forty years of research, glass mineral wool has been exonerated entirely. Glass mineral wool is comprised of fibers that are biosoluble, meaning that the fibers dissolve in the body in a short period of time and exit the body with normal bodily functions. The scrutiny glass mineral wool has undergone is now seen as proof of its safety.
the Red List. Manson Insulation has chosen the Health Product Declaration® (HPD) Collaborative as its standard for reporting building product content and associated health information.
EUCEB tested Glass fiber is perhaps the most widely studied building material available today. All of our processes and formulations are voluntarily third-party audited for compliance with the health and safety exoneration criteria for glass and rock based fiber through the European Certification Board for Mineral Wool Products (EUCEB) exoneration process. This guarantees the formulations are biosoluble and pose no health concerns. Having 35 years of research behind its safety, perhaps no other building material has been as thoroughly evaluated as fiberglass products. We believe a safe product is one that has been thoroughly evaluated.
Our products offer a vast array of potential credits for major green building rating systems, including: WELL, LEED v4, International Green Construction Code, Green Guide for Heath Care, NAHB Green Building Standard and more.
Visit the green building rating systems page to see all the credits you can earn using Manson and Knauf Insulation products.
Manson and Knauf are recycling advocates. We take every opportunity to advocate for recycling and financially support the Glass Recycling Coalition (GRC). We feel that a comprehensive understanding of the benefits of recycling will lead to greater recycling adoption and more promotion by state and local governments. While our only option is to landfill our products at end of life, that doesn't stop us from encouraging consumers to recycle other products, particularly glass bottles.
Environment PCR and ISO 14025.