Have you ever been made to feel as if you were in denial about the reality of the things that happen in your relationship? The harder that you try to persuade your partner of your feelings, the more that you find yourself believing his version of events. Whether it comes from your spouse, significant other or your boss, this is a sign of an emotionally abusive relationship.
• Gaslighting- In this situation the abuser will feed you false information that will cause you to doubt your own memory and perception of events. Generally the three tactics they will be to deny, minimize or blame the abuse on you. They can be so convincing that before long you believe what they tell you about your own reality.
• Intimidation- An abuser may display weapons, make you afraid, hurt your pets or break your belongings.
• Emotional Abuse- Name calling, insulting, humiliation, and instilling feelings of guilt are common campaign to make you feel inferior to them.
• An abuser may also coerce, threaten, use male privilege or your children as tools to keep you in line.
Many people think of domestic violence in terms of the classic image of a blue-collar guy in a wife-beater shirt, smacking a lady around. Yet, this isn't always the case. Just because someone has never hit you doesn't mean they aren't abusing you in other ways. Abusers are masters of stealing your personal power by demeaning you, not taking you seriously, and refusing to own up to their actions.
Abusive relationships take a toll on women at home and in the work place. Abuse leads to a downward spiral of poor self-esteem, and conditions you to be accepting of this type of behavior. However this conduct may not be limited to the home, bullies at work often use many of the same techniques. Some may be more aggressive than others, engaging in a variety of actions.
• Belittling, criticizing and humiliation.
• Threatening by stares, gestures or appearing hostile.
• Failure to acknowledge good work, creating unrealistic job expectations or excessive micro-management of work.
In our society, women are often pre-conditioned to accept this behavior. Taught from an early age to put the needs of others before themselves, females often end up trying to uphold a double standard. It may be true that, to some degree, women are hardwired to be more empathetic. Yet that doesn't mean you have to end up a victim, being the proverbial doormat for someone to wipe their feet on. Tolerance of abusive relationships can lead to desensitization, which leaves you vulnerable to further abuse.
Enduring an abusive relationship at home creates a level of tolerance that spills over into the work environment. When you accept that your opinion is less valuable than that of others, it creates a dynamic that sets you up for a repetitive pattern of believing what you are told about yourself. This can be extremely damaging to your self-esteem, and may hinder professional advancement. Insist on a healthy relationship, where there is mutual respect.
• Listening without passing judgment on how someone should feel.
• Understanding about emotions and attach importance to opinions.
• Respecting that everyone has a right to their own thoughts, activities and feelings.
• Ensuring that behavior allows for safe and comfortable communication.
• Accepting responsibility for actions and accountability for actions.
By insisting on, and modeling respectful behavior, it is possible for you to overcome the negative self-image that many women develop. Achieving harmony and success both at home and in the workplace, is an attainable goal. Knowledge and understanding of why abusive situation occur can go a long way towards developing successful strategies for overcoming this destructive cycle.


text:
Q: parse_dates cannot convert string to datetime I try to read a CSV from the link https://raw.githubusercontent.com/LinkedInLearning/data_cleaning_python_2883183/main/Ch04/challenge/traffic.csv
df = pd.read_csv('https://raw.githubusercontent.com/LinkedInLearning/data_cleaning_python_2883183/main/Ch04/challenge/traffic.csv', parse_dates=['time'])

But, the time column is still in string format.
df.dtypes
[output]
ip        object
time      object
path      object
status     int64
size       int64
dtype: object

Interestingly, when I read a similar csv from a different url, it works. So
df = pd.read_csv('https://raw.githubusercontent.com/LinkedInLearning/data_cleaning_python_2883183/main/Ch04/solution/traffic.csv', parse_dates=['time'])

indeed converts the time column to a datetime object. Why does parse_dates fail in the first link and how can I fix it?

A: There is typo in datetimes:

1017-06-19 14:46:24

Possible solution is convert values to NaT:
df['time'] = pd.to_datetime(df['time'], errors='coerce')

redpajama_set_name: RedPajamaStackExchange


Richard Dawkins has posted the follow-up to Daniel Dennett's first report from the Darwin Festival, in which he heavily criticizes a session on evolution and theology. (Philip Clayton, Wentzel van Huyssteen, and John Brooke have since responded.) In the second installment, Dennett shares his impressions of another session he attended, this one on the evolution of religion.


Every wedding is unique in its own way, but the one thing that makes it even more unique is when small children are involved. Now, some people may see having little ones in a wedding as stressful or a lot to handle, but in some ways they can take the edge off of the stress and add a considerable amount of humour and silliness to the day. It is always very amusing seeing children interacting at a wedding because, quite frankly, they usually do not fully understand the seriousness or reason for a wedding, therefore they often act like they would any other day. As they say, "Kids will be kids."
On the big day, parents of the flower girl or ring bearer are often stressed about the same thing: Keeping their child's outfit clean until family and formal pictures are over and done with. Luckily, this shot was captured after we had taken family photos and bridal party shots, so it was not an issue photo-wise. Although the guests and wedding party thought the incident was quite funny, this little guy was very disappointed in himself for falling and getting his new suit dirty. However, he recovered quite quickly and was running around again in no time. On the bright side, he probably never had to wear the outfit again.


text:
CSU Rams Player Of The Game From Week 2: Tory Horton
A.J. Published: September 12, 2022
Instagram/CSU Football
Let's face it, there wasn't much to celebrate on Saturday at Canvas Stadium as the Colorado State Rams fell to the Middle Tennessee Blue Raiders in their home opener by a final score of 34-19 and to be honest, the score didn't even indicate how badly the team was outplayed in all phases of the game.
Coach Norvell, who was obviously disappointed by his team's performance had this to say after the game--
"The big thing that we've been trying to establish with our guys is we've tried to simplify this game and really work on simple things in practice and try to carry them over to the game," "I'm really disappointed about some of the fundamental things we did not do early in this game."
The lone bright spot on that chilly, damp and gray day was the emergence of wide receiver Tory Horton who snagged 9 catches for almost 200 yards and scored all of the touchdowns on passes from quarterback Clay Millen.
Horton and QB Millen are two of the players that came over from Nevada with head coach Jay Norvell after last season and while the first two games of the season have been bummers, there are some glimpses and this is certainly one of them.
So congratulations is definitely in order to our player of the game from the Middle Tennessee game albeit a bittersweet congratulations.
Let's hope the boys build on some of the momentum they built late in the game and continue that in this week's matchup as the Rams travel up to the Pacific Northwest to Pullman, Washington to take on the Cougars of Washington State University who are coming off a big win at Wisconsin.
As you can for every Rams football game, you can catch all of the action here on your home for Rams football, K99 with pregame starting at 1pm with a kickoff set for 3pm mountain time.
5 Kickass Females You Didn't Know Went to CSU
Categories: Articles, CSU Rams Sports, NoCo Life, NoCo News, Sports
This Week's Larimer County's Most Wanted: Savanna Morrill

redpajama_set_name: RedPajamaCommonCrawl


text:
from sys import platform
from functools import wraps, partial
from itertools import count
from weakref import WeakValueDictionary
from errno import errorcode

from six import text_type as _text_type
from six import integer_types as integer_types

from OpenSSL._util import (
    ffi as _ffi,
    lib as _lib,
    exception_from_error_queue as _exception_from_error_queue,
    native as _native)

from OpenSSL.crypto import (
    FILETYPE_PEM, _PassphraseHelper, PKey, X509Name, X509, X509Store)

_unspecified = object()

try:
    _memoryview = memoryview
except NameError:
    class _memoryview(object):
        pass

OPENSSL_VERSION_NUMBER = _lib.OPENSSL_VERSION_NUMBER
SSLEAY_VERSION = _lib.SSLEAY_VERSION
SSLEAY_CFLAGS = _lib.SSLEAY_CFLAGS
SSLEAY_PLATFORM = _lib.SSLEAY_PLATFORM
SSLEAY_DIR = _lib.SSLEAY_DIR
SSLEAY_BUILT_ON = _lib.SSLEAY_BUILT_ON

SENT_SHUTDOWN = _lib.SSL_SENT_SHUTDOWN
RECEIVED_SHUTDOWN = _lib.SSL_RECEIVED_SHUTDOWN

SSLv2_METHOD = 1
SSLv3_METHOD = 2
SSLv23_METHOD = 3
TLSv1_METHOD = 4
TLSv1_1_METHOD = 5
TLSv1_2_METHOD = 6

OP_NO_SSLv2 = _lib.SSL_OP_NO_SSLv2
OP_NO_SSLv3 = _lib.SSL_OP_NO_SSLv3
OP_NO_TLSv1 = _lib.SSL_OP_NO_TLSv1

OP_NO_TLSv1_1 = getattr(_lib, "SSL_OP_NO_TLSv1_1", 0)
OP_NO_TLSv1_2 = getattr(_lib, "SSL_OP_NO_TLSv1_2", 0)

try:
    MODE_RELEASE_BUFFERS = _lib.SSL_MODE_RELEASE_BUFFERS
except AttributeError:
    pass

OP_SINGLE_DH_USE = _lib.SSL_OP_SINGLE_DH_USE
OP_EPHEMERAL_RSA = _lib.SSL_OP_EPHEMERAL_RSA
OP_MICROSOFT_SESS_ID_BUG = _lib.SSL_OP_MICROSOFT_SESS_ID_BUG
OP_NETSCAPE_CHALLENGE_BUG = _lib.SSL_OP_NETSCAPE_CHALLENGE_BUG
OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG = _lib.SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
OP_SSLREF2_REUSE_CERT_TYPE_BUG = _lib.SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
OP_MICROSOFT_BIG_SSLV3_BUFFER = _lib.SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
try:
    OP_MSIE_SSLV2_RSA_PADDING = _lib.SSL_OP_MSIE_SSLV2_RSA_PADDING
except AttributeError:
    pass
OP_SSLEAY_080_CLIENT_DH_BUG = _lib.SSL_OP_SSLEAY_080_CLIENT_DH_BUG
OP_TLS_D5_BUG = _lib.SSL_OP_TLS_D5_BUG
OP_TLS_BLOCK_PADDING_BUG = _lib.SSL_OP_TLS_BLOCK_PADDING_BUG
OP_DONT_INSERT_EMPTY_FRAGMENTS = _lib.SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
OP_CIPHER_SERVER_PREFERENCE = _lib.SSL_OP_CIPHER_SERVER_PREFERENCE
OP_TLS_ROLLBACK_BUG = _lib.SSL_OP_TLS_ROLLBACK_BUG
OP_PKCS1_CHECK_1 = _lib.SSL_OP_PKCS1_CHECK_1
OP_PKCS1_CHECK_2 = _lib.SSL_OP_PKCS1_CHECK_2
OP_NETSCAPE_CA_DN_BUG = _lib.SSL_OP_NETSCAPE_CA_DN_BUG
OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG= _lib.SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG
try:
    OP_NO_COMPRESSION = _lib.SSL_OP_NO_COMPRESSION
except AttributeError:
    pass

OP_NO_QUERY_MTU = _lib.SSL_OP_NO_QUERY_MTU
OP_COOKIE_EXCHANGE = _lib.SSL_OP_COOKIE_EXCHANGE
try:
    OP_NO_TICKET = _lib.SSL_OP_NO_TICKET
