text:
""" A wrapper for the 'gpg' command::

Portions of this module are derived from A.M. Kuchling's well-designed
GPG.py, using Richard Jones' updated version 1.3, which can be found
in the pycrypto CVS repository on Sourceforge:

http://pycrypto.cvs.sourceforge.net/viewvc/pycrypto/gpg/GPG.py

This module is *not* forward-compatible with amk's; some of the
old interface has changed.  For instance, since I've added decrypt
functionality, I elected to initialize with a 'gnupghome' argument
instead of 'keyring', so that gpg can find both the public and secret
keyrings.  I've also altered some of the returned objects in order for
the caller to not have to know as much about the internals of the
result classes.

While the rest of ISconf is released under the GPL, I am releasing
this single file under the same terms that A.M. Kuchling used for
pycrypto.

Steve Traugott, stevegt@terraluna.org
Thu Jun 23 21:27:20 PDT 2005

This version of the module has been modified from Steve Traugott's version
(see http://trac.t7a.org/isconf/browser/trunk/lib/python/isconf/GPG.py) by
Vinay Sajip to make use of the subprocess module (Steve's version uses os.fork()
and so does not work on Windows). Renamed to gnupg.py to avoid confusion with
the previous versions.

Modifications Copyright (C) 2008-2017 Vinay Sajip. All rights reserved.

A unittest harness (test_gnupg.py) has also been added.
"""

__version__ = "0.4.1"
__author__ = "Vinay Sajip"
__date__  = "$07-Jul-2017 15:09:20$"

try:
    from io import StringIO
except ImportError:  # pragma: no cover
    from cStringIO import StringIO

import codecs
import locale
import logging
import os
import re
import socket
from subprocess import Popen
from subprocess import PIPE
import sys
import threading

STARTUPINFO = None
if os.name == 'nt':  # pragma: no cover
    try:
        from subprocess import STARTUPINFO, STARTF_USESHOWWINDOW, SW_HIDE
    except ImportError:
        STARTUPINFO = None

try:
    import logging.NullHandler as NullHandler
except ImportError:
    class NullHandler(logging.Handler):
        def handle(self, record):
            pass
try:
    unicode
    _py3k = False
    string_types = basestring
    text_type = unicode
except NameError:
    _py3k = True
    string_types = str
    text_type = str

logger = logging.getLogger(__name__)
if not logger.handlers:
    logger.addHandler(NullHandler())

# We use the test below because it works for Jython as well as CPython
if os.path.__name__ == 'ntpath':  # pragma: no cover
    # On Windows, we don't need shell quoting, other than worrying about
    # paths with spaces in them.
    def shell_quote(s):
        return '"%s"' % s
else:
    # Section copied from sarge

    # This regex determines which shell input needs quoting
    # because it may be unsafe
    UNSAFE = re.compile(r'[^\w%+,./:=@-]')

    def shell_quote(s):
        """
        Quote text so that it is safe for Posix command shells.

        For example, "*.py" would be converted to "'*.py'". If the text is
        considered safe it is returned unquoted.

        :param s: The value to quote
        :type s: str (or unicode on 2.x)
        :return: A safe version of the input, from the point of view of Posix
                 command shells
        :rtype: The passed-in type
        """
        if not isinstance(s, string_types):  # pragma: no cover
            raise TypeError('Expected string type, got %s' % type(s))
        if not s:
            result = "''"
        elif not UNSAFE.search(s):
            result = s
        else:
            result = "'%s'" % s.replace("'", r"'\''")
        return result

    # end of sarge code

# Now that we use shell=False, we shouldn't need to quote arguments.
# Use no_quote instead of shell_quote to remind us of where quoting
# was needed. However, note that we still need, on 2.x, to encode any
# Unicode argument with the file system encoding - see Issue #41 and
# Python issue #1759845 ("subprocess.call fails with unicode strings in
# command line").

# Allows the encoding used to be overridden in special cases by setting
# this module attribute appropriately.
fsencoding = sys.getfilesystemencoding()

def no_quote(s):
    if not _py3k and isinstance(s, text_type):
        s = s.encode(fsencoding)
    return s

def _copy_data(instream, outstream):
    # Copy one stream to another
    sent = 0
    if hasattr(sys.stdin, 'encoding'):
        enc = sys.stdin.encoding
    else:  # pragma: no cover
        enc = 'ascii'
    while True:
        # See issue #39: read can fail when e.g. a text stream is provided
        # for what is actually a binary file
        try:
            data = instream.read(1024)
        except UnicodeError:
            logger.warning('Exception occurred while reading', exc_info=1)
            break
        if not data:
            break
        sent += len(data)
        # logger.debug("sending chunk (%d): %r", sent, data[:256])
        try:
            outstream.write(data)
        except UnicodeError:  # pragma: no cover
            outstream.write(data.encode(enc))
        except:
            # Can sometimes get 'broken pipe' errors even when the data has all
            # been sent
            logger.exception('Error sending data')
            break
    try:
        outstream.close()
    except IOError:  # pragma: no cover
        logger.warning('Exception occurred while closing: ignored', exc_info=1)
    logger.debug("closed output, %d bytes sent", sent)

def _threaded_copy_data(instream, outstream):
    wr = threading.Thread(target=_copy_data, args=(instream, outstream))
    wr.setDaemon(True)
    logger.debug('data copier: %r, %r, %r', wr, instream, outstream)
    wr.start()
    return wr

def _write_passphrase(stream, passphrase, encoding):
    passphrase = '%s\n' % passphrase
    passphrase = passphrase.encode(encoding)
    stream.write(passphrase)
    logger.debug('Wrote passphrase')

def _is_sequence(instance):
    return isinstance(instance, (list, tuple, set, frozenset))

def _make_memory_stream(s):
    try:
        from io import BytesIO
        rv = BytesIO(s)
    except ImportError:  # pragma: no cover
        rv = StringIO(s)
    return rv

def _make_binary_stream(s, encoding):
    if _py3k:
        if isinstance(s, str):
            s = s.encode(encoding)
    else:
        if type(s) is not str:
            s = s.encode(encoding)
    return _make_memory_stream(s)

class Verify(object):
    "Handle status messages for --verify"

    TRUST_UNDEFINED = 0
    TRUST_NEVER = 1
    TRUST_MARGINAL = 2
    TRUST_FULLY = 3
    TRUST_ULTIMATE = 4

    TRUST_LEVELS = {
        "TRUST_UNDEFINED" : TRUST_UNDEFINED,
        "TRUST_NEVER" : TRUST_NEVER,
        "TRUST_MARGINAL" : TRUST_MARGINAL,
        "TRUST_FULLY" : TRUST_FULLY,
        "TRUST_ULTIMATE" : TRUST_ULTIMATE,
    }

    def __init__(self, gpg):
        self.gpg = gpg
        self.valid = False
        self.fingerprint = self.creation_date = self.timestamp = None
        self.signature_id = self.key_id = None
        self.username = None
        self.key_status = None
        self.status = None
        self.pubkey_fingerprint = None
        self.expire_timestamp = None
        self.sig_timestamp = None
        self.trust_text = None
        self.trust_level = None

    def __nonzero__(self):
        return self.valid

    __bool__ = __nonzero__

    def handle_status(self, key, value):
        if key in self.TRUST_LEVELS:
            self.trust_text = key
            self.trust_level = self.TRUST_LEVELS[key]
        elif key in ("WARNING", "ERROR"):
            logger.warning('potential problem: %s: %s', key, value)
        elif key == "BADSIG":  # pragma: no cover
            self.valid = False
            self.status = 'signature bad'
            self.key_id, self.username = value.split(None, 1)
        elif key == "ERRSIG":  # pragma: no cover
            self.valid = False
            (self.key_id,
             algo, hash_algo,
             cls,
             self.timestamp) = value.split()[:5]
            self.status = 'signature error'
        elif key == "EXPSIG":  # pragma: no cover
            self.valid = False
            self.status = 'signature expired'
            self.key_id, self.username = value.split(None, 1)
        elif key == "GOODSIG":
            self.valid = True
            self.status = 'signature good'
            self.key_id, self.username = value.split(None, 1)
        elif key == "VALIDSIG":
            (self.fingerprint,
             self.creation_date,
             self.sig_timestamp,
             self.expire_timestamp) = value.split()[:4]
            # may be different if signature is made with a subkey
            self.pubkey_fingerprint = value.split()[-1]
            self.status = 'signature valid'
        elif key == "SIG_ID":
            (self.signature_id,
             self.creation_date, self.timestamp) = value.split()
        elif key == "DECRYPTION_FAILED":  # pragma: no cover
            self.valid = False
            self.key_id = value
            self.status = 'decryption failed'
        elif key == "NO_PUBKEY":  # pragma: no cover
            self.valid = False
            self.key_id = value
            self.status = 'no public key'
        elif key in ("EXPKEYSIG", "REVKEYSIG"):  # pragma: no cover
            # signed with expired or revoked key
            self.valid = False
            self.key_id = value.split()[0]
            if key == "EXPKEYSIG":
                self.key_status = 'signing key has expired'
            else:
                self.key_status = 'signing key was revoked'
            self.status = self.key_status
        elif key in ("UNEXPECTED", "FAILURE"):  # pragma: no cover
            self.valid = False
            self.key_id = value
            if key == "UNEXPECTED":
                self.status = 'unexpected data'
            else:
                # N.B. there might be other reasons
                if not self.status:
                    self.status = 'incorrect passphrase'
        elif key in ("DECRYPTION_INFO", "PLAINTEXT", "PLAINTEXT_LENGTH",
                     "NO_SECKEY", "BEGIN_SIGNING"):
            pass
        else:  # pragma: no cover
            logger.debug('message ignored: %s, %s', key, value)

