Gecko [ sachasauda.akalacademy.ac.in ]

Name	Size	Permission
CherryPy-14.2.0.dist-info	[ DIR ]	drwxr-xr-x
PyYAML-5.3.1.dist-info	[ DIR ]	drwxr-xr-x
__pycache__	[ DIR ]	drwxr-xr-x
archon	[ DIR ]	drwxr-xr-x
archon-4.5.0.dist-info	[ DIR ]	drwxr-xr-x
certifi	[ DIR ]	drwxr-xr-x
certifi-2020.6.20.dist-info	[ DIR ]	drwxr-xr-x
chardet	[ DIR ]	drwxr-xr-x
chardet-3.0.4.dist-info	[ DIR ]	drwxr-xr-x
cheroot	[ DIR ]	drwxr-xr-x
cheroot-6.6.0.dist-info	[ DIR ]	drwxr-xr-x
cherrypy	[ DIR ]	drwxr-xr-x
decorator-4.4.2.dist-info	[ DIR ]	drwxr-xr-x
dotenv	[ DIR ]	drwxr-xr-x
environs-4.2.0.dist-info	[ DIR ]	drwxr-xr-x
falcon	[ DIR ]	drwxr-xr-x
falcon-1.4.1.dist-info	[ DIR ]	drwxr-xr-x
idna	[ DIR ]	drwxr-xr-x
idna-2.10.dist-info	[ DIR ]	drwxr-xr-x
importlib_metadata	[ DIR ]	drwxr-xr-x
importlib_metadata-2.0.0.dist-...	[ DIR ]	drwxr-xr-x
importlib_resources	[ DIR ]	drwxr-xr-x
importlib_resources-1.4.0.dist...	[ DIR ]	drwxr-xr-x
iso8601	[ DIR ]	drwxr-xr-x
iso8601-0.1.13.dist-info	[ DIR ]	drwxr-xr-x
jaraco	[ DIR ]	drwxr-xr-x
jaraco.classes-2.0.dist-info	[ DIR ]	drwxr-xr-x
jaraco.functools-2.0.dist-info	[ DIR ]	drwxr-xr-x
jsonschema	[ DIR ]	drwxr-xr-x
jsonschema-2.6.0.dist-info	[ DIR ]	drwxr-xr-x
kazoo	[ DIR ]	drwxr-xr-x
kazoo-2.8.0.dist-info	[ DIR ]	drwxr-xr-x
marshmallow	[ DIR ]	drwxr-xr-x
marshmallow-3.9.0.dist-info	[ DIR ]	drwxr-xr-x
more_itertools	[ DIR ]	drwxr-xr-x
more_itertools-8.6.0.dist-info	[ DIR ]	drwxr-xr-x
networkx	[ DIR ]	drwxr-xr-x
networkx-1.11.dist-info	[ DIR ]	drwxr-xr-x
nydus	[ DIR ]	drwxr-xr-x
nydus-4.4.4.dist-info	[ DIR ]	drwxr-xr-x
pip	[ DIR ]	drwxr-xr-x
pip-20.0.2.dist-info	[ DIR ]	drwxr-xr-x
pkg_resources	[ DIR ]	drwxr-xr-x
portend-2.6.dist-info	[ DIR ]	drwxr-xr-x
primordial	[ DIR ]	drwxr-xr-x
primordial-1.4.0.dist-info	[ DIR ]	drwxr-xr-x
python_dotenv-0.15.0.dist-info	[ DIR ]	drwxr-xr-x
python_mimeparse-1.6.0.dist-in...	[ DIR ]	drwxr-xr-x
pytz	[ DIR ]	drwxr-xr-x
pytz-2020.4.dist-info	[ DIR ]	drwxr-xr-x
requests	[ DIR ]	drwxr-xr-x
requests-2.23.0.dist-info	[ DIR ]	drwxr-xr-x
semver-2.9.1.dist-info	[ DIR ]	drwxr-xr-x
setuptools	[ DIR ]	drwxr-xr-x
setuptools-40.9.0.dist-info	[ DIR ]	drwxr-xr-x
six-1.15.0.dist-info	[ DIR ]	drwxr-xr-x
tempora	[ DIR ]	drwxr-xr-x
tempora-1.14.1.dist-info	[ DIR ]	drwxr-xr-x
urllib3	[ DIR ]	drwxr-xr-x
urllib3-1.25.11.dist-info	[ DIR ]	drwxr-xr-x
voluptuous	[ DIR ]	drwxr-xr-x
voluptuous-0.11.7.dist-info	[ DIR ]	drwxr-xr-x
wheel	[ DIR ]	drwxr-xr-x
wheel-0.35.1.dist-info	[ DIR ]	drwxr-xr-x
yaml	[ DIR ]	drwxr-xr-x
zipp-1.2.0.dist-info	[ DIR ]	drwxr-xr-x
decorator.py	16.82 KB	-rw-r--r--
easy_install.py	126 B	-rw-r--r--
environs.py	10.27 KB	-rw-r--r--
mimeparse.py	6.1 KB	-rw-r--r--
portend.py	5.77 KB	-rw-r--r--
semver.py	22.65 KB	-rw-r--r--
six.py	33.36 KB	-rw-r--r--
zipp.py	6.87 KB	-rw-r--r--

Code Editor : mimeparse.py

import cgi

__version__ = '1.6.0'
__author__ = 'Joe Gregorio'
__email__ = 'joe@bitworking.org'
__license__ = 'MIT License'
__credits__ = ''