except AttributeError:
    pass

OP_ALL   = _lib.SSL_OP_ALL

VERIFY_PEER = _lib.SSL_VERIFY_PEER
VERIFY_FAIL_IF_NO_PEER_CERT = _lib.SSL_VERIFY_FAIL_IF_NO_PEER_CERT
VERIFY_CLIENT_ONCE = _lib.SSL_VERIFY_CLIENT_ONCE
VERIFY_NONE = _lib.SSL_VERIFY_NONE

SESS_CACHE_OFF = _lib.SSL_SESS_CACHE_OFF
SESS_CACHE_CLIENT = _lib.SSL_SESS_CACHE_CLIENT
SESS_CACHE_SERVER = _lib.SSL_SESS_CACHE_SERVER
SESS_CACHE_BOTH = _lib.SSL_SESS_CACHE_BOTH
SESS_CACHE_NO_AUTO_CLEAR = _lib.SSL_SESS_CACHE_NO_AUTO_CLEAR
SESS_CACHE_NO_INTERNAL_LOOKUP = _lib.SSL_SESS_CACHE_NO_INTERNAL_LOOKUP
SESS_CACHE_NO_INTERNAL_STORE = _lib.SSL_SESS_CACHE_NO_INTERNAL_STORE
SESS_CACHE_NO_INTERNAL = _lib.SSL_SESS_CACHE_NO_INTERNAL

SSL_ST_CONNECT = _lib.SSL_ST_CONNECT
SSL_ST_ACCEPT = _lib.SSL_ST_ACCEPT
SSL_ST_MASK = _lib.SSL_ST_MASK
SSL_ST_INIT = _lib.SSL_ST_INIT
SSL_ST_BEFORE = _lib.SSL_ST_BEFORE
SSL_ST_OK = _lib.SSL_ST_OK
SSL_ST_RENEGOTIATE = _lib.SSL_ST_RENEGOTIATE

SSL_CB_LOOP = _lib.SSL_CB_LOOP
SSL_CB_EXIT = _lib.SSL_CB_EXIT
SSL_CB_READ = _lib.SSL_CB_READ
SSL_CB_WRITE = _lib.SSL_CB_WRITE
SSL_CB_ALERT = _lib.SSL_CB_ALERT
SSL_CB_READ_ALERT = _lib.SSL_CB_READ_ALERT
SSL_CB_WRITE_ALERT = _lib.SSL_CB_WRITE_ALERT
SSL_CB_ACCEPT_LOOP = _lib.SSL_CB_ACCEPT_LOOP
SSL_CB_ACCEPT_EXIT = _lib.SSL_CB_ACCEPT_EXIT
SSL_CB_CONNECT_LOOP = _lib.SSL_CB_CONNECT_LOOP
SSL_CB_CONNECT_EXIT = _lib.SSL_CB_CONNECT_EXIT
SSL_CB_HANDSHAKE_START = _lib.SSL_CB_HANDSHAKE_START
SSL_CB_HANDSHAKE_DONE = _lib.SSL_CB_HANDSHAKE_DONE

class Error(Exception):
    """
    An error occurred in an `OpenSSL.SSL` API.
    """

_raise_current_error = partial(_exception_from_error_queue, Error)

class WantReadError(Error):
    pass

class WantWriteError(Error):
    pass

class WantX509LookupError(Error):
    pass

class ZeroReturnError(Error):
    pass

class SysCallError(Error):
    pass

class _VerifyHelper(object):
    def __init__(self, connection, callback):
        self._problems = []

        @wraps(callback)
        def wrapper(ok, store_ctx):
            cert = X509.__new__(X509)
            cert._x509 = _lib.X509_STORE_CTX_get_current_cert(store_ctx)
            error_number = _lib.X509_STORE_CTX_get_error(store_ctx)
            error_depth = _lib.X509_STORE_CTX_get_error_depth(store_ctx)

            try:
                result = callback(connection, cert, error_number, error_depth, ok)
            except Exception as e:
                self._problems.append(e)
                return 0
            else:
                if result:
                    _lib.X509_STORE_CTX_set_error(store_ctx, _lib.X509_V_OK)
                    return 1
                else:
                    return 0

        self.callback = _ffi.callback(
            "int (*)(int, X509_STORE_CTX *)", wrapper)

    def raise_if_problem(self):
        if self._problems:
            try:
                _raise_current_error()
            except Error:
                pass
            raise self._problems.pop(0)

def _asFileDescriptor(obj):
    fd = None
    if not isinstance(obj, integer_types):
        meth = getattr(obj, "fileno", None)
        if meth is not None:
            obj = meth()

    if isinstance(obj, integer_types):
        fd = obj

    if not isinstance(fd, integer_types):
        raise TypeError("argument must be an int, or have a fileno() method.")
    elif fd < 0:
        raise ValueError(
            "file descriptor cannot be a negative integer (%i)" % (fd,))

    return fd

def SSLeay_version(type):
    """
    Return a string describing the version of OpenSSL in use.

    :param type: One of the SSLEAY_ constants defined in this module.
    """
    return _ffi.string(_lib.SSLeay_version(type))

class Session(object):
    pass