class ImportResult(object):
    "Handle status messages for --import"

    counts = '''count no_user_id imported imported_rsa unchanged
            n_uids n_subk n_sigs n_revoc sec_read sec_imported
            sec_dups not_imported'''.split()
    def __init__(self, gpg):
        self.gpg = gpg
        self.imported = []
        self.results = []
        self.fingerprints = []
        for result in self.counts:
            setattr(self, result, None)

    def __nonzero__(self):
        if self.not_imported: return False
        if not self.fingerprints: return False
        return True

    __bool__ = __nonzero__

    ok_reason = {
        '0': 'Not actually changed',
        '1': 'Entirely new key',
        '2': 'New user IDs',
        '4': 'New signatures',
        '8': 'New subkeys',
        '16': 'Contains private key',
    }

    problem_reason = {
        '0': 'No specific reason given',
        '1': 'Invalid Certificate',
        '2': 'Issuer Certificate missing',
        '3': 'Certificate Chain too long',
        '4': 'Error storing certificate',
    }

    def handle_status(self, key, value):
        if key in ("WARNING", "ERROR"):
            logger.warning('potential problem: %s: %s', key, value)
        elif key in ("IMPORTED", "KEY_CONSIDERED"):
            # this duplicates info we already see in import_ok & import_problem
            pass
        elif key == "NODATA":  # pragma: no cover
            self.results.append({'fingerprint': None,
                'problem': '0', 'text': 'No valid data found'})
        elif key == "IMPORT_OK":
            reason, fingerprint = value.split()
            reasons = []
            for code, text in list(self.ok_reason.items()):
                if int(reason) | int(code) == int(reason):
                    reasons.append(text)
            reasontext = '\n'.join(reasons) + "\n"
            self.results.append({'fingerprint': fingerprint,
                'ok': reason, 'text': reasontext})
            self.fingerprints.append(fingerprint)
        elif key == "IMPORT_PROBLEM":  # pragma: no cover
            try:
                reason, fingerprint = value.split()
            except:
                reason = value
                fingerprint = '<unknown>'
            self.results.append({'fingerprint': fingerprint,
                'problem': reason, 'text': self.problem_reason[reason]})
        elif key == "IMPORT_RES":
            import_res = value.split()
            for i, count in enumerate(self.counts):
                setattr(self, count, int(import_res[i]))
        elif key == "KEYEXPIRED":  # pragma: no cover
            self.results.append({'fingerprint': None,
                'problem': '0', 'text': 'Key expired'})
        elif key == "SIGEXPIRED":  # pragma: no cover
            self.results.append({'fingerprint': None,
                'problem': '0', 'text': 'Signature expired'})
        elif key == "FAILURE":  # pragma: no cover
            self.results.append({'fingerprint': None,
                'problem': '0', 'text': 'Other failure'})
        else:  # pragma: no cover
            logger.debug('message ignored: %s, %s', key, value)

    def summary(self):
        l = []
        l.append('%d imported' % self.imported)
        if self.not_imported:  # pragma: no cover
            l.append('%d not imported' % self.not_imported)
        return ', '.join(l)

ESCAPE_PATTERN = re.compile(r'\\x([0-9a-f][0-9a-f])', re.I)
BASIC_ESCAPES = {
    r'\n': '\n',
    r'\r': '\r',
    r'\f': '\f',
    r'\v': '\v',
    r'\b': '\b',
    r'\0': '\0',
}

class SendResult(object):
    def __init__(self, gpg):
        self.gpg = gpg

    def handle_status(self, key, value):
        logger.debug('SendResult: %s: %s', key, value)

class SearchKeys(list):
    ''' Handle status messages for --search-keys.

        Handle pub and uid (relating the latter to the former).

        Don't care about the rest
    '''

    UID_INDEX = 1
    FIELDS = 'type keyid algo length date expires'.split()

    def __init__(self, gpg):
        self.gpg = gpg
        self.curkey = None
        self.fingerprints = []
        self.uids = []

    def get_fields(self, args):
        result = {}
        for i, var in enumerate(self.FIELDS):
            if i < len(args):
                result[var] = args[i]
            else:
                result[var] = 'unavailable'
        result['uids'] = []
        result['sigs'] = []
        return result

    def pub(self, args):
        self.curkey = curkey = self.get_fields(args)
        self.append(curkey)

    def uid(self, args):
        uid = args[self.UID_INDEX]
        uid = ESCAPE_PATTERN.sub(lambda m: chr(int(m.group(1), 16)), uid)
        for k, v in BASIC_ESCAPES.items():
            uid = uid.replace(k, v)
        self.curkey['uids'].append(uid)
        self.uids.append(uid)

    def handle_status(self, key, value):  # pragma: no cover
        pass

class ListKeys(SearchKeys):
    ''' Handle status messages for --list-keys, --list-sigs.

        Handle pub and uid (relating the latter to the former).

        Don't care about (info from src/DETAILS):

        crt = X.509 certificate
        crs = X.509 certificate and private key available
        uat = user attribute (same as user id except for field 10).
        sig = signature
        rev = revocation signature
        pkd = public key data (special field format, see below)
        grp = reserved for gpgsm
        rvk = revocation key
    '''

    UID_INDEX = 9
    FIELDS = 'type trust length algo keyid date expires dummy ownertrust uid sig'.split()

    def __init__(self, gpg):
        super(ListKeys, self).__init__(gpg)
        self.in_subkey = False
        self.key_map = {}

    def key(self, args):
        self.curkey = curkey = self.get_fields(args)
        if curkey['uid']:
            curkey['uids'].append(curkey['uid'])
        del curkey['uid']
        curkey['subkeys'] = []
        self.append(curkey)
        self.in_subkey = False

    pub = sec = key

    def fpr(self, args):
        fp = args[9]
        if fp in self.key_map:  # pragma: no cover
            raise ValueError('Unexpected fingerprint collision: %s' % fp)
        if not self.in_subkey:
            self.curkey['fingerprint'] = fp
            self.fingerprints.append(fp)
            self.key_map[fp] = self.curkey
        else:
            self.curkey['subkeys'][-1].append(fp)
            self.key_map[fp] = self.curkey

    def sub(self, args):
        subkey = [args[4], args[11]]    # keyid, type
        self.curkey['subkeys'].append(subkey)
        self.in_subkey = True

    def ssb(self, args):
        subkey = [args[4], None]    # keyid, type
        self.curkey['subkeys'].append(subkey)
        self.in_subkey = True

    def sig(self, args):
        # keyid, uid, sigclass
        self.curkey['sigs'].append((args[4], args[9], args[10]))

class ScanKeys(ListKeys):
    ''' Handle status messages for --with-fingerprint.'''

    def sub(self, args):
        # --with-fingerprint --with-colons somehow outputs fewer colons,
        # use the last value args[-1] instead of args[11]
        subkey = [args[4], args[-1]]
        self.curkey['subkeys'].append(subkey)
        self.in_subkey = True

class TextHandler(object):
    def _as_text(self):
        return self.data.decode(self.gpg.encoding, self.gpg.decode_errors)

    if _py3k:
        __str__ = _as_text
    else:
        __unicode__ = _as_text

        def __str__(self):
            return self.data

class Crypt(Verify, TextHandler):
    "Handle status messages for --encrypt and --decrypt"
    def __init__(self, gpg):
        Verify.__init__(self, gpg)
        self.data = ''
        self.ok = False
        self.status = ''

    def __nonzero__(self):
        if self.ok: return True
        return False

    __bool__ = __nonzero__

    def handle_status(self, key, value):
        if key in ("WARNING", "ERROR"):
            logger.warning('potential problem: %s: %s', key, value)
        elif key == "NODATA":
            self.status = "no data was provided"
        elif key in ("NEED_PASSPHRASE", "BAD_PASSPHRASE", "GOOD_PASSPHRASE",
                     "MISSING_PASSPHRASE", "DECRYPTION_FAILED",
                     "KEY_NOT_CREATED", "NEED_PASSPHRASE_PIN"):
            self.status = key.replace("_", " ").lower()
        elif key == "NEED_PASSPHRASE_SYM":
            self.status = 'need symmetric passphrase'
        elif key == "BEGIN_DECRYPTION":
            self.status = 'decryption incomplete'
        elif key == "BEGIN_ENCRYPTION":
            self.status = 'encryption incomplete'
        elif key == "DECRYPTION_OKAY":
            self.status = 'decryption ok'
            self.ok = True
        elif key == "END_ENCRYPTION":
            self.status = 'encryption ok'
            self.ok = True
        elif key == "INV_RECP":  # pragma: no cover
            self.status = 'invalid recipient'
        elif key == "KEYEXPIRED":  # pragma: no cover
            self.status = 'key expired'
        elif key == "SIG_CREATED":  # pragma: no cover
            self.status = 'sig created'
        elif key == "SIGEXPIRED":  # pragma: no cover
            self.status = 'sig expired'
        elif key in ("ENC_TO", "USERID_HINT", "GOODMDC",
                     "END_DECRYPTION", "CARDCTRL", "BADMDC",
                     "SC_OP_FAILURE", "SC_OP_SUCCESS",
                     "PINENTRY_LAUNCHED", "KEY_CONSIDERED"):
            pass
        else:
            Verify.handle_status(self, key, value)

class GenKey(object):
    "Handle status messages for --gen-key"
    def __init__(self, gpg):
        self.gpg = gpg
        self.type = None
        self.fingerprint = None

    def __nonzero__(self):
        if self.fingerprint: return True
        return False

    __bool__ = __nonzero__

    def __str__(self):
        return self.fingerprint or ''

    def handle_status(self, key, value):
        if key in ("WARNING", "ERROR"):  # pragma: no cover
            logger.warning('potential problem: %s: %s', key, value)
        elif key == "KEY_CREATED":
            (self.type,self.fingerprint) = value.split()
        elif key in ("PROGRESS", "GOOD_PASSPHRASE", "KEY_NOT_CREATED"):
            pass
        else:  # pragma: no cover
            logger.debug('message ignored: %s, %s', key, value)

class ExportResult(GenKey):
    """Handle status messages for --export[-secret-key].

    For now, just use an existing class to base it on - if needed, we
    can override handle_status for more specific message handling.
    """
    def handle_status(self, key, value):
        if key in ("EXPORTED", "EXPORT_RES"):
            pass
        else:
            super(ExportResult, self).handle_status(key, value)

class DeleteResult(object):
    "Handle status messages for --delete-key and --delete-secret-key"
    def __init__(self, gpg):
        self.gpg = gpg
        self.status = 'ok'

    def __str__(self):
        return self.status

    problem_reason = {
        '1': 'No such key',
        '2': 'Must delete secret key first',
        '3': 'Ambiguous specification',
    }

    def handle_status(self, key, value):
        if key == "DELETE_PROBLEM":  # pragma: no cover
            self.status = self.problem_reason.get(value,
                                                  "Unknown error: %r" % value)
        else:  # pragma: no cover
            logger.debug('message ignored: %s, %s', key, value)

    def __nonzero__(self):
        return self.status == 'ok'

    __bool__ = __nonzero__

