bidi/algorithm.py
def resolve_neutral_types(storage, debug):
    """Resolving neutral types. Implements N1 and N2

    See: http://unicode.org/reports/tr9/#Resolving_Neutral_Types

    """

    for run in storage['runs']:
        start, length = run['start'], run['length']
        # use sor and eor
        chars = [{'type': run['sor']}] + storage['chars'][start:start+length] +\
                [{'type': run['eor']}]
        total_chars = len(chars)

        seq_start = None
        for idx in range(total_chars):
            _ch = chars[idx]
            if _ch['type'] in ('B', 'S', 'WS', 'ON'):
                # N1. A sequence of neutrals takes the direction of the
                # surrounding strong text if the text on both sides has the same
                # direction. European and Arabic numbers act as if they were R
                # in terms of their influence on neutrals. Start-of-level-run
                # (sor) and end-of-level-run (eor) are used at level run
                # boundaries.
                if seq_start is None:
                    seq_start = idx
                    prev_bidi_type = chars[idx-1]['type']
            else:
                if seq_start is not None:
                    next_bidi_type = chars[idx]['type']

                    if prev_bidi_type in ('AN', 'EN'):
                        prev_bidi_type = 'R'

                    if next_bidi_type in ('AN', 'EN'):
                        next_bidi_type = 'R'

                    for seq_idx in range(seq_start, idx):
                        if prev_bidi_type == next_bidi_type:
                            chars[seq_idx]['type'] = prev_bidi_type
                        else:
                            # N2. Any remaining neutrals take the embedding
                            # direction. The embedding direction for the given
                            # neutral character is derived from its embedding
                            # level: L if the character is set to an even level,
                            # and R if the level is odd.
                            chars[seq_idx]['type'] = \
                                _embedding_direction(chars[seq_idx]['level'])

                    seq_start = None

    if debug:
        debug_storage(storage)
def resolve_neutral_types(storage, debug):
    for run in storage['runs']:
        start, length = run['start'], run['length']
        # use sor and eor
        chars = [{'type': run['sor']}] + storage['chars'][start:start+length] +\
                [{'type': run['eor']}]
        total_chars = len(chars)

        seq_start = None
        for idx in range(total_chars):
            _ch = chars[idx]
            if _ch['type'] in ('B', 'S', 'WS', 'ON'):
                # N1. A sequence of neutrals takes the direction of the
                # surrounding strong text if the text on both sides has the same
                # direction. European and Arabic numbers act as if they were R
                # in terms of their influence on neutrals. Start-of-level-run
                # (sor) and end-of-level-run (eor) are used at level run
                # boundaries.
                if seq_start is None:
                    seq_start = idx
                    prev_bidi_type = chars[idx-1]['type']
            else:
                if seq_start is not None:
                    next_bidi_type = chars[idx]['type']

                    if prev_bidi_type in ('AN', 'EN'):
                        prev_bidi_type = 'R'

                    if next_bidi_type in ('AN', 'EN'):
                        next_bidi_type = 'R'

                    for seq_idx in range(seq_start, idx):
                        if prev_bidi_type == next_bidi_type:
                            chars[seq_idx]['type'] = prev_bidi_type
                        else:
                            # N2. Any remaining neutrals take the embedding
                            # direction. The embedding direction for the given
                            # neutral character is derived from its embedding
                            # level: L if the character is set to an even level,
                            # and R if the level is odd.
                            chars[seq_idx]['type'] = \
                                _embedding_direction(chars[seq_idx]['level'])

                    seq_start = None

    if debug:
        debug_storage(storage)
def resolve_neutral_types ( storage , debug ) : for run in storage [ 'runs' ] : start , length = run [ 'start' ] , run [ 'length' ] # use sor and eor chars = [ { 'type' : run [ 'sor' ] } ] + storage [ 'chars' ] [ start : start + length ] + [ { 'type' : run [ 'eor' ] } ] total_chars = len ( chars ) seq_start = None for idx in range ( total_chars ) : _ch = chars [ idx ] if _ch [ 'type' ] in ( 'B' , 'S' , 'WS' , 'ON' ) : # N1. A sequence of neutrals takes the direction of the # surrounding strong text if the text on both sides has the same # direction. European and Arabic numbers act as if they were R # in terms of their influence on neutrals. Start-of-level-run # (sor) and end-of-level-run (eor) are used at level run # boundaries. if seq_start is None : seq_start = idx prev_bidi_type = chars [ idx - 1 ] [ 'type' ] else : if seq_start is not None : next_bidi_type = chars [ idx ] [ 'type' ] if prev_bidi_type in ( 'AN' , 'EN' ) : prev_bidi_type = 'R' if next_bidi_type in ( 'AN' , 'EN' ) : next_bidi_type = 'R' for seq_idx in range ( seq_start , idx ) : if prev_bidi_type == next_bidi_type : chars [ seq_idx ] [ 'type' ] = prev_bidi_type else : # N2. Any remaining neutrals take the embedding # direction. The embedding direction for the given # neutral character is derived from its embedding # level: L if the character is set to an even level, # and R if the level is odd. chars [ seq_idx ] [ 'type' ] = _embedding_direction ( chars [ seq_idx ] [ 'level' ] ) seq_start = None if debug : debug_storage ( storage )
Resolving neutral types. Implements N1 and N2

    See: http://unicode.org/reports/tr9/#Resolving_Neutral_Types
Resolving neutral types . Implements N1 and N2