class Context(object):
    """
    :py:obj:`OpenSSL.SSL.Context` instances define the parameters for setting up
    new SSL connections.
    """
    _methods = {
        SSLv2_METHOD: "SSLv2_method",
        SSLv3_METHOD: "SSLv3_method",
        SSLv23_METHOD: "SSLv23_method",
        TLSv1_METHOD: "TLSv1_method",
        TLSv1_1_METHOD: "TLSv1_1_method",
        TLSv1_2_METHOD: "TLSv1_2_method",
        }
    _methods = dict(
        (identifier, getattr(_lib, name))
        for (identifier, name) in _methods.items()
        if getattr(_lib, name, None) is not None)

    def __init__(self, method):
        """
        :param method: One of SSLv2_METHOD, SSLv3_METHOD, SSLv23_METHOD, or
            TLSv1_METHOD.
        """
        if not isinstance(method, integer_types):
            raise TypeError("method must be an integer")

        try:
            method_func = self._methods[method]
        except KeyError:
            raise ValueError("No such protocol")

        method_obj = method_func()
        if method_obj == _ffi.NULL:
            # TODO: This is untested.
            _raise_current_error()

        context = _lib.SSL_CTX_new(method_obj)
        if context == _ffi.NULL:
            # TODO: This is untested.
            _raise_current_error()
        context = _ffi.gc(context, _lib.SSL_CTX_free)

        self._context = context
        self._passphrase_helper = None
        self._passphrase_callback = None
        self._passphrase_userdata = None
        self._verify_helper = None
        self._verify_callback = None
        self._info_callback = None
        self._tlsext_servername_callback = None
        self._app_data = None

        # SSL_CTX_set_app_data(self->ctx, self);
        # SSL_CTX_set_mode(self->ctx, SSL_MODE_ENABLE_PARTIAL_WRITE |
        #                             SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER |
        #                             SSL_MODE_AUTO_RETRY);
        self.set_mode(_lib.SSL_MODE_ENABLE_PARTIAL_WRITE)

    def load_verify_locations(self, cafile, capath=None):
        """
        Let SSL know where we can find trusted certificates for the certificate
        chain

        :param cafile: In which file we can find the certificates
        :param capath: In which directory we can find the certificates
        :return: None
        """
        if cafile is None:
            cafile = _ffi.NULL
        elif not isinstance(cafile, bytes):
            raise TypeError("cafile must be None or a byte string")

        if capath is None:
            capath = _ffi.NULL
        elif not isinstance(capath, bytes):
            raise TypeError("capath must be None or a byte string")

        load_result = _lib.SSL_CTX_load_verify_locations(self._context, cafile, capath)
        if not load_result:
            _raise_current_error()

    def _wrap_callback(self, callback):
        @wraps(callback)
        def wrapper(size, verify, userdata):
            return callback(size, verify, self._passphrase_userdata)
        return _PassphraseHelper(
            FILETYPE_PEM, wrapper, more_args=True, truncate=True)

    def set_passwd_cb(self, callback, userdata=None):
        """
        Set the passphrase callback

        :param callback: The Python callback to use
        :param userdata: (optional) A Python object which will be given as
                         argument to the callback
        :return: None
        """
        if not callable(callback):
            raise TypeError("callback must be callable")

        self._passphrase_helper = self._wrap_callback(callback)
        self._passphrase_callback = self._passphrase_helper.callback
        _lib.SSL_CTX_set_default_passwd_cb(
            self._context, self._passphrase_callback)
        self._passphrase_userdata = userdata

    def set_default_verify_paths(self):
        """
        Use the platform-specific CA certificate locations

        :return: None
        """
        set_result = _lib.SSL_CTX_set_default_verify_paths(self._context)
        if not set_result:
            # TODO: This is untested.
            _raise_current_error()

    def use_certificate_chain_file(self, certfile):
        """
        Load a certificate chain from a file

        :param certfile: The name of the certificate chain file
        :return: None
        """
        if isinstance(certfile, _text_type):
            # Perhaps sys.getfilesystemencoding() could be better?
            certfile = certfile.encode("utf-8")

        if not isinstance(certfile, bytes):
            raise TypeError("certfile must be bytes or unicode")

        result = _lib.SSL_CTX_use_certificate_chain_file(self._context, certfile)
        if not result:
            _raise_current_error()

    def use_certificate_file(self, certfile, filetype=FILETYPE_PEM):
        """
        Load a certificate from a file

        :param certfile: The name of the certificate file
        :param filetype: (optional) The encoding of the file, default is PEM
        :return: None
        """
        if isinstance(certfile, _text_type):
            # Perhaps sys.getfilesystemencoding() could be better?
            certfile = certfile.encode("utf-8")
        if not isinstance(certfile, bytes):
            raise TypeError("certfile must be bytes or unicode")
        if not isinstance(filetype, integer_types):
            raise TypeError("filetype must be an integer")

        use_result = _lib.SSL_CTX_use_certificate_file(self._context, certfile, filetype)
        if not use_result:
            _raise_current_error()

    def use_certificate(self, cert):
        """
        Load a certificate from a X509 object

        :param cert: The X509 object
        :return: None
        """
        if not isinstance(cert, X509):
            raise TypeError("cert must be an X509 instance")

        use_result = _lib.SSL_CTX_use_certificate(self._context, cert._x509)
        if not use_result:
            _raise_current_error()

    def add_extra_chain_cert(self, certobj):
        """
        Add certificate to chain

        :param certobj: The X509 certificate object to add to the chain
        :return: None
        """
        if not isinstance(certobj, X509):
            raise TypeError("certobj must be an X509 instance")

        copy = _lib.X509_dup(certobj._x509)
        add_result = _lib.SSL_CTX_add_extra_chain_cert(self._context, copy)
        if not add_result:
            # TODO: This is untested.
            _lib.X509_free(copy)
            _raise_current_error()

    def _raise_passphrase_exception(self):
        if self._passphrase_helper is None:
            _raise_current_error()
        exception = self._passphrase_helper.raise_if_problem(Error)
        if exception is not None:
            raise exception

    def use_privatekey_file(self, keyfile, filetype=_unspecified):
        """
        Load a private key from a file

        :param keyfile: The name of the key file
        :param filetype: (optional) The encoding of the file, default is PEM
        :return: None
        """
        if isinstance(keyfile, _text_type):
            # Perhaps sys.getfilesystemencoding() could be better?
            keyfile = keyfile.encode("utf-8")

        if not isinstance(keyfile, bytes):
            raise TypeError("keyfile must be a byte string")

        if filetype is _unspecified:
            filetype = FILETYPE_PEM
        elif not isinstance(filetype, integer_types):
            raise TypeError("filetype must be an integer")

        use_result = _lib.SSL_CTX_use_PrivateKey_file(
            self._context, keyfile, filetype)
        if not use_result:
            self._raise_passphrase_exception()

    def use_privatekey(self, pkey):
        """
        Load a private key from a PKey object

        :param pkey: The PKey object
        :return: None
        """
        if not isinstance(pkey, PKey):
            raise TypeError("pkey must be a PKey instance")

        use_result = _lib.SSL_CTX_use_PrivateKey(self._context, pkey._pkey)
        if not use_result:
            self._raise_passphrase_exception()

    def check_privatekey(self):
        """
        Check that the private key and certificate match up

        :return: None (raises an exception if something's wrong)
        """

    def load_client_ca(self, cafile):
        """
        Load the trusted certificates that will be sent to the client (basically
        telling the client "These are the guys I trust").  Does not actually
        imply any of the certificates are trusted; that must be configured
        separately.

        :param cafile: The name of the certificates file
        :return: None
        """

    def set_session_id(self, buf):
        """
        Set the session identifier.  This is needed if you want to do session
        resumption.

        :param buf: A Python object that can be safely converted to a string
        :returns: None
        """

    def set_session_cache_mode(self, mode):
        """
        Enable/disable session caching and specify the mode used.

        :param mode: One or more of the SESS_CACHE_* flags (combine using
            bitwise or)
        :returns: The previously set caching mode.
        """
        if not isinstance(mode, integer_types):
            raise TypeError("mode must be an integer")

        return _lib.SSL_CTX_set_session_cache_mode(self._context, mode)

    def get_session_cache_mode(self):
        """
        :returns: The currently used cache mode.
        """
        return _lib.SSL_CTX_get_session_cache_mode(self._context)

    def set_verify(self, mode, callback):
        """
        Set the verify mode and verify callback

        :param mode: The verify mode, this is either VERIFY_NONE or
                     VERIFY_PEER combined with possible other flags
        :param callback: The Python callback to use
        :return: None

        See SSL_CTX_set_verify(3SSL) for further details.
        """
        if not isinstance(mode, integer_types):
            raise TypeError("mode must be an integer")

        if not callable(callback):
            raise TypeError("callback must be callable")

        self._verify_helper = _VerifyHelper(self, callback)
        self._verify_callback = self._verify_helper.callback
        _lib.SSL_CTX_set_verify(self._context, mode, self._verify_callback)

    def set_verify_depth(self, depth):
        """
        Set the verify depth

        :param depth: An integer specifying the verify depth
        :return: None
        """
        if not isinstance(depth, integer_types):
            raise TypeError("depth must be an integer")

        _lib.SSL_CTX_set_verify_depth(self._context, depth)

    def get_verify_mode(self):
        """
        Get the verify mode

        :return: The verify mode
        """
        return _lib.SSL_CTX_get_verify_mode(self._context)

    def get_verify_depth(self):
        """
        Get the verify depth

        :return: The verify depth
        """
        return _lib.SSL_CTX_get_verify_depth(self._context)

    def load_tmp_dh(self, dhfile):
        """
        Load parameters for Ephemeral Diffie-Hellman

        :param dhfile: The file to load EDH parameters from
        :return: None
        """
        if not isinstance(dhfile, bytes):
            raise TypeError("dhfile must be a byte string")

        bio = _lib.BIO_new_file(dhfile, b"r")
        if bio == _ffi.NULL:
            _raise_current_error()
        bio = _ffi.gc(bio, _lib.BIO_free)

        dh = _lib.PEM_read_bio_DHparams(bio, _ffi.NULL, _ffi.NULL, _ffi.NULL)
        dh = _ffi.gc(dh, _lib.DH_free)
        _lib.SSL_CTX_set_tmp_dh(self._context, dh)

    def set_cipher_list(self, cipher_list):
        """
        Change the cipher list

        :param cipher_list: A cipher list, see ciphers(1)
        :return: None
        """
        if isinstance(cipher_list, _text_type):
            cipher_list = cipher_list.encode("ascii")

        if not isinstance(cipher_list, bytes):
            raise TypeError("cipher_list must be bytes or unicode")

        result = _lib.SSL_CTX_set_cipher_list(self._context, cipher_list)
        if not result:
            _raise_current_error()

    def set_client_ca_list(self, certificate_authorities):
        """
        Set the list of preferred client certificate signers for this server context.

        This list of certificate authorities will be sent to the client when the
        server requests a client certificate.

        :param certificate_authorities: a sequence of X509Names.
        :return: None
        """
        name_stack = _lib.sk_X509_NAME_new_null()
        if name_stack == _ffi.NULL:
            # TODO: This is untested.
            _raise_current_error()

        try:
            for ca_name in certificate_authorities:
                if not isinstance(ca_name, X509Name):
                    raise TypeError(
                        "client CAs must be X509Name objects, not %s objects" % (
                            type(ca_name).__name__,))
                copy = _lib.X509_NAME_dup(ca_name._name)
                if copy == _ffi.NULL:
                    # TODO: This is untested.
                    _raise_current_error()
                push_result = _lib.sk_X509_NAME_push(name_stack, copy)
                if not push_result:
                    _lib.X509_NAME_free(copy)
                    _raise_current_error()
        except:
            _lib.sk_X509_NAME_free(name_stack)
            raise

        _lib.SSL_CTX_set_client_CA_list(self._context, name_stack)

    def add_client_ca(self, certificate_authority):
        """
        Add the CA certificate to the list of preferred signers for this context.

        The list of certificate authorities will be sent to the client when the
        server requests a client certificate.

        :param certificate_authority: certificate authority's X509 certificate.
        :return: None
        """
        if not isinstance(certificate_authority, X509):
            raise TypeError("certificate_authority must be an X509 instance")

        add_result = _lib.SSL_CTX_add_client_CA(
            self._context, certificate_authority._x509)
        if not add_result:
            # TODO: This is untested.
            _raise_current_error()

    def set_timeout(self, timeout):
        """
        Set session timeout

        :param timeout: The timeout in seconds
        :return: The previous session timeout
        """
        if not isinstance(timeout, integer_types):
            raise TypeError("timeout must be an integer")

        return _lib.SSL_CTX_set_timeout(self._context, timeout)

    def get_timeout(self):
        """
        Get the session timeout

        :return: The session timeout
        """
        return _lib.SSL_CTX_get_timeout(self._context)

    def set_info_callback(self, callback):
        """
        Set the info callback

        :param callback: The Python callback to use
        :return: None
        """
        @wraps(callback)
        def wrapper(ssl, where, return_code):
            callback(Connection._reverse_mapping[ssl], where, return_code)
        self._info_callback = _ffi.callback(
            "void (*)(const SSL *, int, int)", wrapper)
        _lib.SSL_CTX_set_info_callback(self._context, self._info_callback)

    def get_app_data(self):
        """
        Get the application data (supplied via set_app_data())

        :return: The application data
        """
        return self._app_data

    def set_app_data(self, data):
        """
        Set the application data (will be returned from get_app_data())

        :param data: Any Python object
        :return: None
        """
        self._app_data = data

    def get_cert_store(self):
        """
        Get the certificate store for the context.

        :return: A X509Store object or None if it does not have one.
        """
        store = _lib.SSL_CTX_get_cert_store(self._context)
        if store == _ffi.NULL:
            # TODO: This is untested.
            return None

        pystore = X509Store.__new__(X509Store)
        pystore._store = store
        return pystore

    def set_options(self, options):
        """
        Add options. Options set before are not cleared!

        :param options: The options to add.
        :return: The new option bitmask.
        """
        if not isinstance(options, integer_types):
            raise TypeError("options must be an integer")

        return _lib.SSL_CTX_set_options(self._context, options)

    def set_mode(self, mode):
        """
        Add modes via bitmask. Modes set before are not cleared!

        :param mode: The mode to add.
        :return: The new mode bitmask.
        """
        if not isinstance(mode, integer_types):
            raise TypeError("mode must be an integer")

        return _lib.SSL_CTX_set_mode(self._context, mode)

    def set_tlsext_servername_callback(self, callback):
        """
        Specify a callback function to be called when clients specify a server name.

        :param callback: The callback function.  It will be invoked with one
            argument, the Connection instance.
        """
        @wraps(callback)
        def wrapper(ssl, alert, arg):
            callback(Connection._reverse_mapping[ssl])
            return 0

        self._tlsext_servername_callback = _ffi.callback(
            "int (*)(const SSL *, int *, void *)", wrapper)
        _lib.SSL_CTX_set_tlsext_servername_callback(
            self._context, self._tlsext_servername_callback)

ContextType = Context