class Sign(TextHandler):
    "Handle status messages for --sign"
    def __init__(self, gpg):
        self.gpg = gpg
        self.type = None
        self.hash_algo = None
        self.fingerprint = None
        self.status = None

    def __nonzero__(self):
        return self.fingerprint is not None

    __bool__ = __nonzero__

    def handle_status(self, key, value):
        if key in ("WARNING", "ERROR", "FAILURE"):  # pragma: no cover
            logger.warning('potential problem: %s: %s', key, value)
        elif key in ("KEYEXPIRED", "SIGEXPIRED"):  # pragma: no cover
            self.status = 'key expired'
        elif key == "KEYREVOKED":  # pragma: no cover
            self.status = 'key revoked'
        elif key == "SIG_CREATED":
            (self.type,
             algo, self.hash_algo, cls,
             self.timestamp, self.fingerprint
             ) = value.split()
            self.status = 'signature created'
        elif key in ("USERID_HINT", "NEED_PASSPHRASE", "GOOD_PASSPHRASE",
                     "BAD_PASSPHRASE", "BEGIN_SIGNING"):
            pass
        else:  # pragma: no cover
            logger.debug('message ignored: %s, %s', key, value)

VERSION_RE = re.compile(r'gpg \(GnuPG\) (\d+(\.\d+)*)'.encode('ascii'), re.I)
HEX_DIGITS_RE = re.compile(r'[0-9a-f]+$', re.I)