class MimeTypeParseException(ValueError):
    pass

def parse_mime_type(mime_type):
    """Parses a mime-type into its component parts.

Carves up a mime-type and returns a tuple of the (type, subtype, params)
    where 'params' is a dictionary of all the parameters for the media range.
    For example, the media range 'application/xhtml;q=0.5' would get parsed
    into:

('application', 'xhtml', {'q', '0.5'})

:rtype: (str,str,dict)
    """
    full_type, params = cgi.parse_header(mime_type)
    # Java URLConnection class sends an Accept header that includes a
    # single '*'. Turn it into a legal wildcard.
    if full_type == '*':
        full_type = '*/*'

type_parts = full_type.split('/') if '/' in full_type else None
    if not type_parts or len(type_parts) > 2:
        raise MimeTypeParseException(
            "Can't parse type \"{}\"".format(full_type))

(type, subtype) = type_parts

return (type.strip(), subtype.strip(), params)

def parse_media_range(range):
    """Parse a media-range into its component parts.

Carves up a media range and returns a tuple of the (type, subtype,
    params) where 'params' is a dictionary of all the parameters for the media
    range.  For example, the media range 'application/*;q=0.5' would get parsed
    into:

('application', '*', {'q', '0.5'})

In addition this function also guarantees that there is a value for 'q'
    in the params dictionary, filling it in with a proper default if
    necessary.

:rtype: (str,str,dict)
    """
    (type, subtype, params) = parse_mime_type(range)
    params.setdefault('q', params.pop('Q', None))  # q is case insensitive
    try:
        if not params['q'] or not 0 <= float(params['q']) <= 1:
            params['q'] = '1'
    except ValueError:  # from float()
        params['q'] = '1'

return (type, subtype, params)

def quality_and_fitness_parsed(mime_type, parsed_ranges):
    """Find the best match for a mime-type amongst parsed media-ranges.

Find the best match for a given mime-type against a list of media_ranges
    that have already been parsed by parse_media_range(). Returns a tuple of
    the fitness value and the value of the 'q' quality parameter of the best
    match, or (-1, 0) if no match was found. Just as for quality_parsed(),
    'parsed_ranges' must be a list of parsed media ranges.

:rtype: (float,int)
    """
    best_fitness = -1
    best_fit_q = 0
    (target_type, target_subtype, target_params) = \
        parse_media_range(mime_type)

for (type, subtype, params) in parsed_ranges:

# check if the type and the subtype match
        type_match = (
            type in (target_type, '*') or
            target_type == '*'
        )
        subtype_match = (
            subtype in (target_subtype, '*') or
            target_subtype == '*'
        )

# if they do, assess the "fitness" of this mime_type
        if type_match and subtype_match:

# 100 points if the type matches w/o a wildcard
            fitness = type == target_type and 100 or 0

# 10 points if the subtype matches w/o a wildcard
            fitness += subtype == target_subtype and 10 or 0

# 1 bonus point for each matching param besides "q"
            param_matches = sum([
                1 for (key, value) in target_params.items()
                if key != 'q' and key in params and value == params[key]
            ])
            fitness += param_matches

# finally, add the target's "q" param (between 0 and 1)
            fitness += float(target_params.get('q', 1))

if fitness > best_fitness:
                best_fitness = fitness
                best_fit_q = params['q']

return float(best_fit_q), best_fitness

def quality_parsed(mime_type, parsed_ranges):
    """Find the best match for a mime-type amongst parsed media-ranges.

Find the best match for a given mime-type against a list of media_ranges
    that have already been parsed by parse_media_range(). Returns the 'q'
    quality parameter of the best match, 0 if no match was found. This function
    behaves the same as quality() except that 'parsed_ranges' must be a list of
    parsed media ranges.

:rtype: float
    """

return quality_and_fitness_parsed(mime_type, parsed_ranges)[0]

def quality(mime_type, ranges):
    """Return the quality ('q') of a mime-type against a list of media-ranges.

Returns the quality 'q' of a mime-type when compared against the
    media-ranges in ranges. For example:

>>> quality('text/html','text/*;q=0.3, text/html;q=0.7,
                  text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5')
    0.7

:rtype: float
    """
    parsed_ranges = [parse_media_range(r) for r in ranges.split(',')]

return quality_parsed(mime_type, parsed_ranges)

def best_match(supported, header):
    """Return mime-type with the highest quality ('q') from list of candidates.

Takes a list of supported mime-types and finds the best match for all the
    media-ranges listed in header. The value of header must be a string that
    conforms to the format of the HTTP Accept: header. The value of 'supported'
    is a list of mime-types. The list of supported mime-types should be sorted
    in order of increasing desirability, in case of a situation where there is
    a tie.

>>> best_match(['application/xbel+xml', 'text/xml'],
                   'text/*;q=0.5,*/*; q=0.1')
    'text/xml'

:rtype: str
    """
    split_header = _filter_blank(header.split(','))
    parsed_header = [parse_media_range(r) for r in split_header]
    weighted_matches = []
    pos = 0
    for mime_type in supported:
        weighted_matches.append((
            quality_and_fitness_parsed(mime_type, parsed_header),
            pos,
            mime_type
        ))
        pos += 1
    weighted_matches.sort()

return weighted_matches[-1][0][0] and weighted_matches[-1][2] or ''

def _filter_blank(i):
    """Return all non-empty items in the list."""
    for s in i:
        if s.strip():
            yield s

${this.title}

Code Editor : mimeparse.py