class Connection(object):
    """
    """
    _reverse_mapping = WeakValueDictionary()

    def __init__(self, context, socket=None):
        """
        Create a new Connection object, using the given OpenSSL.SSL.Context
        instance and socket.

        :param context: An SSL Context to use for this connection
        :param socket: The socket to use for transport layer
        """
        if not isinstance(context, Context):
            raise TypeError("context must be a Context instance")

        ssl = _lib.SSL_new(context._context)
        self._ssl = _ffi.gc(ssl, _lib.SSL_free)
        self._context = context

        self._reverse_mapping[self._ssl] = self

        if socket is None:
            self._socket = None
            # Don't set up any gc for these, SSL_free will take care of them.
            self._into_ssl = _lib.BIO_new(_lib.BIO_s_mem())
            self._from_ssl = _lib.BIO_new(_lib.BIO_s_mem())

            if self._into_ssl == _ffi.NULL or self._from_ssl == _ffi.NULL:
                # TODO: This is untested.
                _raise_current_error()

            _lib.SSL_set_bio(self._ssl, self._into_ssl, self._from_ssl)
        else:
            self._into_ssl = None
            self._from_ssl = None
            self._socket = socket
            set_result = _lib.SSL_set_fd(self._ssl, _asFileDescriptor(self._socket))
            if not set_result:
                # TODO: This is untested.
                _raise_current_error()

    def __getattr__(self, name):
        """
        Look up attributes on the wrapped socket object if they are not found on
        the Connection object.
        """
        return getattr(self._socket, name)

    def _raise_ssl_error(self, ssl, result):
        if self._context._verify_helper is not None:
            self._context._verify_helper.raise_if_problem()

        error = _lib.SSL_get_error(ssl, result)
        if error == _lib.SSL_ERROR_WANT_READ:
            raise WantReadError()
        elif error == _lib.SSL_ERROR_WANT_WRITE:
            raise WantWriteError()
        elif error == _lib.SSL_ERROR_ZERO_RETURN:
            raise ZeroReturnError()
        elif error == _lib.SSL_ERROR_WANT_X509_LOOKUP:
            # TODO: This is untested.
            raise WantX509LookupError()
        elif error == _lib.SSL_ERROR_SYSCALL:
            if _lib.ERR_peek_error() == 0:
                if result < 0:
                    if platform == "win32":
                        errno = _ffi.getwinerror()[0]
                    else:
                        errno = _ffi.errno
                    raise SysCallError(errno, errorcode[errno])
                else:
                    raise SysCallError(-1, "Unexpected EOF")
            else:
                # TODO: This is untested.
                _raise_current_error()
        elif error == _lib.SSL_ERROR_NONE:
            pass
        else:
            _raise_current_error()

    def get_context(self):
        """
        Get session context
        """
        return self._context

    def set_context(self, context):
        """
        Switch this connection to a new session context

        :param context: A :py:class:`Context` instance giving the new session
            context to use.
        """
        if not isinstance(context, Context):
            raise TypeError("context must be a Context instance")

        _lib.SSL_set_SSL_CTX(self._ssl, context._context)
        self._context = context

    def get_servername(self):
        """
        Retrieve the servername extension value if provided in the client hello
        message, or None if there wasn't one.

        :return: A byte string giving the server name or :py:data:`None`.
        """
        name = _lib.SSL_get_servername(self._ssl, _lib.TLSEXT_NAMETYPE_host_name)
        if name == _ffi.NULL:
            return None

        return _ffi.string(name)

    def set_tlsext_host_name(self, name):
        """
        Set the value of the servername extension to send in the client hello.

        :param name: A byte string giving the name.
        """
        if not isinstance(name, bytes):
            raise TypeError("name must be a byte string")
        elif b"\0" in name:
            raise TypeError("name must not contain NUL byte")

        # XXX I guess this can fail sometimes?
        _lib.SSL_set_tlsext_host_name(self._ssl, name)

    def pending(self):
        """
        Get the number of bytes that can be safely read from the connection

        :return: The number of bytes available in the receive buffer.
        """
        return _lib.SSL_pending(self._ssl)

    def send(self, buf, flags=0):
        """
        Send data on the connection. NOTE: If you get one of the WantRead,
        WantWrite or WantX509Lookup exceptions on this, you have to call the
        method again with the SAME buffer.

        :param buf: The string to send
        :param flags: (optional) Included for compatibility with the socket
                      API, the value is ignored
        :return: The number of bytes written
        """
        if isinstance(buf, _memoryview):
            buf = buf.tobytes()
        if not isinstance(buf, bytes):
            raise TypeError("data must be a byte string")

        result = _lib.SSL_write(self._ssl, buf, len(buf))
        self._raise_ssl_error(self._ssl, result)
        return result
    write = send

    def sendall(self, buf, flags=0):
        """
        Send "all" data on the connection. This calls send() repeatedly until
        all data is sent. If an error occurs, it's impossible to tell how much
        data has been sent.

        :param buf: The string to send
        :param flags: (optional) Included for compatibility with the socket
                      API, the value is ignored
        :return: The number of bytes written
        """
        if isinstance(buf, _memoryview):
            buf = buf.tobytes()
        if not isinstance(buf, bytes):
            raise TypeError("buf must be a byte string")

        left_to_send = len(buf)
        total_sent = 0
        data = _ffi.new("char[]", buf)

        while left_to_send:
            result = _lib.SSL_write(self._ssl, data + total_sent, left_to_send)
            self._raise_ssl_error(self._ssl, result)
            total_sent += result
            left_to_send -= result

    def recv(self, bufsiz, flags=None):
        """
        Receive data on the connection. NOTE: If you get one of the WantRead,
        WantWrite or WantX509Lookup exceptions on this, you have to call the
        method again with the SAME buffer.

        :param bufsiz: The maximum number of bytes to read
        :param flags: (optional) Included for compatibility with the socket
                      API, the value is ignored
        :return: The string read from the Connection
        """
        buf = _ffi.new("char[]", bufsiz)
        result = _lib.SSL_read(self._ssl, buf, bufsiz)
        self._raise_ssl_error(self._ssl, result)
        return _ffi.buffer(buf, result)[:]
    read = recv

    def _handle_bio_errors(self, bio, result):
        if _lib.BIO_should_retry(bio):
            if _lib.BIO_should_read(bio):
                raise WantReadError()
            elif _lib.BIO_should_write(bio):
                # TODO: This is untested.
                raise WantWriteError()
            elif _lib.BIO_should_io_special(bio):
                # TODO: This is untested.  I think io_special means the socket
                # BIO has a not-yet connected socket.
                raise ValueError("BIO_should_io_special")
            else:
                # TODO: This is untested.
                raise ValueError("unknown bio failure")
        else:
            # TODO: This is untested.
            _raise_current_error()

    def bio_read(self, bufsiz):
        """
        When using non-socket connections this function reads the "dirty" data
        that would have traveled away on the network.

        :param bufsiz: The maximum number of bytes to read
        :return: The string read.
        """
        if self._from_ssl is None:
            raise TypeError("Connection sock was not None")

        if not isinstance(bufsiz, integer_types):
            raise TypeError("bufsiz must be an integer")

        buf = _ffi.new("char[]", bufsiz)
        result = _lib.BIO_read(self._from_ssl, buf, bufsiz)
        if result <= 0:
            self._handle_bio_errors(self._from_ssl, result)

        return _ffi.buffer(buf, result)[:]

    def bio_write(self, buf):
        """
        When using non-socket connections this function sends "dirty" data that
        would have traveled in on the network.

        :param buf: The string to put into the memory BIO.
        :return: The number of bytes written
        """
        if self._into_ssl is None:
            raise TypeError("Connection sock was not None")

        if not isinstance(buf, bytes):
            raise TypeError("buf must be a byte string")

        result = _lib.BIO_write(self._into_ssl, buf, len(buf))
        if result <= 0:
            self._handle_bio_errors(self._into_ssl, result)
        return result

    def renegotiate(self):
        """
        Renegotiate the session

        :return: True if the renegotiation can be started, false otherwise
        """

    def do_handshake(self):
        """
        Perform an SSL handshake (usually called after renegotiate() or one of
        set_*_state()). This can raise the same exceptions as send and recv.

        :return: None.
        """
        result = _lib.SSL_do_handshake(self._ssl)
        self._raise_ssl_error(self._ssl, result)

    def renegotiate_pending(self):
        """
        Check if there's a renegotiation in progress, it will return false once
        a renegotiation is finished.

        :return: Whether there's a renegotiation in progress
        """

    def total_renegotiations(self):
        """
        Find out the total number of renegotiations.

        :return: The number of renegotiations.
        """
        return _lib.SSL_total_renegotiations(self._ssl)

    def connect(self, addr):
        """
        Connect to remote host and set up client-side SSL

        :param addr: A remote address
        :return: What the socket's connect method returns
        """
        _lib.SSL_set_connect_state(self._ssl)
        return self._socket.connect(addr)

    def connect_ex(self, addr):
        """
        Connect to remote host and set up client-side SSL. Note that if the socket's
        connect_ex method doesn't return 0, SSL won't be initialized.

        :param addr: A remove address
        :return: What the socket's connect_ex method returns
        """
        connect_ex = self._socket.connect_ex
        self.set_connect_state()
        return connect_ex(addr)

    def accept(self):
        """
        Accept incoming connection and set up SSL on it

        :return: A (conn,addr) pair where conn is a Connection and addr is an
                 address
        """
        client, addr = self._socket.accept()
        conn = Connection(self._context, client)
        conn.set_accept_state()
        return (conn, addr)

    def bio_shutdown(self):
        """
        When using non-socket connections this function signals end of
        data on the input for this connection.

        :return: None
        """
        if self._from_ssl is None:
            raise TypeError("Connection sock was not None")

        _lib.BIO_set_mem_eof_return(self._into_ssl, 0)

    def shutdown(self):
        """
        Send closure alert

        :return: True if the shutdown completed successfully (i.e. both sides
                 have sent closure alerts), false otherwise (i.e. you have to
                 wait for a ZeroReturnError on a recv() method call
        """
        result = _lib.SSL_shutdown(self._ssl)
        if result < 0:
            # TODO: This is untested.
            _raise_current_error()
        elif result > 0:
            return True
        else:
            return False

    def get_cipher_list(self):
        """
        Get the session cipher list

        :return: A list of cipher strings
        """
        ciphers = []
        for i in count():
            result = _lib.SSL_get_cipher_list(self._ssl, i)
            if result == _ffi.NULL:
                break
            ciphers.append(_native(_ffi.string(result)))
        return ciphers

    def get_client_ca_list(self):
        """
        Get CAs whose certificates are suggested for client authentication.

        :return: If this is a server connection, a list of X509Names representing
            the acceptable CAs as set by :py:meth:`OpenSSL.SSL.Context.set_client_ca_list` or
            :py:meth:`OpenSSL.SSL.Context.add_client_ca`.  If this is a client connection,
            the list of such X509Names sent by the server, or an empty list if that
            has not yet happened.
        """
        ca_names = _lib.SSL_get_client_CA_list(self._ssl)
        if ca_names == _ffi.NULL:
            # TODO: This is untested.
            return []

        result = []
        for i in range(_lib.sk_X509_NAME_num(ca_names)):
            name = _lib.sk_X509_NAME_value(ca_names, i)
            copy = _lib.X509_NAME_dup(name)
            if copy == _ffi.NULL:
                # TODO: This is untested.
                _raise_current_error()

            pyname = X509Name.__new__(X509Name)
            pyname._name = _ffi.gc(copy, _lib.X509_NAME_free)
            result.append(pyname)
        return result

    def makefile(self):
        """
        The makefile() method is not implemented, since there is no dup semantics
        for SSL connections

        :raise NotImplementedError
        """
        raise NotImplementedError("Cannot make file object of OpenSSL.SSL.Connection")

    def get_app_data(self):
        """
        Get application data

        :return: The application data
        """
        return self._app_data

    def set_app_data(self, data):
        """
        Set application data

        :param data - The application data
        :return: None
        """
        self._app_data = data

    def get_shutdown(self):
        """
        Get shutdown state

        :return: The shutdown state, a bitvector of SENT_SHUTDOWN, RECEIVED_SHUTDOWN.
        """
        return _lib.SSL_get_shutdown(self._ssl)

    def set_shutdown(self, state):
        """
        Set shutdown state

        :param state - bitvector of SENT_SHUTDOWN, RECEIVED_SHUTDOWN.
        :return: None
        """
        if not isinstance(state, integer_types):
            raise TypeError("state must be an integer")

        _lib.SSL_set_shutdown(self._ssl, state)

    def state_string(self):
        """
        Get a verbose state description

        :return: A string representing the state
        """

    def server_random(self):
        """
        Get a copy of the server hello nonce.

        :return: A string representing the state
        """
        if self._ssl.session == _ffi.NULL:
            return None
        return _ffi.buffer(
            self._ssl.s3.server_random,
            _lib.SSL3_RANDOM_SIZE)[:]

    def client_random(self):
        """
        Get a copy of the client hello nonce.

        :return: A string representing the state
        """
        if self._ssl.session == _ffi.NULL:
            return None
        return _ffi.buffer(
            self._ssl.s3.client_random,
            _lib.SSL3_RANDOM_SIZE)[:]

    def master_key(self):
        """
        Get a copy of the master key.

        :return: A string representing the state
        """
        if self._ssl.session == _ffi.NULL:
            return None
        return _ffi.buffer(
            self._ssl.session.master_key,
            self._ssl.session.master_key_length)[:]

    def sock_shutdown(self, *args, **kwargs):
        """
        See shutdown(2)

        :return: What the socket's shutdown() method returns
        """
        return self._socket.shutdown(*args, **kwargs)

    def get_peer_certificate(self):
        """
        Retrieve the other side's certificate (if any)

        :return: The peer's certificate
        """
        cert = _lib.SSL_get_peer_certificate(self._ssl)
        if cert != _ffi.NULL:
            pycert = X509.__new__(X509)
            pycert._x509 = _ffi.gc(cert, _lib.X509_free)
            return pycert
        return None

    def get_peer_cert_chain(self):
        """
        Retrieve the other side's certificate (if any)

        :return: A list of X509 instances giving the peer's certificate chain,
                 or None if it does not have one.
        """
        cert_stack = _lib.SSL_get_peer_cert_chain(self._ssl)
        if cert_stack == _ffi.NULL:
            return None

        result = []
        for i in range(_lib.sk_X509_num(cert_stack)):
            # TODO could incref instead of dup here
            cert = _lib.X509_dup(_lib.sk_X509_value(cert_stack, i))
            pycert = X509.__new__(X509)
            pycert._x509 = _ffi.gc(cert, _lib.X509_free)
            result.append(pycert)
        return result

    def want_read(self):
        """
        Checks if more data has to be read from the transport layer to complete an
        operation.

        :return: True iff more data has to be read
        """
        return _lib.SSL_want_read(self._ssl)

    def want_write(self):
        """
        Checks if there is data to write to the transport layer to complete an
        operation.

        :return: True iff there is data to write
        """
        return _lib.SSL_want_write(self._ssl)

    def set_accept_state(self):
        """
        Set the connection to work in server mode. The handshake will be handled
        automatically by read/write.

        :return: None
        """
        _lib.SSL_set_accept_state(self._ssl)

    def set_connect_state(self):
        """
        Set the connection to work in client mode. The handshake will be handled
        automatically by read/write.

        :return: None
        """
        _lib.SSL_set_connect_state(self._ssl)

    def get_session(self):
        """
        Returns the Session currently used.

        @return: An instance of :py:class:`OpenSSL.SSL.Session` or :py:obj:`None` if
            no session exists.
        """
        session = _lib.SSL_get1_session(self._ssl)
        if session == _ffi.NULL:
            return None

        pysession = Session.__new__(Session)
        pysession._session = _ffi.gc(session, _lib.SSL_SESSION_free)
        return pysession

    def set_session(self, session):
        """
        Set the session to be used when the TLS/SSL connection is established.

        :param session: A Session instance representing the session to use.
        :returns: None
        """
        if not isinstance(session, Session):
            raise TypeError("session must be a Session instance")

        result = _lib.SSL_set_session(self._ssl, session._session)
        if not result:
            _raise_current_error()