class GPG(object):

    decode_errors = 'strict'

    result_map = {
        'crypt': Crypt,
        'delete': DeleteResult,
        'generate': GenKey,
        'import': ImportResult,
        'send': SendResult,
        'list': ListKeys,
        'scan': ScanKeys,
        'search': SearchKeys,
        'sign': Sign,
        'verify': Verify,
        'export': ExportResult,
    }

    "Encapsulate access to the gpg executable"
    def __init__(self, gpgbinary='gpg', gnupghome=None, verbose=False,
                 use_agent=False, keyring=None, options=None,
                 secret_keyring=None):
        """Initialize a GPG process wrapper.  Options are:

        gpgbinary -- full pathname for GPG binary.

        gnupghome -- full pathname to where we can find the public and
        private keyrings.  Default is whatever gpg defaults to.
        keyring -- name of alternative keyring file to use, or list of such
        keyrings. If specified, the default keyring is not used.
        options =-- a list of additional options to pass to the GPG binary.
        secret_keyring -- name of alternative secret keyring file to use, or
        list of such keyrings.
        """
        self.gpgbinary = gpgbinary
        self.gnupghome = gnupghome
        if keyring:
            # Allow passing a string or another iterable. Make it uniformly
            # a list of keyring filenames
            if isinstance(keyring, string_types):
                keyring = [keyring]
        self.keyring = keyring
        if secret_keyring:
            # Allow passing a string or another iterable. Make it uniformly
            # a list of keyring filenames
            if isinstance(secret_keyring, string_types):
                secret_keyring = [secret_keyring]
        self.secret_keyring = secret_keyring
        self.verbose = verbose
        self.use_agent = use_agent
        if isinstance(options, str):  # pragma: no cover
            options = [options]
        self.options = options
        self.on_data = None  # or a callable - will be called with data chunks
        # Changed in 0.3.7 to use Latin-1 encoding rather than
        # locale.getpreferredencoding falling back to sys.stdin.encoding
        # falling back to utf-8, because gpg itself uses latin-1 as the default
        # encoding.
        self.encoding = 'latin-1'
        if gnupghome and not os.path.isdir(self.gnupghome):
            os.makedirs(self.gnupghome,0x1C0)
        try:
            p = self._open_subprocess(["--version"])
        except OSError:
            msg = 'Unable to run gpg - it may not be available.'
            logger.exception(msg)
            raise OSError(msg)
        result = self.result_map['verify'](self) # any result will do for this
        self._collect_output(p, result, stdin=p.stdin)
        if p.returncode != 0:  # pragma: no cover
            raise ValueError("Error invoking gpg: %s: %s" % (p.returncode,
                                                             result.stderr))
        m = VERSION_RE.match(result.data)
        if not m:  # pragma: no cover
            self.version = None
        else:
            dot = '.'.encode('ascii')
            self.version = tuple([int(s) for s in m.groups()[0].split(dot)])

    def make_args(self, args, passphrase):
        """
        Make a list of command line elements for GPG. The value of ``args``
        will be appended. The ``passphrase`` argument needs to be True if
        a passphrase will be sent to GPG, else False.
        """
        cmd = [self.gpgbinary, '--status-fd', '2', '--no-tty']
        cmd.extend(['--debug', 'ipc'])
        if passphrase and hasattr(self, 'version'):
            if self.version >= (2, 1):
                cmd[1:1] = ['--pinentry-mode', 'loopback']
        cmd.extend(['--fixed-list-mode', '--batch', '--with-colons'])
        if self.gnupghome:
            cmd.extend(['--homedir',  no_quote(self.gnupghome)])
        if self.keyring:
            cmd.append('--no-default-keyring')
            for fn in self.keyring:
                cmd.extend(['--keyring', no_quote(fn)])
        if self.secret_keyring:
            for fn in self.secret_keyring:
                cmd.extend(['--secret-keyring', no_quote(fn)])
        if passphrase:
            cmd.extend(['--passphrase-fd', '0'])
        if self.use_agent:  # pragma: no cover
            cmd.append('--use-agent')
        if self.options:
            cmd.extend(self.options)
        cmd.extend(args)
        return cmd

    def _open_subprocess(self, args, passphrase=False):
        # Internal method: open a pipe to a GPG subprocess and return
        # the file objects for communicating with it.

        # def debug_print(cmd):
            # result = []
            # for c in cmd:
                # if ' ' not in c:
                    # result.append(c)
                # else:
                    # if '"' not in c:
                        # result.append('"%s"' % c)
                    # elif "'" not in c:
                        # result.append("'%s'" % c)
                    # else:
                        # result.append(c)  # give up
            # return ' '.join(cmd)
        from subprocess import list2cmdline as debug_print

        cmd = self.make_args(args, passphrase)
        if self.verbose:  # pragma: no cover
            print(debug_print(cmd))
        if not STARTUPINFO:
            si = None
        else:  # pragma: no cover
            si = STARTUPINFO()
            si.dwFlags = STARTF_USESHOWWINDOW
            si.wShowWindow = SW_HIDE
        result = Popen(cmd, shell=False, stdin=PIPE, stdout=PIPE, stderr=PIPE,
                       startupinfo=si)
        logger.debug("%s: %s", result.pid, debug_print(cmd))
        return result

    def _read_response(self, stream, result):
        # Internal method: reads all the stderr output from GPG, taking notice
        # only of lines that begin with the magic [GNUPG:] prefix.
        #
        # Calls methods on the response object for each valid token found,
        # with the arg being the remainder of the status line.
        lines = []
        while True:
            line = stream.readline()
            if len(line) == 0:
                break
            lines.append(line)
            line = line.rstrip()
            if self.verbose:  # pragma: no cover
                print(line)
            logger.debug("%s", line)
            if line[0:9] == '[GNUPG:] ':
                # Chop off the prefix
                line = line[9:]
                L = line.split(None, 1)
                keyword = L[0]
                if len(L) > 1:
                    value = L[1]
                else:
                    value = ""
                result.handle_status(keyword, value)
        result.stderr = ''.join(lines)

    def _read_data(self, stream, result, on_data=None):
        # Read the contents of the file from GPG's stdout
        chunks = []
        while True:
            data = stream.read(1024)
            if len(data) == 0:
                break
            logger.debug("chunk: %r" % data[:256])
            chunks.append(data)
            if on_data:
                on_data(data)
        if _py3k:
            # Join using b'' or '', as appropriate
            result.data = type(data)().join(chunks)
        else:
            result.data = ''.join(chunks)

    def _collect_output(self, process, result, writer=None, stdin=None):
        """
        Drain the subprocesses output streams, writing the collected output
        to the result. If a writer thread (writing to the subprocess) is given,
        make sure it's joined before returning. If a stdin stream is given,
        close it before returning.
        """
        stderr = codecs.getreader(self.encoding)(process.stderr)
        rr = threading.Thread(target=self._read_response, args=(stderr, result))
        rr.setDaemon(True)
        logger.debug('stderr reader: %r', rr)
        rr.start()

        stdout = process.stdout
        dr = threading.Thread(target=self._read_data, args=(stdout, result, self.on_data))
        dr.setDaemon(True)
        logger.debug('stdout reader: %r', dr)
        dr.start()

        dr.join()
        rr.join()
        if writer is not None:
            writer.join()
        process.wait()
        if stdin is not None:
            try:
                stdin.close()
            except IOError:  # pragma: no cover
                pass
        stderr.close()
        stdout.close()

    def _handle_io(self, args, fileobj, result, passphrase=None, binary=False):
        "Handle a call to GPG - pass input data, collect output data"
        # Handle a basic data call - pass data to GPG, handle the output
        # including status information. Garbage In, Garbage Out :)
        p = self._open_subprocess(args, passphrase is not None)
        if not binary:  # pragma: no cover
            stdin = codecs.getwriter(self.encoding)(p.stdin)
        else:
            stdin = p.stdin
        if passphrase:
            _write_passphrase(stdin, passphrase, self.encoding)
        writer = _threaded_copy_data(fileobj, stdin)
        self._collect_output(p, result, writer, stdin)
        return result

    #
    # SIGNATURE METHODS
    #
    def sign(self, message, **kwargs):
        """sign message"""
        f = _make_binary_stream(message, self.encoding)
        result = self.sign_file(f, **kwargs)
        f.close()
        return result

    def set_output_without_confirmation(self, args, output):
        "If writing to a file which exists, avoid a confirmation message."
        if os.path.exists(output):
            # We need to avoid an overwrite confirmation message
            args.extend(['--yes'])
        args.extend(['--output', no_quote(output)])

    def sign_file(self, file, keyid=None, passphrase=None, clearsign=True,
                  detach=False, binary=False, output=None, extra_args=None):
        """sign file"""
        logger.debug("sign_file: %s", file)
        if binary:  # pragma: no cover
            args = ['-s']
        else:
            args = ['-sa']
        # You can't specify detach-sign and clearsign together: gpg ignores
        # the detach-sign in that case.
        if detach:
            args.append("--detach-sign")
        elif clearsign:
            args.append("--clearsign")
        if keyid:
            args.extend(['--default-key', no_quote(keyid)])
        if output:  # write the output to a file with the specified name
            self.set_output_without_confirmation(args, output)

        if extra_args:
            args.extend(extra_args)
        result = self.result_map['sign'](self)
        #We could use _handle_io here except for the fact that if the
        #passphrase is bad, gpg bails and you can't write the message.
        p = self._open_subprocess(args, passphrase is not None)
        try:
            stdin = p.stdin
            if passphrase:
                _write_passphrase(stdin, passphrase, self.encoding)
            writer = _threaded_copy_data(file, stdin)
        except IOError:  # pragma: no cover
            logging.exception("error writing message")
            writer = None
        self._collect_output(p, result, writer, stdin)
        return result

    def verify(self, data, **kwargs):
        """Verify the signature on the contents of the string 'data'

        >>> GPGBINARY = os.environ.get('GPGBINARY', 'gpg')
        >>> gpg = GPG(gpgbinary=GPGBINARY, gnupghome="keys")
        >>> input = gpg.gen_key_input(passphrase='foo')
        >>> key = gpg.gen_key(input)
        >>> assert key
        >>> sig = gpg.sign('hello',keyid=key.fingerprint,passphrase='bar')
        >>> assert not sig
        >>> sig = gpg.sign('hello',keyid=key.fingerprint,passphrase='foo')
        >>> assert sig
        >>> verify = gpg.verify(sig.data)
        >>> assert verify

        """
        f = _make_binary_stream(data, self.encoding)
        result = self.verify_file(f, **kwargs)
        f.close()
        return result

    def verify_file(self, file, data_filename=None, close_file=True, extra_args=None):
        "Verify the signature on the contents of the file-like object 'file'"
        logger.debug('verify_file: %r, %r', file, data_filename)
        result = self.result_map['verify'](self)
        args = ['--verify']
        if extra_args:
            args.extend(extra_args)
        if data_filename is None:
            self._handle_io(args, file, result, binary=True)
        else:
            logger.debug('Handling detached verification')
            import tempfile
            fd, fn = tempfile.mkstemp(prefix='pygpg')
            s = file.read()
            if close_file:
                file.close()
            logger.debug('Wrote to temp file: %r', s)
            os.write(fd, s)
            os.close(fd)
            args.append(no_quote(fn))
            args.append(no_quote(data_filename))
            try:
                p = self._open_subprocess(args)
                self._collect_output(p, result, stdin=p.stdin)
            finally:
                os.unlink(fn)
        return result

    def verify_data(self, sig_filename, data, extra_args=None):
        "Verify the signature in sig_filename against data in memory"
        logger.debug('verify_data: %r, %r ...', sig_filename, data[:16])
        result = self.result_map['verify'](self)
        args = ['--verify']
        if extra_args:
            args.extend(extra_args)
        args.extend([no_quote(sig_filename), '-'])
        stream = _make_memory_stream(data)
        self._handle_io(args, stream, result, binary=True)
        return result

    #
    # KEY MANAGEMENT
    #

    def import_keys(self, key_data):
        """
        Import the key_data into our keyring.
        """
        result = self.result_map['import'](self)
        logger.debug('import_keys: %r', key_data[:256])
        data = _make_binary_stream(key_data, self.encoding)
        self._handle_io(['--import'], data, result, binary=True)
        logger.debug('import_keys result: %r', result.__dict__)
        data.close()
        return result

    def recv_keys(self, keyserver, *keyids):
        """Import a key from a keyserver

        >>> import shutil
        >>> shutil.rmtree("keys", ignore_errors=True)
        >>> GPGBINARY = os.environ.get('GPGBINARY', 'gpg')
        >>> gpg = GPG(gpgbinary=GPGBINARY, gnupghome="keys")
        >>> os.chmod('keys', 0x1C0)
        >>> result = gpg.recv_keys('pgp.mit.edu', '92905378')
        >>> assert result

        """
        result = self.result_map['import'](self)
        logger.debug('recv_keys: %r', keyids)
        data = _make_binary_stream("", self.encoding)
        #data = ""
        args = ['--keyserver', no_quote(keyserver), '--recv-keys']
        args.extend([no_quote(k) for k in keyids])
        self._handle_io(args, data, result, binary=True)
        logger.debug('recv_keys result: %r', result.__dict__)
        data.close()
        return result

    def send_keys(self, keyserver, *keyids):
        """Send a key to a keyserver.

        Note: it's not practical to test this function without sending
        arbitrary data to live keyservers.
        """
        result = self.result_map['send'](self)
        logger.debug('send_keys: %r', keyids)
        data = _make_binary_stream('', self.encoding)
        #data = ""
        args = ['--keyserver', no_quote(keyserver), '--send-keys']
        args.extend([no_quote(k) for k in keyids])
        self._handle_io(args, data, result, binary=True)
        logger.debug('send_keys result: %r', result.__dict__)
        data.close()
        return result

    def delete_keys(self, fingerprints, secret=False, passphrase=None):
        which='key'
        if secret:  # pragma: no cover
            if self.version >= (2, 1) and passphrase is None:
                raise ValueError('For GnuPG >= 2.1, deleting secret keys '
                                 'needs a passphrase to be provided')
            which='secret-key'
        if _is_sequence(fingerprints):  # pragma: no cover
            fingerprints = [no_quote(s) for s in fingerprints]
        else:
            fingerprints = [no_quote(fingerprints)]
        args = ['--delete-%s' % which]
        args.extend(fingerprints)
        result = self.result_map['delete'](self)
        if not secret or self.version < (2, 1):
            p = self._open_subprocess(args)
            self._collect_output(p, result, stdin=p.stdin)
        else:
            # Need to send in a passphrase.
            f = _make_binary_stream('', self.encoding)
            try:
                self._handle_io(args, f, result, passphrase=passphrase,
                                binary=True)
            finally:
                f.close()
        return result

    def export_keys(self, keyids, secret=False, armor=True, minimal=False,
                    passphrase=None):
        """
        Export the indicated keys. A 'keyid' is anything gpg accepts.

        Since GnuPG 2.1, you can't export secret keys without providing a
        passphrase.
        """

        which=''
        if secret:
            which='-secret-key'
            if self.version >= (2, 1) and passphrase is None:
                raise ValueError('For GnuPG >= 2.1, exporting secret keys '
                                 'needs a passphrase to be provided')
        if _is_sequence(keyids):
            keyids = [no_quote(k) for k in keyids]
        else:
            keyids = [no_quote(keyids)]
        args = ['--export%s' % which]
        if armor:
            args.append('--armor')
        if minimal:  # pragma: no cover
            args.extend(['--export-options','export-minimal'])
        args.extend(keyids)
        # gpg --export produces no status-fd output; stdout will be
        # empty in case of failure
        #stdout, stderr = p.communicate()
        result = self.result_map['export'](self)
        if not secret or self.version < (2, 1):
            p = self._open_subprocess(args)
            self._collect_output(p, result, stdin=p.stdin)
        else:
            # Need to send in a passphrase.
            f = _make_binary_stream('', self.encoding)
            try:
                self._handle_io(args, f, result, passphrase=passphrase,
                                binary=True)
            finally:
                f.close()
        logger.debug('export_keys result: %r', result.data)
        # Issue #49: Return bytes if armor not specified, else text
        result = result.data
        if armor:
            result = result.decode(self.encoding, self.decode_errors)
        return result

    def _get_list_output(self, p, kind):
        # Get the response information
        result = self.result_map[kind](self)
        self._collect_output(p, result, stdin=p.stdin)
        lines = result.data.decode(self.encoding,
                                   self.decode_errors).splitlines()
        valid_keywords = 'pub uid sec fpr sub ssb sig'.split()
        for line in lines:
            if self.verbose:  # pragma: no cover
                print(line)
            logger.debug("line: %r", line.rstrip())
            if not line:  # pragma: no cover
                break
            L = line.strip().split(':')
            if not L:  # pragma: no cover
                continue
            keyword = L[0]
            if keyword in valid_keywords:
                getattr(result, keyword)(L)
        return result

    def list_keys(self, secret=False, keys=None, sigs=False):
        """ list the keys currently in the keyring

        >>> import shutil
        >>> shutil.rmtree("keys", ignore_errors=True)
        >>> GPGBINARY = os.environ.get('GPGBINARY', 'gpg')
        >>> gpg = GPG(gpgbinary=GPGBINARY, gnupghome="keys")
        >>> input = gpg.gen_key_input(passphrase='foo')
        >>> result = gpg.gen_key(input)
        >>> fp1 = result.fingerprint
        >>> result = gpg.gen_key(input)
        >>> fp2 = result.fingerprint
        >>> pubkeys = gpg.list_keys()
        >>> assert fp1 in pubkeys.fingerprints
        >>> assert fp2 in pubkeys.fingerprints

        """

        if sigs:
            which = 'sigs'
        else:            which='keys'
        if secret:
            which='secret-keys'
        args = ['--list-%s' % which,
                '--fingerprint', '--fingerprint'] # get subkey FPs, too
        if keys:
            if isinstance(keys, string_types):
                keys = [keys]
            args.extend(keys)
        p = self._open_subprocess(args)
        return self._get_list_output(p, 'list')

    def scan_keys(self, filename):
        """
        List details of an ascii armored or binary key file
        without first importing it to the local keyring.

        The function achieves this on modern GnuPG by running:

        $ gpg --dry-run --import-options import-show --import

        On older versions, it does the *much* riskier:

        $ gpg --with-fingerprint --with-colons filename
        """
        if self.version >= (2, 1):
            args = ['--dry-run', '--import-options', 'import-show', '--import']
        else:
            logger.warning('Trying to list packets, but if the file is not a '
                           'keyring, might accidentally decrypt')
            args = ['--with-fingerprint', '--with-colons', '--fixed-list-mode']
        args.append(no_quote(filename))
        p = self._open_subprocess(args)
        return self._get_list_output(p, 'scan')

    def search_keys(self, query, keyserver='pgp.mit.edu'):
        """ search keyserver by query (using --search-keys option)

        >>> import shutil
        >>> shutil.rmtree('keys', ignore_errors=True)
        >>> GPGBINARY = os.environ.get('GPGBINARY', 'gpg')
        >>> gpg = GPG(gpgbinary=GPGBINARY, gnupghome='keys')
        >>> os.chmod('keys', 0x1C0)
        >>> result = gpg.search_keys('<vinay_sajip@hotmail.com>')
        >>> assert result, 'Failed using default keyserver'
        >>> #keyserver = 'keyserver.ubuntu.com'
        >>> #result = gpg.search_keys('<vinay_sajip@hotmail.com>', keyserver)
        >>> #assert result, 'Failed using keyserver.ubuntu.com'

        """
        query = query.strip()
        if HEX_DIGITS_RE.match(query):
            query = '0x' + query
        args = ['--fingerprint',
                '--keyserver', no_quote(keyserver), '--search-keys',
                no_quote(query)]
        p = self._open_subprocess(args)

        # Get the response information
        result = self.result_map['search'](self)
        self._collect_output(p, result, stdin=p.stdin)
        lines = result.data.decode(self.encoding,
                                   self.decode_errors).splitlines()
        valid_keywords = ['pub', 'uid']
        for line in lines:
            if self.verbose:  # pragma: no cover
                print(line)
            logger.debug('line: %r', line.rstrip())
            if not line:    # sometimes get blank lines on Windows
                continue
            L = line.strip().split(':')
            if not L:  # pragma: no cover
                continue
            keyword = L[0]
            if keyword in valid_keywords:
                getattr(result, keyword)(L)
        return result

    def gen_key(self, input):
        """Generate a key; you might use gen_key_input() to create the
        control input.

        >>> GPGBINARY = os.environ.get('GPGBINARY', 'gpg')
        >>> gpg = GPG(gpgbinary=GPGBINARY, gnupghome="keys")
        >>> input = gpg.gen_key_input(passphrase='foo')
        >>> result = gpg.gen_key(input)
        >>> assert result
        >>> result = gpg.gen_key('foo')
        >>> assert not result

        """
        args = ["--gen-key"]
        result = self.result_map['generate'](self)
        f = _make_binary_stream(input, self.encoding)
        self._handle_io(args, f, result, binary=True)
        f.close()
        return result

    def gen_key_input(self, **kwargs):
        """
        Generate --gen-key input per gpg doc/DETAILS
        """
        parms = {}
        for key, val in list(kwargs.items()):
            key = key.replace('_','-').title()
            if str(val).strip():    # skip empty strings
                parms[key] = val
        parms.setdefault('Key-Type','RSA')
        parms.setdefault('Key-Length',2048)
        parms.setdefault('Name-Real', "Autogenerated Key")
        logname = (os.environ.get('LOGNAME') or os.environ.get('USERNAME') or
                   'unspecified')
        hostname = socket.gethostname()
        parms.setdefault('Name-Email', "%s@%s" % (logname.replace(' ', '_'),
                                                  hostname))
        out = "Key-Type: %s\n" % parms.pop('Key-Type')
        for key, val in list(parms.items()):
            out += "%s: %s\n" % (key, val)
        out += "%commit\n"
        return out

        # Key-Type: RSA
        # Key-Length: 1024
        # Name-Real: ISdlink Server on %s
        # Name-Comment: Created by %s
        # Name-Email: isdlink@%s
        # Expire-Date: 0
        # %commit
        #
        #
        # Key-Type: DSA
        # Key-Length: 1024
        # Subkey-Type: ELG-E
        # Subkey-Length: 1024
        # Name-Real: Joe Tester
        # Name-Comment: with stupid passphrase
        # Name-Email: joe@foo.bar
        # Expire-Date: 0
        # Passphrase: abc
        # %pubring foo.pub
        # %secring foo.sec
        # %commit

    #
    # ENCRYPTION
    #
    def encrypt_file(self, file, recipients, sign=None,
            always_trust=False, passphrase=None,
            armor=True, output=None, symmetric=False, extra_args=None):
        "Encrypt the message read from the file-like object 'file'"
        args = ['--encrypt']
        if symmetric:
            # can't be False or None - could be True or a cipher algo value
            # such as AES256
            args = ['--symmetric']
            if symmetric is not True:
                args.extend(['--cipher-algo', no_quote(symmetric)])
            # else use the default, currently CAST5
        else:
            if not recipients:
                raise ValueError('No recipients specified with asymmetric '
                                 'encryption')
            if not _is_sequence(recipients):
                recipients = (recipients,)
            for recipient in recipients:
                args.extend(['--recipient', no_quote(recipient)])
        if armor:   # create ascii-armored output - False for binary output
            args.append('--armor')
        if output:  # write the output to a file with the specified name
            self.set_output_without_confirmation(args, output)
        if sign is True:  # pragma: no cover
            args.append('--sign')
        elif sign:  # pragma: no cover
            args.extend(['--sign', '--default-key', no_quote(sign)])
        if always_trust:  # pragma: no cover
            args.append('--always-trust')
        if extra_args:
            args.extend(extra_args)
        result = self.result_map['crypt'](self)
        self._handle_io(args, file, result, passphrase=passphrase, binary=True)
        logger.debug('encrypt result: %r', result.data)
        return result

    def encrypt(self, data, recipients, **kwargs):
        """Encrypt the message contained in the string 'data'

        >>> import shutil
        >>> if os.path.exists("keys"):
        ...     shutil.rmtree("keys", ignore_errors=True)
        >>> GPGBINARY = os.environ.get('GPGBINARY', 'gpg')
        >>> gpg = GPG(gpgbinary=GPGBINARY, gnupghome="keys")
        >>> input = gpg.gen_key_input(name_email='user1@test', passphrase='pp1')
        >>> result = gpg.gen_key(input)
        >>> fp1 = result.fingerprint
        >>> input = gpg.gen_key_input(name_email='user2@test', passphrase='pp2')
        >>> result = gpg.gen_key(input)
        >>> fp2 = result.fingerprint
        >>> result = gpg.encrypt("hello",fp2)
        >>> message = str(result)
        >>> assert message != 'hello'
        >>> result = gpg.decrypt(message, passphrase='pp2')
        >>> assert result
        >>> str(result)
        'hello'
        >>> result = gpg.encrypt("hello again", fp1)
        >>> message = str(result)
        >>> result = gpg.decrypt(message, passphrase='bar')
        >>> result.status in ('decryption failed', 'bad passphrase')
        True
        >>> assert not result
        >>> result = gpg.decrypt(message, passphrase='pp1')
        >>> result.status == 'decryption ok'
        True
        >>> str(result)
        'hello again'
        >>> result = gpg.encrypt("signed hello", fp2, sign=fp1, passphrase='pp1')
        >>> result.status == 'encryption ok'
        True
        >>> message = str(result)
        >>> result = gpg.decrypt(message, passphrase='pp2')
        >>> result.status == 'decryption ok'
        True
        >>> assert result.fingerprint == fp1

        """
        data = _make_binary_stream(data, self.encoding)
        result = self.encrypt_file(data, recipients, **kwargs)
        data.close()
        return result

    def decrypt(self, message, **kwargs):
        data = _make_binary_stream(message, self.encoding)
        result = self.decrypt_file(data, **kwargs)
        data.close()
        return result

    def decrypt_file(self, file, always_trust=False, passphrase=None,
                     output=None, extra_args=None):
        args = ["--decrypt"]
        if output:  # write the output to a file with the specified name
            self.set_output_without_confirmation(args, output)
        if always_trust:  # pragma: no cover
            args.append("--always-trust")
        if extra_args:
            args.extend(extra_args)
        result = self.result_map['crypt'](self)
        self._handle_io(args, file, result, passphrase, binary=True)
        logger.debug('decrypt result: %r', result.data)
        return result