ConnectionType = Connection

# This is similar to the initialization calls at the end of OpenSSL/crypto.py
# but is exercised mostly by the Context initializer.
_lib.SSL_library_init()

redpajama_set_name: RedPajamaGithub


text:
El premio Internacional de Poesía Emilio Prados es uno de los premios más destacados de la poesía joven en lengua española convocado anualmente por el Centro de la Generación del 27 en la ciudad de Málaga, España.

Patrocinado por la Diputación de Málaga, es un concurso para autores de menos de 35 años y obras inéditas, dotado con 6.000 €. El premio se entrega en un acto ante los medios de comunicación celebrado en el Centro Cultural Provincial. Desde su creación los trabajos ganadores han publicados por la Editorial Pre-Textos.

Ganadores
 2000: Alexis Díaz Pimienta, con Yo también pude ser Jacques Daguerre.
 2001: Carlos Pardo, con Desvelo sin paisaje.
 2002: Antonio Manilla, con Canción gris.
 2003: Josep M. Rodríguez, con La caja negra
 2004: Andrés Navarro, con La fiebre.
 2005: Camilo de Ory, con Lugares comunes.
 2006: Isidro Hernández, con El ciego del alba.
 2007: Juan Manuel Romero, con Hasta mañana.
 2008: Rafael Espejo, con Nos han dejado solos.
 2009: Jorge Omar Ramírez Pimienta, con Escribo desde aquí.
 2010: Jeymer Gamboa, con Días ordinarios.
 2011: Alberto Carpio Jiménez, con Los comensales.
 2012: Lola Mascarell, con Mientras la luz.
 2013: Andrés Catalán, con Ahora solo bebo té.
 2014: Javier Vela, con Hotel origen.
 2015: Juan Bello, con Nada extraordinario.
2016: Alejandro González Luna, con Donde el mar se muere.
2017: Gracia Aguilar Almendros, con Libérame, domine.
2018: Virginia Navalón, con Bestiario.
2019: Ángelo Néstore, con Hágase mi voluntad.
2020: Juan de Beatriz, con Cantar qué.

Referencias

Enlaces externos

 Web de la Diputación de Málaga

Emilio Prados
Eventos en Málaga

redpajama_set_name: RedPajamaWikipedia


text:
General Soccer
Georgia talent on display in NWSL draft today
Two projected to be first round selections
By Jason Longshore@Longshoe Jan 12, 2017, 12:25pm EST
Share All sharing options for: Georgia talent on display in NWSL draft today
Photo by Vaughn Ridley/Getty Images
This afternoon at 3:00 p.m., the National Women's Soccer League will conduct its college draft at the National Soccer Coaches Association of American convention in Los Angeles. Here is a rundown of players with Georgia ties that could be selected:
Alexa Antetomaso, forward, Georgia, Rochester (NY): Antetomaso played four years at Georgia, moving from defense to forward and never truly settling on a position. She played in thirteen games in 2016, scoring once.
Jane Campbell, goalkeeper, Stanford, Kennesaw: Excelle Sports has Campbell going fourth in their NWSL Mock Draft to Sky Blue FC. Many regard her as the best goalkeeper in the 2017 Draft. She was called up to the January USWNT camp and is thought to be in the mix for the starting role moving forward. She featured for Concorde Fire before heading to play in college at Stanford.
Marion Crowder, forward, Georgia, Madison (MS): Crowder was the leading scorer for the Bulldogs in 2016, scoring eight goals in eighteen games. She finished her Georgia career as the third leading scorer in program history.
Savannah Jordan, forward, Florida, Fayetteville: Excelle has Jordan at #7 in their Mock Draft, although they say it is risky due to rumors of Jordan signing overseas. She scored 81 goals during her time at Florida, placing her second in SEC history. Before heading to Gainesville and lighting up the SEC, Jordan was a star for the Concorde Fire South youth program.
Brittney Reed, defender, Kennesaw St., Dallas: Reed was second team All-Conference in 2016, starting the season as a forward before moving to defense. She scored 14 goals in her 59 career matches for the Owls.
Allison Wetherington, midfielder, Portland, Atlanta: Wetherington traveled across the country to represent the Pilots in college. She featured for the U.S. youth national teams at the U18 and U20 levels. In nineteen games in 2016, Wetherington scored four goals and has five assists.


Free shipping to UK,we post our items next working day.
Items will be sent by International Airmail small packets and can take up to 21 days to arrive. Please note,no replacements or refunds will be sent until the 21 day limit has passed.
Normal shipping time to EUROPE 5-7 days.
Normal shipping time to the rest of the world 7-10 days.


A medical billing company needed a full asset inventory. Without the staff and scanners to complete such an inventory, the billing company needed a partner. They connected with RGIS to inventory all state assets within two 3-floor buildings.
To comply with the project's requirements, RGIS had to work on a tight timeline. The quote, inventory event, and data delivery were all completed within 30 days.
RGIS created an asset data collection program that allowed for verification and addition of assets.
Experienced, local teams were deployed through RGIS' scheduling department. Auditors found detailed asset information on new and existing assets.
The client was able to comply with the set requirements and maintained their contract and their reputation as a full-service medical biller.
With RGIS' experienced staff behind you, across the U.S.


text:
June 2015, VOLUME 135 / ISSUE 6
Estimated Number of Infants Detected and Missed by Critical Congenital Heart Defect Screening
Elizabeth C. Ailes, Suzanne M. Gilboa, Margaret A. Honein, Matthew E. Oster
BACKGROUND AND OBJECTIVES: In 2011, the US Secretary of Health and Human Services recommended universal screening of newborns for critical congenital heart defects (CCHDs), yet few estimates of the number of infants with CCHDs likely to be detected through universal screening exist. Our objective was to estimate the number of infants with nonsyndromic CCHDs in the United States likely to be detected (true positives) and missed (false negatives) through universal newborn CCHD screening.
METHODS: We developed a simulation model based on estimates of birth prevalence, prenatal diagnosis, late detection, and sensitivity of newborn CCHD screening through pulse oximetry to estimate the number of true-positive and false-negative nonsyndromic cases of the 7 primary and 5 secondary CCHD screening targets identified through screening.
RESULTS: We estimated that 875 (95% uncertainty interval [UI]: 705–1060) US infants with nonsyndromic CCHDs, including 470 (95% UI: 360–585) infants with primary CCHD screening targets, will be detected annually through newborn CCHD screening. An additional 880 (UI: 700–1080) false-negative screenings, including 280 (95% UI: 195–385) among primary screening targets, are expected. We estimated that similar numbers of CCHDs would be detected under scenarios comparing "lower" (∼19%) and "higher" (∼41%) than current prenatal detection prevalences.
CONCLUSIONS: A substantial number of nonsyndromic CCHD cases are likely to be detected through universal CCHD screening; however, an equal number of false-negative screenings, primarily among secondary targets of screening, are likely to occur. Future efforts should document the true impact of CCHD screening in practice.
What's Known on This Subject:
Newborn screening for critical congenital heart defects (CCHDs) has been implemented in many hospitals, yet there is uncertainty about the number of infants with CCHDs that might be detected through universal implementation of newborn CCHD screening in the United States.
What This Study Adds:
We estimated that ∼875 infants with CCHDs might be detected, and ∼880 missed, annually through universal CCHD screening in the United States. Increases in prenatal diagnosis are unlikely to substantially impact the number of infants detected through CCHD screening.
Congenital heart defects (CHDs) affect ∼8 per 1000 births and ∼25% are considered critical congenital heart defects (CCHDs).1 In 2011 the US Secretary of Health and Human Services recommended adding CCHDs to the newborn Recommended Uniform Screening Panel.2 Subsequently, screening for CCHDs through pulse oximetry, used to supplement standard clinical evaluation and monitoring of newborns, has been implemented in many hospitals.3–5 Screening protocols vary with regard to the age of the newborn at screening and the use of pre- and/or postductal oxygen saturation measurements.4,6 The American Academy of Pediatrics (AAP), the American Heart Association (AHA), and others recommend screening infants at 24 to 48 hours of life with consideration of both pre- and postductal measurements.7
Estimates of the impact of CCHD screening differ.4,8,9 Differences in prenatal diagnosis and "late" detection (ie, CCHD diagnosis after birth hospital discharge9 or after 3 days of life8) by CCHD type and geographic location might contribute to the observed variation.8,10–12 Another potential contributor is the sensitivity of the pulse oximetry screening test; although the overall sensitivity is estimated to be 76%,13 it varies considerably by CCHD type, ranging from 36% to 100%.14
Estimating the number of infants potentially detected ("true positives") and missed ("false negatives") through universal CCHD screening must incorporate 3 key sources of variability: (1) the birth prevalence of the specific CCHD; (2) the prenatal diagnosis prevalence, both across CCHD types and geographic region; and (3) the sensitivity of CCHD screening for different CCHD types. This study incorporated these elements into a simulation model to estimate the number of true-positive and false-negative CCHD cases in the United States likely to result from CCHD screening through pulse oximetry.
We included the 7 CCHDs considered to be "primary" targets of screening: hypoplastic left heart syndrome (HLHS), pulmonary atresia, dextro-transposition of the great arteries (d-TGA), truncus arteriosus, tricuspid atresia, tetralogy of Fallot (TOF), and total anomalous pulmonary venous return (TAPVR).7 We also included the 5 "secondary" targets of CCHD screening: coarctation of the aorta (COA), double-outlet right ventricle, Ebstein anomaly, interrupted aortic arch (IAA), and single ventricle.1 Although critical aortic and pulmonary stenoses are also typically considered CCHDs, we lacked complete data on lesion severity.15 We combined COA and IAA into a single category (COA/IAA) as this was done for one of our data sources.14 To calculate estimates for "all CCHDs" by summing across the specific CCHD estimates, we created a "multiple CCHDs" category including those cases with multiple CCHD diagnoses, such that no case was counted more than once. We restricted the analysis to infants with CCHDs diagnosed before 1 year of life. To better reflect the population of infants eligible for CCHD screening, all analyses were restricted to live-born infants and, for consistency across data sources, restricted to infants without chromosomal abnormalities ("nonsyndromic").
Live-Birth Prevalence
We simulated a 2012 birth cohort of infants with nonsyndromic CCHDs by using data from the Metropolitan Atlanta Congenital Defects Program (MACDP), an active surveillance system for major birth defects in metropolitan Atlanta, Georgia.16 Surveillance is conducted for infants, fetuses, and stillbirths >20 weeks' gestational age with major birth defects identified before 6 years of age. Trained abstractors visit birth hospitals, pediatric hospitals, specialty clinics, and perinatal offices to identify and abstract clinical and demographic information on potential cases. CHD cases are classified by clinicians with expertise in pediatric cardiology.17 For our analysis, we updated the analysis by Oster et al15 to calculate the 2000–2005 live-birth prevalence of the 12 selected CCHD types.
Frequency of Prenatal Diagnosis
Prenatal diagnosis was estimated by using data from the National Birth Defects Prevention Study (NBDPS), a multisite case-control study of risk factors for select major birth defects, including CCHDs.18 Cases were identified through birth defects surveillance systems in 10 US sites; infants with recognized or strongly suspected single-gene disorders or chromosomal abnormalities were excluded. Trained abstractors reviewed medical records of infants/fetuses with CCHDs and, to be included in the study, CCHD cases had to be confirmed by echocardiography, cardiac catheterization, surgery, or autopsy.18 Prenatally diagnosed cases were included only if confirmed by autopsy or by a clinician with expertise in pediatric cardiology.19 CCHD type(s) were assigned by physicians with specialized training in clinical genetics or pediatric cardiology.19 We defined prenatal diagnosis as (1) a maternal report of a prenatal diagnosis of a CHD (as had been done in a previous analysis10) and/or (2) clinical record of a fetal echocardiography before the date of birth. Then, for each CCHD type, we calculated the 2000–2005 prenatal diagnosis prevalence.
Frequency of Late Detection
NBDPS data were also used to estimate the prevalence of "late" CCHD detection.8 Previously, we categorized infants with echocardiography or autopsy information as having "timely" CCHD detection if their first documented echocardiography was within 3 days of birth and as having "late" CCHD detection if their first echocardiography (or autopsy) occurred after the third day of life.8 Here, we modified the analysis slightly to be restricted to infants without a prenatal diagnosis (as defined above). We calculated the 2000–2005 late detection prevalence among live-born infants without a prenatal diagnosis.
Sensitivity of Newborn CCHD Screening Through Pulse Oximetry
We obtained CCHD-specific estimates of the sensitivity of screening through pulse oximetry from a review by Prudhoe et al,14 which used mutually exclusive CCHD categories but did not provide estimates for Ebstein anomaly or "multiple CCHDs." We summed the number of cases reported to be detected through CCHD screening using pulse oximetry and the total number of cases screened, across all secondary screening targets, to obtain an estimate of screening sensitivity for Ebstein anomaly, and across all CCHDs, to obtain an estimate for multiple CCHDs.
For each CCHD, we estimated the number of true-positive and false-negative cases resulting from CCHD screening through pulse oximetry (Fig 1). To account for uncertainty in our birth prevalence, prenatal diagnosis, late detection, and CCHD screening sensitivity for each CCHD type, we used normal distributions based on the reported estimated means and SEs for these variables (Table 1). However, there were 4 estimates of CCHD screening sensitivity that were based on exceptionally small numbers (≤10 total cases) and, for 3 of them, there was no sample variance associated with the estimate. For these variables, we used a uniform distribution based on the lower and upper 95% confidence limits of the Wilson score exact 95% confidence interval (CI) (Table 1). We then used a Monte Carlo simulation approach and drew 10 000 samples from the distributions of each of the variable estimates, as described above. For each simulation, to avoid negative values, simulated values were truncated with a lower bound at zero cases. We summarized the results of the 10 000 simulations using the mean and a 95% uncertainty interval (UI) defined by the 2.5th and 97.5th percentiles of the distribution of simulated values. Because we had created mutually exclusive CCHD categories throughout the analysis, for each simulation we calculated the sum of each variable of interest and summarized the results of the simulation using the same statistics (mean, 95% UI) to obtain our estimates for "all CCHDs." To further reflect uncertainty in our estimates, we rounded estimates to the nearest 5 cases.
Model estimating the number of US nonsyndromic CCHD cases in 2012 estimated to be born alive, prenatally diagnosed, born undiagnosed, timely detected, and late detected and false negatives and true positives of CCHD screening through pulse oximetry, assuming universal implementation of CCHD screening in all states.
Simulation Model Inputs Used To Estimate the Number of True-Positive and False-Negative Nonsyndromic CCHD Cases Resulting From CCHD Screening Using Pulse Oximetry in 2012 in the United States, Assuming Universal Implementation of CCHD Screening in All States
As a secondary analysis, we repeated the analysis under scenarios of "lower" and "higher" prevalence of prenatal diagnosis than the current estimates. Using NBDPS data, we identified the 3 sites with the highest and 3 with the lowest prevalence of prenatal detection. We calculated the prevalence of prenatal diagnosis and late detection within each of these subgroups and used them as separate inputs into our simulation model, while keeping the same estimates for birth prevalence and CCHD screening sensitivity as in the primary analysis.
Analyses were performed by using SAS, version 9.3 (SAS Institute, Cary, NC). The MACDP was approved by the institutional review board at the Centers for Disease Control and Prevention and NBDPS by institutional review boards at the Centers for Disease Control and Prevention and study sites.
As inputs for our simulation, we estimated that the 2000–2005 live-birth prevalence for specific nonsyndromic CCHDs ranged from 0.36 (0.11) per 10 000 births for multiple CCHDs to 3.90 (0.36) per 10 000 births for TOF (Table 1). Prenatal diagnosis was most frequent for HLHS and single ventricle and lowest for TAPVR and COA/IAA. Late detection (diagnosis at >3 days of birth) was more common for infants with COA/IAA and less frequent for infants with pulmonary atresia and d-TGA.
The simulation estimated that 5965 infants (95% UI: 5415–6515) are born alive with at least 1 nonsyndromic CCHD annually in the United States, with TOF, COA/IAA, d-TGA, and HLHS accounting for ∼75% of all live-born CCHD cases (Table 2). Excluding CCHD cases estimated to be detected prenatally (n = 1800 overall), an estimated 2410 CCHDs (95% UI: 2150–2680) would receive a timely diagnosis and 1755 CCHD cases (95% UI: 1540–1980) would be detected "late" (at >3 days of birth) and be most likely to benefit from CCHD screening through pulse oximetry; infants with COA/IAA accounted for approximately half of late-detected cases.
Monte Carlo Simulation Model Estimates of the Number of Nonsyndromic CCHD Cases in 2012 in the United States Estimated to be Born Alive, Prenatally Diagnosed, Born Undiagnosed, Timely Detected, and Late Detected and True Positives and False Negatives Resulting From CCHD Screening Through Pulse Oximetry, Assuming Universal Implementation of CCHD Screening in All States
After accounting for the estimates of CCHD screening sensitivity using pulse oximetry, we estimated that 875 (95% UI: 705–1060) infants with CCHDs in the United States, including 470 (95% UI: 360–585) among primary CCHD screening targets alone, would be detected by using CCHD screening through pulse oximetry (true positives) each year, corresponding to ∼15% of all CCHD cases (Fig 2). An additional 880 (95% UI: 700–1080; 280 [95% UI: 195–385] among primary screening targets alone) would be missed (false negatives), corresponding to ∼15% of all CCHD cases (Fig 2). COA/IAA and TOF cases were the main contributors to both of these estimates. CCHD screening through pulse oximetry appears to offer the greatest benefit for infants with TAPVR, double-outlet right ventricle, and COA/IAA; 20% to 30% of cases of each of these defects were estimated to be detected through CCHD screening with the use of pulse oximetry (Fig 2).
Proportion of US nonsyndromic CCHD cases in 2012 estimated to be prenatally diagnosed, and timely detected and true positives and false negatives of CCHD screening through pulse oximetry, by CCHD type, assuming universal implementation of CCHD screening in all states. DORV, double-outlet right ventricle; Multiple, multiple CCHDs.
In our secondary analysis, under a scenario assuming "low" prenatal detection across the United States (19% across all CCHD types; Supplemental Table 4), we estimated that ∼1105 (95% UI: 885–1350) true-positive and 1020 (95% UI: 805–1260) false-negative CCHD cases would result from CCHD screening by using pulse oximetry, corresponding to ∼2.80 and 2.58 cases per 10 000 live births annually (Table 3). Comparatively, in a scenario assuming "high" prenatal detection (41% across all CCHD types; Supplemental Table 4), we estimated that ∼740 (95% UI: 575–925) true-positive and an additional 785 (95% UI: 610–975) false-negative CCHD cases would result from CCHD screening by using pulse oximetry, corresponding to ∼1.87 and 1.99 cases per 10 000 live births annually (Table 3).
Monte Carlo Simulation Model Estimates of Number of Nonsyndromic CCHD Cases in 2012 in the United States Estimated to be Prenatally Diagnosed, Timely Detected, and True Positives and False Negatives Resulting From CCHD Screening Through Pulse Oximetry, Assuming Universal Implementation of CCHD Screening in All States, in the Primary Analysis and Under Scenarios of Low and High Prenatal Diagnosis Prevalence
We estimated that ∼900 infants with nonsyndromic CCHDs could be detected annually in the United States through universal implementation of CCHD screening with the use of pulse oximetry. The majority of these infants would be those with CCHDs less likely to be detected prenatally or clinically at birth, such as COA/IAA, TOF, or d-TGA. These estimates were reassuring in that very few cases (0%–16% overall) of defects considered to be "primary" targets of CCHD screening were estimated to be false negatives. However, due to high birth prevalence, low prenatal detection rates, and limited CCHD screening sensitivity,14 an estimated ∼900 infants with nonsyndromic CCHDs, primarily those with COA/IAA or TOF, were likely to be false negatives resulting from CCHD screening through pulse oximetry, suggesting that the sensitivity of CCHD screening in practice for all primary and secondary targets combined may be closer to 50% than the previous estimate of 76%.13 In our secondary analysis, despite the large difference in the proportion of infants with nonsyndromic CCHDs identified prenatally under scenarios of "low" compared with "high" prenatal diagnosis prevalence (19% vs 41%), the subsequent large difference in the number of infants with undiagnosed CCHDs at birth was greatly diminished by "timely" diagnosis. Thus, the number of true-positive nonsyndromic CCHD cases estimated to be identified by CCHD screening was relatively similar across the 2 prenatal screening scenarios (within ∼1 case per 10 000 live births), even though the relative difference was ∼50%.
Our estimate of the number of infants with CCHDs likely to be detected through screening (875; 95% UI: 705–1060) is similar to the 1189 estimate from a recent cost-effectiveness analysis.20 Differences may be attributable to the inclusion of infants with genetic syndromes in the cost-effectiveness analysis or their use of overall estimates of prenatal diagnosis, late detection, and screening sensitivity for all CCHDs combined rather than each specific CCHD type. Our estimate differs from that suggested by a report describing the first 9 months of CCHD screening in New Jersey, the first state to mandate and implement statewide CCHD screening, which found that 3 infants with CCHDs were detected through screening alone.4 If extrapolated to the annual US birth population, the New Jersey experience equates to ∼220 CCHD cases,* which is much lower than our estimate. One potential reason for this discrepancy may be differences in prenatal diagnosis prevalence. Of the 55 infants with CCHDs identified in the New Jersey study, 48 (87%) were not reported as having a failed screen for a number of potential reasons, including having a prenatal diagnosis.4
In our analysis, a large proportion of nonsyndromic CCHD cases estimated to be both missed and detected through CCHD screening were infants with COA/IAA. Because COA can have varying degrees of severity that may confer varying levels of hypoxia, it is possible that the more severe cases of coarctation are more likely to be detected prenatally or possibly identified through CCHD screening, but less severe cases may be missed. Furthermore, unlike some previous studies of CCHD screening sensitivity,13,14 our CCHD definition allowed for diagnosis of CCHD within 1 year, rather than 28 days, of life, also potentially leading us to include less severe cases of COA. However, we were unable to examine the impact of severity of these lesions on the likelihood of being detected prenatally or through CCHD screening because information on severity was not available in our data sources.
Although this analysis focused on CCHD cases likely to be detected and missed through universal CCHD screening, infants with non-CCHD conditions are likely to result in "false-positive" screens. In a meta-analysis of 13 studies of CCHD screening through pulse oximetry, Thangaratinam et al13 estimated the false-positive rate to be 0.14% (95% CI: 0.06%–0.33%), which dropped to 0.05% (95% CI: 0.02%–0.12%) when screening was conducted at >24 hours after birth, the time frame recommended by the AAP, the AHA, and others.7 Although infants with false-positive screens do not have CCHDs, they may have other clinically relevant conditions that contributed to their failed screening, including pneumonia and sepsis.4,21
Our analysis was subject to additional limitations. We restricted our estimates of birth prevalence, prenatal diagnosis, and late detection to 2000–2005 because we were only able to obtain maternal report of prenatal diagnosis through 2005 in the NBDPS.10 Our birth prevalence estimates were restricted to only the 5 central counties of metropolitan Atlanta and our prenatal diagnosis and late detection estimates were derived from a study conducted in 10 states; thus, our estimates may not be reflective of the entire United States. Despite potential improvements in prenatal diagnosis over time22 and differing definitions of prenatal diagnosis, our range of prenatal diagnosis estimates from 2000–2005 NBDPS data was consistent with those from a study that used national 2006–2012 Society of Thoracic Surgeons data (unpublished data), and our "high" prenatal diagnosis estimates were similar to a recent analysis of Massachusetts data.22 Our definition of late-detected CCHDs was based on the timing of the first-documented echocardiography confirming the defect, not necessarily the first time echocardiography was ever performed; thus, some infants may have been misclassified. However, our overall estimate of late detection is similar to that of a study in a cohort of Florida births, in which the authors defined late detection as diagnosis after birth hospitalization.9 In addition, it is possible that some infants that we classified as having "timely" diagnosis could still have benefited from screening; thus, our estimates may be altered if screening is performed earlier. An additional limitation is that we relied on published estimates of CCHD-specific screening sensitivity that included studies with screening algorithms different from that recommended by the AAP, AHA, and others and we were unable to assess the impact of these differences, such as the age at screening, in our study. It is possible that the classification of specific defects differed across our other data sources (MACDP, NBDPS, Prudhoe et al14). Finally, our estimates of the number of infants potentially detected through CCHD screening only apply to the subset of infants, estimated to be ∼88%,15 with CCHDs not associated with a genetic syndrome.
In the absence of national implementation and data collection on CCHD screening, our analysis used modeling approaches to estimate the potential impact of screening and had several strengths, which make it a valuable contribution to the literature. We used data from a population-based active surveillance system to estimate CCHD prevalence and a population-based case-control study to estimate prenatal diagnosis and late detection. To better account for uncertainty, we used a range of estimates for our model variables (typically the mean and SE). In addition, estimates from our secondary analysis allow public health professionals and policy makers to consider the prevalence of prenatal diagnosis in their communities when estimating the likely impact of CCHD screening.
On the basis of our model, nearly 900 infants per year with nonsyndromic CCHDs are likely to be detected through universal CCHD screening in the United States; however, an equal number are likely to be missed. Although many infants with CCHDs will likely be identified through screening, there will still be many false negatives, suggesting that the general practitioner should not rely on CCHD screening alone to rule out a CCHD.23 Our analysis also suggests that increases in prenatal diagnosis of CCHDs are unlikely to substantially impact the number of infants detected through CCHD screening. Future efforts should focus on documenting the true impact of CCHD screening in practice, and linking CCHD screening data with birth defects surveillance data,24 to identify the outcome of infants with false-negative screening results.
* Calculation: 3 infants identified in 9 months is equivalent to 4 infants identified in 12 months; 4 infants identified through screening per 73 000 births in New Jersey × ∼4,000,000 births in the United States = 219/year in the United States.
Accepted March 6, 2015.
Address correspondence to Elizabeth C. Ailes, PhD, MPH, National Center on Birth Defects and Developmental Disabilities, Centers for Disease Control and Prevention, 1600 Clifton Rd NE, MS E-86, Atlanta, GA 30329. E-mail: eailes{at}cdc.gov
Dr Ailes conceptualized and designed the study, acquired the data, carried out the analysis and interpretation of the data, drafted the initial manuscript, and reviewed and revised the manuscript; Drs Gilboa, Honein, and Oster conceptualized and designed the study and reviewed and revised the manuscript; and all authors approved the final manuscript as submitted and agree to be accountable for all aspects of the work in ensuring that questions related to the accuracy or integrity of any part of the work are appropriately investigated and resolved.
The findings and conclusions in this report are those of the authors and do not necessarily represent the official position of the Centers for Disease Control and Prevention.
FINANCIAL DISCLOSURE: The authors have indicated they have no financial relationships relevant to this article to disclose.
FUNDING: This work was partially supported through cooperative agreements under PA 96043, PA 02081, and FOA DD09-001 from the Centers for Disease Control and Prevention.
POTENTIAL CONFLICT OF INTEREST: The authors have indicated they have no potential conflicts of interest to disclose.
Mahle WT,
Newburger JW,
Matherne GP,
et al.,
American Heart Association Congenital Heart Defects Committee of the Council on Cardiovascular Disease in the Young, Council on Cardiovascular Nursing, Interdisciplinary Council on Quality of Care and Outcomes Research,
American Academy of Pediatrics Section on Cardiology and Cardiac Surgery,,
Committee on Fetus and Newborn
. Role of pulse oximetry in examining newborns for congenital heart disease: a scientific statement from the AHA and AAP. Pediatrics. 2009;124(2):823–836pmid:19581259
Secretary's Advisory Committee on Heritable Disorders in Newborns and Children. HHS Secretary adopts recommendation to add critical congenital heart disease to the Recommended Uniform Screening Panel. September 21, 2011. Available at: www.HRSA.Gov/advisorycommittees/mchbadvisory/heritabledisorders/recommendations/correspondence/cyanoticheartsecre09212011.pdf. Accessed October 20, 2014
. Assessment of current practices and feasibility of routine screening for critical congenital heart defects—Georgia, 2012. MMWR Morb Mortal Wkly Rep. 2013;62(15):288–291pmid:23594685
Garg LF,
Van Naarden Braun K,
Knapp MM,
. Results from the New Jersey statewide critical congenital heart defects screening program. Pediatrics. 2013;132(2):e314–e323pmid:23858425
American Academy of Pediatrics Division of State Government Affairs. CCHD screening map. Available at: www.Cqstatetrack.Com/texis/viewrpt/main.Html?Event=4f7f371574&run=y. Accessed May, 14, 2014
Walsh W
. Evaluation of pulse oximetry screening in middle Tennessee: cases for consideration before universal screening. J Perinatol. 2011;31(2):125–129pmid:20508595
Kemper AR,
Martin GR,
. Strategies for implementing screening for critical congenital heart disease. Pediatrics. 2011;128(5):e1259–e1267pmid:21987707
Peterson C,
Ailes E,
Riehle-Colarusso T,
. Late detection of critical congenital heart disease among US infants: estimation of the potential impact of proposed universal screening using pulse oximetry. JAMA Pediatr. 2014;168(4):361–370pmid:24493342
Dawson A,
Grosse SD,
. Hospitalizations, costs, and mortality among infants with critical congenital heart disease: how important is timely detection? Birth Defects Res A Clin Mol Teratol. 2013;97(10):664–672pmid:24000201
Ailes EC,
Gilboa SM,
National Birth Defects Prevention Study
. Prenatal diagnosis of nonsyndromic congenital heart defects. Prenat Diagn. 2014;34(3):214–222pmid:24222433
Friedberg MK,
Silverman NH,
Moon-Grady AJ,
. Prenatal detection of congenital heart disease. J Pediatr. 2009;155(1):26–31, e1pmid:19394031
Pinto NM,
Keenan HT,
Minich LL,
Puchalski MD,
Heywood M,
Botto LD
. Barriers to prenatal detection of congenital heart disease: a population-based study. Ultrasound Obstet Gynecol. 2012;40(4):418–425pmid:21998002
Thangaratinam S,
Daniels J,
Ewer AK,
Zamora J,
Khan KS
. Accuracy of pulse oximetry in screening for congenital heart disease in asymptomatic newborns: a systematic review. Arch Dis Child Fetal Neonatal Ed. 2007;92(3):F176–F180pmid:17344253
Prudhoe S,
Abu-Harb M,
Richmond S,
Wren C
. Neonatal screening for critical cardiovascular anomalies using pulse oximetry. Arch Dis Child Fetal Neonatal Ed. 2013;98(4):F346–F350pmid:23341250
Oster ME, Lee KA, Honein MA, Riehle-Colarusso T, Shin M, Correa A. Temporal trends in survival among infants with critical congenital heart defects. Pediatrics. 2013;131(5):e1502–e1508
Correa A,
Cragan JD,
Kucik JE,
. Reporting birth defects surveillance data 1968-2003. Birth Defects Res A Clin Mol Teratol. 2007;79(2):65–186pmid:17278144
Strickland MJ,
Reller MD,
. Improving the quality of surveillance data on congenital heart defects in the metropolitan Atlanta congenital defects program. Birth Defects Res A Clin Mol Teratol. 2007;79(11):743–753pmid:17990334
Yoon PW,
Rasmussen SA,
Lynberg MC,
. The National Birth Defects Prevention Study. Public Health Rep. 2001;116(suppl 1):32–40pmid:11889273
Botto LD,
Lin AE,
Malik S,
. Seeking causes: classifying and evaluating congenital heart defects in etiologic studies. Birth Defects Res A Clin Mol Teratol. 2007;79(10):714–727pmid:17729292
Oster ME,
Olney RS,
Cassell CH
. Cost-effectiveness of routine screening for critical congenital heart disease in US newborns. Pediatrics. 2013;132(3):e595–e603pmid:23918890
Middleton LJ,
Furmston AT,
PulseOx Study Group
. Pulse oximetry screening for congenital heart defects in newborn infants (PulseOx): a test accuracy study. Lancet. 2011;378(9793):785–794pmid:21820732
Liberman RF,
Getz KD,
. Delayed diagnosis of critical congenital heart defects: trends and associated factors. Pediatrics. 2014;134(2):e373–e381pmid:25070301
Colarusso T,
Glidewell J
. Screening for critical congenital heart disease: a matter of sensitivity. Pediatr Cardiol. 2013;34(1):203–204pmid:23179425
. Newborn screening for critical congenital heart disease: essential public health roles for birth defects monitoring programs. Birth Defects Res A Clin Mol Teratol. 2012;94(12):965–969pmid:23184496
Hamilton BE,
Martin JA,
Ventura SJ
. Births: preliminary data for 2012. Natl Vital Stat Rep. 2013;62(3):1–20pmid:24321416
You are going to email the following Estimated Number of Infants Detected and Missed by Critical Congenital Heart Defect Screening
Pediatrics Jun 2015, 135 (6) 1000-1008; DOI: 10.1542/peds.2014-3662