Via I-295 N - Head north on I-295 N. Take exit 54 for Gate Pkwy, turn right onto Gate Pkwy. Gate Pkwy turns right and becomes Baymeadows Rd E. Turn right onto Courtney Meadows and then turn left onto Courtney Meadows. The leasing office will be on the right.
Via FL-202 W - Take FL-202 W to Gate Pkwy. Take exit 54 from I-295 S. Follow Gate Pkwy and Baymeadows Rd E to Courtney Meadows.


text:
Jovana Rikalo/Stocksy
5 Sneaky Ways You Can Get Sick On Vacation & How To Steer Clear Of The Germs
By Caroline Burke
When you're about to go on vacation, the literal last thing you want to happen is to catch a nasty cough the day before you leave. Even worse, there are tons of sneaky ways you can get sick on vacation, which can be hell on earth when you're in a foreign place and don't have access to the medicine or comforting tactics that you use at home when you don't feel well. Getting sick on vacation is basically more annoying than not going on vacation at all.
Unfortunately, though, it kind of happens a lot. According to Daphne Hendsebee, a communications and marketing specialist for the International Association for Medical Assistance to Travellers, it's very common for people to get sick from traveling, simply by virtue of how many germs you encounter. "You touch many surfaces covered in bacteria and viruses (door handles, tray tables in planes or trains, seats, railings, money, etc.)," she told Smarter Travel, adding that you also come in contact with so many different people throughout the whole process. What's more, she explained, "travel stress, fatigue, and jet lag can also have a big impact on your health."
For the most part, encountering foreign germs while you travel is pretty much unavoidable, so there's no use worrying about what you can't control. But there are some specific things you should watch out for and potentially avoid, so that you put your healthiest foot forward while on vacation. Here are five of the sneakiest ways you can get sick on vacation.
1. Drinking The Local Water
...or the local fruits, or any local produce that might not have been washed free of germs. Everyone knows someone who's experienced a horrible bout of food poisoning or diarrhea abroad from drinking water in a place like Mexico.
With that said, this doesn't mean you should only eat packaged food when you're abroad. After all, one of the best parts about traveling is enjoying the cuisine of the place you visit. Instead, simply check what the standards and warnings are for the place you're visiting. For example, if you're traveling to Cabo, you might take more time checking out their warning about drinking the tap water than if you're visiting friends in the Hamptons.
2. Over-Planning
You finally have the right to tell your Type A best friend that her planning is going to make both of you sick — literally. Howard Tinsley, Ph.D., professor emeritus of psychology at Southern Illinois University, told Reader's Digest that packing your schedule to the brim while you travel can lead to over-exertion, which might make you sick.
"On vacation, a person can become goal-oriented," Tinsley explained — which is a good thing, sure, until it just goes overboard and makes the vacation more stressful than it should be. There's no way to directly solve this issue, besides continually reminding yourself (and your strung-out BFF) to simply relax. You might not see everything you want to see, or do everything you want to do, but you'll feel better while you're traveling, and it'll give you a reason to visit this destination in the future.
3. "Leisure Sickness"
Yes, "leisure sickness" is a real thing, guys. According to a study conducted by Tilburg University in the Netherlands, around 3 percent of people experience symptoms similar to sickness while traveling, such as headaches, dizziness, fatigue, muscle pain, and nausea. The researchers wrote in their study that they believe this is likely due to the general stress that comes with traveling, including both the psychological effects of transitioning out of your usual schedule, to the physical stress of getting to another place on the globe.
The best thing you can do to combat this is to pay attention to how your own body reacts each time you travel. For example, if you notice how awful you feel after a day of traveling, try to think about whether you drank enough water, ate the right foods, or slept enough.
4. Sharing A Sick Person's Air During Public Transportation
Pretty much everyone has experienced this situation before: finally arriving to your plane or train or bus seat, only to see that the stranger sitting next to you is hacking up a lung, or covered in mucus. Blech.
Dr. William Schaffner, a professor of preventative medicine at Vanderbilt University School of Medicine, told TIME that certain modes of public transportation, like planes, conduct their air circulation "like a sliced hot dog." In other words, you and that sick person in the seat next to you are sharing a whole lot of air during a five-hour flight.
Unfortunately, Dr. Schaffner also told TIME that there's not much you can really do about this one, besides making sure to wash your hands immediately after the flight, and even taking a shower or changing your clothes as soon as you can after you land. Let go and let live, right?
5. Not Adjusting To Jet Lag (Or Compensating For It)
Nothing makes you feel totally out of it faster than experiencing a gnarly bout of jet lag that leaves you staring up at some random ceiling at 4 a.m. Jet lag is part of the magic (and horror) of traveling, but it can also leave you prone to sickness since you're not getting enough sleep.
The solution? Don't feel guilty about napping. Ideally, you want to get yourself into the new time zone by staying up and matching this new area's schedule, according to TIME, but it's not the end of the world if you can't do this immediately. Either way, making sure you get around seven to eight hours of sleep a day is the best way to rest your body and keep your immune system strong during your travels.