There's nothing quite like being an only child.
Or, at least, that's what I was led to believe for most of my life. My friends with both older and younger siblings were jealous I didn't have to share toys or clothes, my mother mollycoddled me and my grandmother always cooked the food I wanted.
When I turned 19, that changed. Over dinner, my mom told me she was expecting another baby with her boyfriend at the time.
Naturally, I was livid. I was no longer going to be treated as the princess of the family.
I was at an age where the baby could've easily passed as my own. As my friends continued to remind me, when I turned 40, the baby would be 20. What kind of sense was that supposed to make?
Then, several months later, my little sister was born.
She was small and fuzzy with a scent like love and powder.
I knew I loved her when her hands reflexively closed around my finger, like she could already foresee all the times she'd have to hold my hand when crossing the road, or walking in the dark when she was scared.
She also teaches me just as much as I taught her. For that, I'll always be grateful.
1. Sisters prepare you for parenthood.
I can't even recall how many times a stranger thought my little sister was actually my daughter. She doesn't even look like me!
When you're significantly older than your sibling, you absorb some of the responsibilities a parent does.
You not only change diapers, prepare meals and clean up, but you also take him or her to the doctor, calm down any temper tantrums and chaperone playdates.
You become the de facto parent. It's a great prep for when you're ready to have children of your own.
2. You learn babies are rarely Instagram-perfect.
Babies are giant and adorable Whoopee Cushions. They burp, puke and something is always coming out of their asses.
Babies also have the uncanny habit of covering themselves in precisely the grossest thing they can get their hands on, whether it be mud, sh*t or mushy pea baby food.
There's a reason babies are always sleeping peacefully in their Instagram debuts.
3. She taught you all about unconditional love.
If you spent most of your life as an only child, your only idea of unconditional love probably stems from your parents.
You had to learn to love a new baby, it wasn't just ingrained from an early age. You worked for it.
When your siblings are close in age to you, you're always fighting over the same toys, clothes and attention from your family.
When you are a much older sibling, you're not at all interested in your little sister's toys.
Regardless of how many times your mom assures your baby sis that she's actually the favorite, you're old enough to know your family will always love you.
5. You can play the adult card.
Your age makes you an authority figure.
She has to listen when you boss her around, because you're supposed to be the one who knows better.
6. She gives you something to fight for.
If someone picks on my sister at the playground or if a boy makes her cry, I will practically skin someone alive.
My mom might have qualms about getting her hands dirty if someone upsets her little girl, but I don't.
7. She looks up to you.
To her, you're somewhere between a parent and a friend.
You're old enough to make rules, but young enough to break them every so often. She knows she can tell you her secrets and she's still young enough to wholly trust you.
8. She has moments of extreme generosity.
Every time my sister willingly gives up the last piece of candy or gave me her favorite doll to play with, I know she trusts me with something precious to her.
I can never forget that.
9. Because she won't be into boys (or girls) for a long time.
I won't have to hear about how Jake broke her heart or about the cute boy in her geometry class for many, many years.
10. Because dress up will always be both of our favorite pastimes.
It's like having a real life Madame Alexander doll to play with.
Good thing she's into frills, tutus and pink.
11. Because she still thinks makeup is for playtime.
She doesn't try on my lipstick or play with my eyeshadow because she thinks it'll make her prettier.
She just does it because she likes putting crazy colors on her face and scaring everyone.
12. She allows me to do crazy sh*t to her hair.
From wacky fishtail braids to hair chalk, she's always down for something that looks cool.
13. She gives me an excuse to watch the best TV of all time.
If you haven't discovered the perfection of "Peppa Pig," "Mickey Mouse Clubhouse" or "Sofia the First" yet, you're seriously missing out.
14. Because tea time will always be a good time.
Even if it's just pretend.