redpajama_set_name: RedPajamaCommonCrawl


text:
Court evidence suggests abuse cover-up by high ranking Legionaries of Christ
February 17, 2020 CNA Daily News News Briefs 3 Print
Milan, Italy, Feb 18, 2020 / 12:01 am (CNA).- Evidence to be presented in an upcoming criminal trial suggests an elaborate cover-up of sexual abuse allegations against a former priest of the Legionaries of Christ whom an Italian court has convicted of sexual abuse of a minor.
The case, set to begin in March, names four Legion priests and a Legion lawyer who are accused of attempting to obstruct justice and extort the family of a sex abuse victim, according to reporting by the Associated Press.
The names of the priests and lawyer in question have not been released, and the Legion did not respond to CNA's request for comment.
The Legion of Christ, a religious congregation consisting of fewer than 1,000 priests worldwide, was long the subject of critical reports and rumors before it was rocked by Vatican acknowledgment that its charismatic founder, Father Marcial Maciel, lived a double life, sexually abused seminarians, and fathered children. Maciel abused at least 60 minors.
In 2006 the Congregation of the Doctrine of the Faith, with the approval of Benedict XVI, removed Maciel from public ministry and ordered him to spend the rest of his life in prayer and penance. The congregation decided not to subject him to a canonical process because of his advanced age, and he died in 2008.
Benedict XVI appointed Cardinal Valasio De Paolis, a highly respected canon lawyer, to lead the religious order in 2010.
De Paolis, who died in 2017, has faced criticism for leaving much of the leadership of the congregation from Maciel's time in place and failing to investigate claims of cover-up.
The present case chiefly concerns Mexico native Vladimir Reséndiz Gutiérrez, who was ordained a priest in 2006 and immediately was sent to oversee young boys at the Gozzano youth seminary near Italy's border with Switzerland, the AP reports.
The Legion has said it first recieved allegations of sexual abuse against Reséndiz during March 2011. An Austrain boy reported the allegation to a church ombudsman's office in Austria that receives abuse complaints, according to the AP.
In addition, the son of Yolanda Martinez, a church employee in Milan, revealed in 2013 during sessions with his psychologist that Reséndiz had abused him at the Gozzano youth seminary in 2008.
In October 2013, the Legion offered a settlement of 15,000 euros to Martinez, but in return, her son would have to recant the testimony he gave to prosecutors that Reséndiz had repeatedly assaulted him, the AP reports.
Martinez called De Paolis to complain about the proposal. According to their wiretapped Jan. 7, 2014 conversation, De Paolis told Martinez not to sign the deal and to negotiate a different deal, without lawyers.
Authorities obtained the tape of the conversation, as well as numerous documents to be presented at the trial, during a 2014 raid of the Legion's headquarters in Rome.
Documents obtained during the 2014 raid suggest that Reséndiz was known to the Legion as a risk to children even when he was a teenage seminarian in 1994, with his novice director writing that he believed Reséndiz to be "a boy with strong sexual impulses and low capacity to control them."
A lawyer for the Legion is accused of recommending various schemes to Legion leaders aimed at covering up Reséndiz abuses.
The lawyer recommended in a March 2011 email that Father Gabriel Sotres, a Legion priest who was tasked with revising the congregation's constitution a decade ago, go to Austria to convince the alleged victim not to tell their parents or the authorities.
Documents also suggest that Legion knew about another possible victim in Venezuela, where Reséndiz had been moved in 2008. The lawyer proposed a plan to report only Reséndiz's name to Venezuelan police to comply with local reporting laws, leaving out that he was a priest, that he was accused of a sex crime against a child, and the name of the Legion, as well as noting that he no longer lived in Venezuela, the AP reported.
All of this would be done in order to mitigate the possible damage to the order.
That same month, Reséndiz was removed from priestly ministry after his religious superior questioned him, but documents suggest he hearing confessions in schools and celebrating Mass in Colombia while he was supposedly suspended, and later assigned to an administrative position.
Evidence to be presented at the trial suggests that although De Paolis opened a canonical investigation of Reséndiz within the congregation, he did not alert the police.
Authorities in Milan did not learn of the abuse allegations against Reséndiz until March 2013, when Martinez's son's psychologist reported them.
Reséndiz eventually confessed to his crimes in a letter to Cardinal Gerhard Mueller in 2012. The Congregation for the Doctrine of the Faith dismissed Reséndiz from the clerical state during April 2013, the Legion says.
An Italian court convicted Reséndiz in absentia during March 2019, and during Jan. 2020 an appeals court confirmed the conviction. Reséndiz faces a sentence of six and a half years in jail. He is believed to be living in Mexico.
The Legion reported in December 2019 that since its founding in 1941, 33 priests of the Legionaries of Christ have been found to have committed sexual abuse of minors, victimizing 175 children, according to the 2019 report.
The preliminary hearing for the present criminal trial in Milan is scheduled for March 12.
First Mass since Reformation to be held in Swiss cathedral
BREAKING: Vatican official raided over London property deal investigation
French bishops press government to review 30-person Mass limit
November 25, 2020 CNA Daily News 1
Rome Newsroom, Nov 25, 2020 / 07:00 am (CNA).- After a strong reaction by French Catholics to the government's decision Tuesday night to limit Mass attendance to 30 people per church during Advent, bishops are in negotiations with the government … […]
Scottish MP calls for end to UK two-child tax credit limit
December 14, 2020 CNA Daily News 1
CNA Staff, Dec 15, 2020 / 12:24 am (CNA).- A Scottish member of Parliament is calling on the UK government to end a two-child limit on tax credits and other benefits for children, which is believed to be a leading factor for many women seeking abortion… […]
Public Masses to resume in Austria May 15
April 21, 2020 CNA Daily News 0
Rome Newsroom, Apr 21, 2020 / 05:00 pm (CNA).- Public Masses will resume in Austria on May 15, the country's chancellor has said.
Sebastian Kurz made the announcement at a press conference in Vienna at noon local time April 21.
Fr. Peter Schipka, secretary general of the Austrian bishops' conference, confirmed that public liturgies would begin again from May 15, according to the Austrian Catholic news agency Kathpress.
Kurz said at the press conference that church services will "naturally" still be subject to certain restrictions. In particular, churches will have to ensure "that the distance rule is observed everywhere," Kathpress reported.
Kurz, a Catholic, also announced the news on Twitter April 21, alongside other measures to ease the lockdown in Austria.
"It is good that we can go the way of reopening and there is also light at the end of the tunnel for the economic development of our country," he tweeted.
"Our motto for the next phase is clear: as much freedom as possible, as much restriction as necessary."
A statement on the website of the Federal Chancellery of Austria said that church services will be permitted "subject to certain conditions and safety regulations to protect health".
The statement added that Susanne Raab, the country's minister of education and cultural affairs, will share further details, in consultation with religious communities, on Thursday, April 23.
Responding to the news, Cardinal Christoph Schönborn of Vienna tweeted: "We will soon be able to celebrate the Eucharist together with great joy and responsibility."
He added: "Faith needs both: the celebration together and the personal relationship with God. This is where Christianity comes from. The community of the Church is something essentially different from a club or a group of friends."
Austria, which has a population of 8.9 million, was one of the first European countries to enter lockdown. The first two cases of coronavirus were confirmed on February 25. From March 16 onwards, Austrians were ordered not to leave their homes except for reasons such as essential work or shopping.
Almost 15,000 people have contracted COVID-19 in Austria and 491 people have died as of April 21, according to Johns Hopkins University Coronavirus Resource Center.
More bad publicity for the LCs.
Disband this fraudulent "Legion" rabble debasing the name of Christ.
Founded by a sexual maniac, pervert and thief. Why does this order still exist? Follow the money.
Court evidence suggests abuse cover-up by high ranking Legionaries of Christ - Catholic Mass Search
Is capitalism the problem, or the solution?
Catherine Harmon August 16, 2011 0
Be sure to check out the CWR homepage, currently featuring Italian journalist Alessandra Nucci's interview with Vatican Bank chief Ettore Gotti Tedeschi, "The Church and Capitalism," from our August/September issue. Tedeschi touches on several issues […]


TOTAL TIME: 30:25 min, Video is approx. 31:00 min.
REMARKS: Bootleg. Recorded at Wisseloord Studios, Netherlands, October 19 - 1999. Disc 2 contains a 00 minuted cd-rom "2 Meter Sessies" Jethro Tull live video for personal computer.


Our refrigeration mechanics are fully licensed and compliant. We guarantee that all electrical works and gasses are completed and used in an environmentally-friendly manner.
AC maintenance prevents unit breakdowns in your home or business. It improves energy efficiency and performance by optimising your system.
Clogged, dirty filters will block normal airflow and reduce efficiency. Our technicians will clean all the dirty filters will replace for new if required, which will reduce the air conditioner's energy consumption by 5% to 15%.
The evaporator and condenser coil collects dirt over the course of months and years. Clean filters prevent evaporator coils from soiling quickly. We will inspect and clean your evaporator coil, annually.
The aluminium fins on evaporator and condenser coils bend easily causing them to block airflow. A "fin comb" puts fins back into nearly original condition.
When your air conditioner needs regular maintenance, call us to find and fix the problems. We have the knowledge and expertise to design, supply, install and repair all makes and models.
Check the amount of refrigerant.
Carefully capture any refrigerant that needs to be evacuated, and legally dispose of it in the correct manner.
Check for any seal duct leakage in central systems.
Verify the correct electric control sequence and make sure that the heating and cooling do not operate simultaneously.
Inspect electric terminals, clean and tighten connections, and apply non-conductive coating where necessary.
We also perform commercial air conditioning maintenance for businesses. We'll make sure your systems are well-maintained so the unit keeps employees and customers comfortable; no matter the weather.
We service and maintain air conditioning units from most well-known brands. Contact us today to discuss your requirements.


text:
Q: Use a proxy to connect iPhone to server? I'm researching how to code an iPhone app that needs to connect to an online service to get data. The online service only provides access to specified IP addresses or ranges, so iPhones won't be able to connect directly, and the request will have to go through a server.  I looked into setting up my own forward proxy server (which the service in question are happy with, by the way), which I guess would do the job for most other platforms. Unfortunately the iPhone does not seem to allow configuring a proxy address programmatically. Is there another potential solution for accessing the content from an intermediate server, that would show the online service the IP address of the server, rather than each individual iPhone?
Many thanks
Steve

A: It appears that using cURL is one way to achieve this. There should be bindings available for Cocoa.
I'll let people know how it goes in the comments.
Steve

redpajama_set_name: RedPajamaStackExchange


text:
Mar 7, 2013 / Announcements, Seminars
Bevan Seminar Series TODAY with Dr. David S. Siscovick!
Please join the School of Aquatic and Fishery Sciences and UW Professor David S. Siscovick, today, March 7, for the Bevans Series on Sustainability. Dr. Siscovick's presentation is titled, Fish intake and heart health: a clear picture or a new controversy? (abstract).
Time: 4:30 PM, reception to follow
For a list of all the Bevans Series topics 2013 Seminars, please visit our School seminars website.
Mar 6, 2013 / Announcements, Events
National Symposium Will Discuss the Future of Working Waterfronts
U.S. waterfronts account for over 6.75 million jobs, $284 billion in wages, and $645 billion in income. Yet across the United States, this valuable real estate is getting squeezed as increasing coastal populations generate conflicts over access to and uses of waterfronts. This March 25-28, Tacoma, Wash., will be the meeting site for coastal communities seeking a shared vision for the future of working waterfronts.
Feb 28, 2013 / Announcements, Seminars
Bevan Seminar Series TODAY with Elizabeth McLanahan (NOAA)!
Please join the School of Aquatic and Fishery Sciences and Acting Director of NOAA's Office of International Affairs, Elizabeth McLanahan, today, February 28, for the Bevans Series on Sustainability. Ms. McLanahan's presentation is titled, Melting Arctic Ice: the New Frontier for Exploitation or Conservation? (abstract).
Bevan Seminar Series TODAY with Dr. Poul Degnbol!
Please join the School of Aquatic and Fishery Sciences and Head of Advisory Programme at the International Council for the Exploration of the Seas, Poul Degnbol, today, February 21, for the Bevans Series on Sustainability. Dr. Degnbol's presentation is titled, No seafood for the future without good governance: experiences from Europe (abstract).
Feb 7, 2013 / Announcements, Seminars
Bevan Seminar Series TODAY with Dr. Rashid Sumaila!
Please join the School of Aquatic and Fishery Sciences and University of British Columbia's Fisheries Centre Director and Professor, Rashid Sumaila, today, February 7, for the Bevans Series on Sustainability. Dr. Sumaila's presentation is titled New threats to the flow of benefits from the global ocean (abstract).
Bevan Seminar Series TODAY with Ted Ames!
Please join the School of Aquatic and Fishery Sciences and fisherman and scholar, Ted Ames, today, February 14, for the Bevans Series on Sustainability. Mr. Ames' presentation is titled, So what's really happening with Gulf of Maine cod? (abstract).
Jan 31, 2013 / Announcements, Seminars
Bevan Seminar Series TODAY with Dr. Virginia Butler!
Please join the School of Aquatic and Fishery Sciences and Portland State University Professor Virginia Butler today, January 31, for the Bevans Series on Sustainability. Dr. Butler's presentation is titled The 10,000 year record of sustainable fisheries in the Pacific Northwest (abstract).
Bevan Seminar Series TODAY with Dr. Peter Tyedmers!
Please join the School of Aquatic and Fishery Sciences and Dalhousie University Associate Professor Peter Tyedmers today, January 24, for the Bevans Series on Sustainability. Dr. Tydemers' presentation is titled Energy use in fisheries: Achilles' heel or Poseidon's trident? (abstract).
Bevan Seminar Series TODAY with Dr. Emily Oken!
Please join the School of Aquatic and Fishery Sciences and Harvard Medical School Associate Professor Emily Oken today, January 17, for the Bevans Series on Sustainability. Dr. Oken's presentation is titled Should pregnant women, nursing mothers, and young children eat fish? (abstract).
Jan 16, 2013 / Announcements, Events
Monster Seminar JAM, feat. Dr. Erika Eliason
If you would like to meet with Dr. Erika Eliason, please contact Peter Kiffney at peter.kiffney@noaa.gov.
The next installment of the 2013 Winter Quarter NWFSC Weekly Monster Seminar JAM series will feature Dr. Erika Eliason, School of Biological Sciences, University of Sydney and Department of Forest Sciences, University of British Columbia. Dr. Eliason's presentation entitled "Local Adaptation and Thermal Tolerance in Adult Migrating Fraser River Sockeye Salmon Populations", will take place on Thursday, January 17th at 11:00 AM in the Northwest Fisheries Science Center Auditorium: 2725 Montlake Blvd.


text:
Murder Games
Written By: James Patterson
Narrated By: Edoardo Ballerini
Publisher: Cornerstone Digital
Random House presents the unabridged, downloadable audio edition of Murder Games by James Patterson, read by Edoardo Ballerini.
The next hand he deals you... may be your last.
A serial killer is loose on the streets of Manhattan. His victims appear to be total strangers. The only clue that links the crimes is the playing card left behind at each scene that hints at the next target.
The killer, known in the tabloids as The Dealer, is baiting the police into a deadly guessing game that has the city increasingly on edge. Following her instincts, the tenacious cop in charge of the case turns to an unlikely ally - Dylan Reinhart, a brilliant professor with a keen insight into the criminal mind whose book turned up in connection with the murders.
As the tabloid frenzy over The Dealer reaches fever pitch, Dylan and Elizabeth must connect the clues to discover what the victims have in common before The Dealer runs through his entire deck.
Mystery, Thriller & Horror >
What a great read/ listen! Loved the suspense but definitely was left wanting more & wishing for more!
This title is due for release on June 1, 2017.
This title is due for release on June 1, 2017