text:
Gearhouse Broadcast has a rich heritage in providing complete production facilities and project management support for major televised events around the world. We help you manage the operation from start to finish, offering everything from consultancy, planning and design through to set-up, pre-production, logistics, crewing and onsite infrastructure.
From sport to reality TV, studio to outside broadcast, we have an impeccable record for delivering high-quality, innovative solutions that enable complex high-definition broadcasts wherever they're needed.
Whatever the event, Gearhouse delivers comprehensive host broadcast services, including multilateral coverage, unilateral production and commentary solutions. Our recent projects include portable units for international broadcast centres, technical operations centres, production control rooms, edit suites, studios, ENG facilities and remote production.
These Flyaways have been used at some of the world's most prestigious sporting events, including football World Cups, Olympic Games and Gram Slam tennis tournaments. We have also been the sole broadcast facility provider for such household hits as I'm A Celebrity…Get Me Out Of Here.
We build our packages using state-of-the-art technology, including UHD, 4K and IP systems, and we also offer a full range of temporary cable solutions, featuring the latest SMPTE, TAC and Triax fibre technologies.
Our specialist personnel will help with your entire project, advising on the best use of technology to meet your objectives cost-effectively – wherever and whenever you need us.
Find out more about our Flypacks
Host broadcast
Gearhouse Broadcast has the expertise and capacity to deliver first-class host broadcasting support anywhere in the world. From initial consultancy through to onsite management, our team is renowned across the industry for its unparalleled experience, reliability and customer service.
Whether it's a single venue or multi-site broadcast, our comprehensive solutions range from internet streaming through to designing, building and integrating full-service International Broadcast Centres, Master Control Rooms, Venue Technical Operation Centres, Commentary Control Rooms, Production Control Rooms and Media Centres.
With offices in the UK, Australia, USA, Qatar, France and now Germany, Gearhouse Broadcast is renowned for supplying high-quality remote production facilities and project management support for large-scale live and near-live events locally or on location anywhere in the world.
With the latest technological advancements, remote production can transport signals over fibre or IP circuits with high security and low latency. Compact remote equipment minimises cost, is easy to set up, and can support multiple events across a number of venues in a single day.
Designed to feel just like home for your crew, our engineers can set up a temporary studio for you anywhere you may need it. Whether it's a pop-up studio for a one-off event or a semi-permanent installation to increase the capacity of your own facilities, we have the kit and expertise to cover it – onsite at the event or at a location of your choosing.
We also provide as much technical support as you need, allowing you to focus on the content you want to capture, and we have editing equipment and staff available to look after post-production and delivery requirements.
Commentary solutions
As part of our mission to deliver greater value to our clients, we have developed a complete commentary infrastructure service for live sports productions. This new service allows rights owners to deliver bespoke broadcasts to their audiences – either on site at the stadium or remotely – while keeping production costs down.
The commentary service uses real-time audio-over-IP networking technology. This enables us to deliver a fully flexible IP contribution network that eliminates the need to use ageing ISDN lines and having to patch in each commentator manually.


text:
Psyche: A Journal of Entomology
Society Affiliation ·
To receive news and publication updates for Psyche: A Journal of Entomology, enter your email address in the box below.
Volume 2012, Article ID 896473, 8 pages
Undecomposed Twigs in the Leaf Litter as Nest-Building Resources for Ants (Hymenoptera: Formicidae) in Areas of the Atlantic Forest in the Southeastern Region of Brazil
Tae Tanaami Fernandes,1 Rogério Rosa da Silva,2 Débora Rodrigues de Souza,1 Natália Araújo,1 and Maria Santina de Castro Morini1
1Laboratório de Mirmecologia, Universidade de Mogi das Cruzes, 08701-970 Mogi das Cruzes, SP, Brazil
2Museu de Zoologia da Universidade de São Paulo, Avenida Nazaré 481, Ipiranga, 04263-000 São Paulo, SP, Brazil
Received 12 June 2012; Revised 15 September 2012; Accepted 17 September 2012
Academic Editor: Diana E. Wheeler
Copyright © 2012 Tae Tanaami Fernandes et al. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.
In tropical forests, the leaf-litter stratum exhibits one of the greatest abundances of ant species. This diversity is associated with the variety of available locations for nest building. Ant nests can be found in various microhabitats, including tree trunks and fallen twigs in different stages of decomposition. In this study, we aimed to investigate undecomposed twigs as nest-building resources in the leaf litter of dense ombrophilous forest areas in the southeastern region of Brazil. Demographic data concerning the ant colonies, the physical characteristics of the nests, and the population and structural of the forest were observed. Collections were performed manually over four months in closed canopy locations that did not have trails or flooded areas. A total of 294 nests were collected, and 34 ant species were recorded. Pheidole, Camponotus, and Hypoponera were the richest genera observed; these genera were also among the most populous and exhibited the greatest abundance of nests. We found no association between population size and nest diameter. Only tree cover influenced the nest abundance and species richness. Our data indicate that undecomposed twigs may be part of the life cycle of many species and are important for maintaining ant diversity in the leaf litter.


text:
<!DOCTYPE html>
<meta charset=utf-8>
<title>empty src is not valid</title>
<iframe src=""></iframe>