text:
Meg Whitman Interview: Skype, California Budget Crisis and Mitt Romney
The former eBay chief and gubernatorial candidate on the brutality of politics, where her life has taken her since November—and why she's glad she bought Skype.
Lois Romano
Have you recovered from the [California governor's] campaign?
Mostly. [laughs] Yeah I have. November and December was very tough. But with the new year, I got back in the swing of things and I'm doing a lot of interesting and fun things now.
Were you surprised with how ugly and personal the race became?
It's politics. I knew what I was getting into. But it's still hurtful. It's tough on you, tough on the family. It's not an easy thing. I knew what it was intellectually, but emotionally it was harder than you think.
Do you think you'll run for public office again?
I doubt it. You never say never. I will stay involved in politics and public policy, but it may not be elective office.
Governor Brown is being credited with reducing the California budget deficit. How do you think he's doing? What would you do differently?
Well I think it's... well know that I would have taken a different approach. My approach was to reduce spending. Reduce size of government, reform pensions, and reform a lot of programs that had gotten to be so expensive in California and I would not have raised taxes. Gov. Brown is still working on bringing the budget home and I have been quite careful not to criticize him. I think it's appropriate that we give him a chance to get through one budget cycle, which is due July 1.
You have a new job with Kleiner Perkins, the venture-capital firm. Tell us what you're doing.
I'm part-time as what they call a strategic adviser and my job is to help with digital investments and to also coach and mentor CEOs and founders because very few people have scaled up companies the way I did at eBay, from $7 million to nearly $8 billion in revenue, from 30 employees to 15,000.
I think I can be a lot of help to young founders and CEOs who have big aspirations.
On the investment side, you're always looking for brilliant new ideas that disrupt the existing way of doing things. The most successful companies are those that create entirely new markets… Like eBay, which created global online trading… and Google created a search that had never been done before. You're looking for breakthrough ideas that change the way we do things for the better.
Do you shop on eBay?
Oh yeah. All the time, I bought books recently. Sometimes I buy clothes. When the children were young, I bought a lot of athletic equipment.
You took some heat when you were at eBay for buying Skype in 2005 for $3 billion. Microsoft just bought it for $8 billion. Do you feel vindicated?
Well, I always had great confidence in the Skype acquisition and great confidence in the company. It was incredible technology that changed everything abut the way we communicate with each other.
That's what leadership is, you do what you think is in the best interest of the company and shareholders, and sometimes it takes a little while for the entire story to be told. So I was pleased for what it sold for.
Sometimes in life you don't get recognition easily.
Is it worth $8 billion?
Yeah, probably. It all depends the how large the platform can grow and what Microsoft can do. I suspect it probably is.
Was it not a good fit for eBay's business model?
Skype didn't get the synergies with eBay that we would have liked. Could we have done better creating those synergies? Absolutely.
You supported Mitt Romney in 2008.
I am supporting him again and hard at work on the Romney campaign. I'm very involved. I'll be in Las Vegas all day [May 16], where he's having huge gathering of his supporters. We're all going to come together and make fundraising phone calls for him.
Will Barack Obama be harder to beat now that he's silenced Osama bid Laden?
I congratulate President Obama on that decision. Boy, that took some guts and he deserves credit. It's always hard to beat an incumbent president. I think this election will turn on the economy and jobs. If the economy doesn't improve measurably… and people don't have more optimism about their own future, I think President Obama can be beaten.
Mitt is an extraordinary leader and he understands the economy. Often this is about the right person at the right time.
"You're always looking for brilliant new ideas that disrupt the existing way of doing things....You're looking for breakthrough ideas that change the way we do things for the better."
Is there anything else you're doing that you'd like to share?
I've been getting involved in philanthropic activities. I joined the Teach for America board, have joined the Summit Preparatory High School board, and the board of the Nature Conservancy.
Lois Romano is a senior writer for Newsweek/Daily Beast based in Washington. She was a longtime political writer and columnist for The Washington Post, covering presidential campaigns and Washington powerbrokers.


Auto-Align Layers - In my opinion, there is missing possibility to align selected layers to one particular layer (which stays unchanged).
There is already are align layers commands.
How would you expect that to work automatically?
At this moment all selected layers are modified by Auto-Align Layers Command.
I wish if this command respected Layer Shape Lock - so one of the image would stay unchanged and only the rest would adopt the shape and disortion.
Please imagine batch of images, where one of the image is main shot (with composition reference) and this image should not be changed. The rest of the images are either elements of the product or focuses. Sometimes the angle of the camera changes a little bit due to the nature of photographed object and this may affect the main shot.
Using Auto-Align Layers command would change it along with other selected layers.


When it comes to home renovations, hiring the right Victoria contractor is the most important decision you can make. Protect yourself by choosing one that is licensed, insured and highly experienced.
Your contractor shouldn't be one of them.
A home renovation involves making a lot of important decisions. Today with new Victoria building code and hazardous material regulations, those decisions matter more than ever. Horizon helps you understand how to make the smart choices that keep you on budget and on time. Without compromise.
Are you in a neighbourhood where building down instead of out is the only option? Raising your home to get more height for a basement suite or luxurious retreat could be the perfect solution.
In a city where real estate is at a premium, additions make a lot of sense. Particularly if you live in one of those Victoria neighbourhoods where the homes tend to be older and the lots larger.
It's finally time to build your dream kitchen. You've got a lot to decide. Where to start? Horizon is an expert at helping you get from point A to Z with your sanity and budget intact.
Looking for a way to brighten up your day? A sunroom, solarium, balcony enclosure, or greenhouse is guaranteed to put you in a sunnier mood, even on the grayest Victoria day.


Agfa Graphics is introducing digital print in manufacturing at InPrint 2017, contributing to just-in-time delivery and personalized or variable content.
Agfa acts as an important partner and connector to anyone taking part in manufacturing, helping to integrate digital object printing in the production process.
The company says that with years of experience in providing graphics solutions, it has developed a range of fluids including inkjet inks, primers and coatings.
The inks are claimed to have proven their value in several diverse applications such as marking, coding, product printing, packaging and interior decoration.
At InPrint 2017, Agfa plans to display a range of its industrial products ranging from printed tubes and containers, customised shoes and personalised PET bottles along with low-migration inks for food packaging applications.
Though, its inks are UV-curable or water-based, these will be delivered for functional requirements for example, flooring and furniture on melamine base. Thanks to their consistent color and low metamerism, these inks offer a unique image quality and substrate adhesion.
The inks on display represent areas where inks and fluids are used to add functionality or decorate the products by means of digital printing alternatives, on an industrial scale.
The list of applications for industrial inkjet is growing on a daily basis, across several industries. These inks can be used with wide-format printers such as Jeti Titan, Jeti Tauro, Jeti Mira or the Anapurna systems.
He said: "InPrint is the place to meet industrial customers that are looking for a competitive advantage. They want access to a process or solution that puts them ahead of the competition. We are eager to collaborate with such companies to integrate print in a specific industrial process.


text:
Human Genomics Analysis Interface | FaceBase
Next FaceBase Office Hours are Wednesday, January 26th: Register via Zoom
Human Genomics Analysis Interface
HGAI Home
Oral-Facial Clefting
OFC1: International Consortium to Identify Genes and Interactions Controlling Oral Clefts
OFC2: Targeted Sequencing of CL/P GWAS Loci
OFC3: GWAS of OFCs in Guatemala
OFC4: Genetics of Orofacial Clefts and Related Phenotypes
OFC5: Meta GWAS Analysis of OFC1 and OFC4
Facial Variation
FV1: GWAS of Facial Measures in Europeans
Dental Traits
Dent1: Childhood Caries
Dent2: Caries in Permanent Dentition
Dent3: Caries in Smooth and Pit-and-Fissure Surfaces
Explore Project Data
dbGaP Study Accession: phs000774.v2.p1.
Principal Investigator: Mary L. Marazita, University of Pittsburgh, Pittsburgh, PA, USA
X01-HG007485 Genetics of Orofacial Clefts and Related Phenotypes. National Human Genome Research Institute, CIDR Genotyping, National Institutes of Health, Bethesda, MD, USA
R01-DE-016148, Extending the Phenotype of Nonsyndromic Orofacial Clefts. National Institute of Dental and Craniofacial Research, National Institutes of Health, Bethesda, MD, USA
R01-DE-012472, HOMOZYGOSITY MAPPING OF ORAL-FACIAL CLEFTS IN TURKEY. National Institute of Dental and Craniofacial Research, National Institutes of Health, Bethesda, MD, USA
R01-DE-009886, GENE MAPPING STUDIES OF ORAL/FACIAL CLEFTS - CHINA/INDIA. National Institute of Dental and Craniofacial Research, National Institutes of Health, Bethesda, MD, USA
P50-DE-016215, CRANIOFACIAL ANOMALIES RESEARCH CENTER. National Institute of Dental and Craniofacial Research, National Institutes of Health, Bethesda, MD, USA
K99-DE-022378, GENETIC STUDIES OF NONSYNDROMIC CLEFTS IN POPULATIONS OF AFRICAN DESCENT. National Institute of Dental and Craniofacial Research, National Institutes of Health, Bethesda, MD, USA
R37-DE-008559, MOLECULAR GENETIC EPIDEMIOLOGY OF CLEFT LIP AND PALATE. National Institute of Dental and Craniofacial Research, National Institutes of Health, Bethesda, MD, USA
R01-DE-014667, CLEFT LIP GENETICS: A MULTI CENTER INTERNATIONAL CONSORTIUM. National Institute of Dental and Craniofacial Research, National Institutes of Health, Bethesda, MD, USA
R01-DD-000295, HEALTH OUTCOMES AND IMPROVED PHENOTYPIC CHARACTERIZATION OF CLEFT LIP AND PALATE. National Center on Birth Defects and Developmental Disabilities, Centers for Disease Control and Prevention, Atlanta, GA, USA
R21-DE-016930, PLANNING INTERNATIONAL OROFACIAL CLEFT GENETIC STUDIES. National Institute of Dental and Craniofacial Research, National Institutes of Health, Bethesda, MD, USA
The current study is the culmination of many years of ongoing collaborations among the study investigators (for complete list of investigators, see dbGaP). Molecular genetic studies of orofacial clefts (OFC) by members of this research consortium began in the 1980's, followed by genome-wide linkage studies in the 1990's-early 2000's, and then genome-wide association studies in the 2010's. A rich phenotyping approach was first added to the consortium in 1999 as a project led by Dr. Mary Marazita under a center grant headed by Dr. Jeff Murray. Additional sites were added throughout the 2000's, until multiple populations and a large number of individuals (~12,000) comprise the current study population for genetic studies of OFCs and related subclinical phenotypes—subtle features believed to represent mild manifestations of the same underlying genetic susceptibility responsible for OFCs. As such, their inclusion in case-control and family-based genetic studies can help to clarify and refine the relationship between genotype and phenotype. Information on how to obtain individual level data is available on dbGaP.
Genotyping and quality control methods are available on dbGaP and are briefly described in Leslie et al. "A genome-wide association study of nonsyndromic cleft palate identifies an etiologic missense variant in GRHL3". Am J Hum Genet. 2016; and Leslie et al. "A multi-ethnic genome-wide association study identifies novel loci for nonsyndromic cleft lip with or without cleft palate on 2p24.2, 17q23 and 19q31". Hum Mol Genet. 2016.
Briefly, GWAS scans were conducted in two subsets: independent cases and controls, and an independent set of case-parent trios. Statistical analysis was performed in PLINK using logistic regression while adjusting for principal components of ancestry and the transmission disequilibrium test. Association results for the two GWAS scans were combined by weighted odds ratio meta-analysis to estimate study-wide association results. Analyses were completed in the full multiethnic sample or stratified by genetically defined subpopulations.
Frequency Counts for Study Variables
Please select option:
Case Clefting Status Proband Clefting Status Case Ancestry Control Ancestry Proband Ancestry Case Sex Control Sex Proband Sex Case Clefting x Ancestry Proband Clefting x Ancestry	Case Clefting x Sex Proband Clefting x Sex
The samples for this study come from three primary ancestry groups: Europeans (from the United States, Denmark, Hungary, Spain, and Turkey), Asians (from China, the Philippines, and India), Central/South Americans (from Puerto Rico, Guatemala, Colombia, and Argentina), and Africans (from Nigeria and Ethiopia). The subjects have been assessed for various cleft types and related subclinical phenotypes. Our results database contains the GWAS results from this study of OFCs and can be explored as one study or subset into separate groups.
All genomic coordinates are mapped to Human GRCh37 - hg19 genome assembly.
Custom Plots
Ancestry Groups
Central/South Americans
Cleft Palate (CP)
Cleft Lip With Or Without Cleft Palate (CL/P)
Analysis Group
Case-Control
Static Manhattan Plot
Interactive Locus Zoom (opens in new tab)
PubMed list for all publications associated with this project.
© 2014-2019 University of Pittsburgh.
This project is made possible by funding from NIDCR.
Grant #:U01-DE024425
Contact | News | Privacy Policy
By downloading data or using data from this site, you agree to these Terms of Use.
FaceBase is funded by the National Institute of Dental and Craniofacial Research (NIDCR).