diff --git a/news/219.feature.rst b/news/219.feature.rst new file mode 100644 index 00000000..8a367648 --- /dev/null +++ b/news/219.feature.rst @@ -0,0 +1 @@ +Added ``requirementslib.models.metadata`` module with ``get_package``, ``get_package_version``, and ``get_package_from_requirement`` interfaces. diff --git a/setup.cfg b/setup.cfg index d8f2a7b1..d992a245 100644 --- a/setup.cfg +++ b/setup.cfg @@ -125,12 +125,12 @@ markers = atomic = true not_skip = __init__.py line_length = 90 -indent = ' ' multi_line_output = 3 -known_third_party = appdirs,attr,cached_property,chardet,distlib,environ,hypothesis,invoke,orderedmultidict,packaging,parver,pep517,pip_shims,plette,pyparsing,pytest,requests,setuptools,six,tomlkit,towncrier,urllib3,vistir +known_third_party = appdirs,attr,cached_property,chardet,dateutil,distlib,environ,hypothesis,invoke,orderedmultidict,packaging,parver,pep517,pip_shims,plette,pyparsing,pytest,requests,setuptools,six,tomlkit,towncrier,urllib3,vistir known_first_party = requirementslib,tests combine_as_imports=True include_trailing_comma = True +use_parentheses=True force_grid_wrap=0 [flake8] diff --git a/src/requirementslib/models/markers.py b/src/requirementslib/models/markers.py index ef0e69f9..84637642 100644 --- a/src/requirementslib/models/markers.py +++ b/src/requirementslib/models/markers.py @@ -197,6 +197,7 @@ def _get_specs(specset): return sorted(result, key=operator.itemgetter(1)) +# TODO: Rename this to something meaningful def _group_by_op(specs): # type: (Union[Set[Specifier], SpecifierSet]) -> Iterator specs = [_get_specs(x) for x in list(specs)] @@ -208,6 +209,7 @@ def _group_by_op(specs): return grouping +# TODO: rename this to something meaningful def normalize_specifier_set(specs): # type: (Union[str, SpecifierSet]) -> Optional[Set[Specifier]] """Given a specifier set, a string, or an iterable, normalize the specifiers @@ -238,6 +240,8 @@ def normalize_specifier_set(specs): return normalize_specifier_set(SpecifierSet(",".join(spec_list))) +# TODO: Check if this is used by anything public otherwise make it private +# And rename it to something meaningful def get_sorted_version_string(version_set): # type: (Set[AnyStr]) -> AnyStr version_list = sorted( @@ -247,6 +251,9 @@ def get_sorted_version_string(version_set): return version +# TODO: Rename this to something meaningful +# TODO: Add a deprecation decorator and deprecate this -- i'm sure it's used +# in other libraries @lru_cache(maxsize=1024) def cleanup_pyspecs(specs, joiner="or"): specs = normalize_specifier_set(specs) @@ -292,6 +299,7 @@ def cleanup_pyspecs(specs, joiner="or"): return sorted([(k[0], v) for k, v in results.items()], key=operator.itemgetter(1)) +# TODO: Rename this to something meaningful @lru_cache(maxsize=1024) def fix_version_tuple(version_tuple): # type: (Tuple[AnyStr, AnyStr]) -> Tuple[AnyStr, AnyStr] @@ -306,6 +314,7 @@ def fix_version_tuple(version_tuple): return (op, version) +# TODO: Rename this to something meaningful, deprecate it (See prior function) @lru_cache(maxsize=128) def get_versions(specset, group_by_operator=True): # type: (Union[Set[Specifier], SpecifierSet], bool) -> List[Tuple[STRING_TYPE, STRING_TYPE]] @@ -594,6 +603,7 @@ def get_specset(marker_list): return specifiers +# TODO: Refactor this (reduce complexity) def parse_marker_dict(marker_dict): op = marker_dict["op"] lhs = marker_dict["lhs"] @@ -710,3 +720,16 @@ def marker_from_specifier(spec): marker_segments.append(format_pyversion(marker_segment)) marker_str = " and ".join(marker_segments).replace('"', "'") return Marker(marker_str) + + +def merge_markers(m1, m2): + # type: (Marker, Marker) -> Optional[Marker] + if not all((m1, m2)): + return next(iter(v for v in (m1, m2) if v), None) + m1 = _ensure_marker(m1) + m2 = _ensure_marker(m2) + _markers = [] # type: List[Marker] + for marker in (m1, m2): + _markers.append(str(marker)) + marker_str = " and ".join([normalize_marker_str(m) for m in _markers if m]) + return _ensure_marker(normalize_marker_str(marker_str)) diff --git a/src/requirementslib/models/metadata.py b/src/requirementslib/models/metadata.py new file mode 100644 index 00000000..912b1b77 --- /dev/null +++ b/src/requirementslib/models/metadata.py @@ -0,0 +1,1240 @@ +# -*- coding=utf-8 -*- +import datetime +import functools +import io +import json +import logging +import operator +import os +import zipfile +from collections import defaultdict + +import attr +import dateutil.parser +import distlib.metadata +import distlib.wheel +import packaging.version +import requests +import six +import vistir +from packaging.markers import Marker +from packaging.requirements import Requirement as PackagingRequirement +from packaging.specifiers import Specifier, SpecifierSet +from packaging.tags import Tag + +from ..environment import MYPY_RUNNING +from .markers import ( + get_contained_extras, + get_contained_pyversions, + get_without_extra, + get_without_pyversion, + marker_from_specifier, + merge_markers, + normalize_specifier_set, +) +from .requirements import Requirement +from .utils import filter_dict, get_pinned_version, is_pinned_requirement + +# fmt: off +from six.moves import Sequence # type: ignore # isort:skip +from six.moves import reduce # type: ignore # isort:skip +# fmt: on # isort:skip + + +ch = logging.StreamHandler() +formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s") +ch.setFormatter(formatter) +logger = logging.getLogger(__name__) +logger.setLevel(logging.INFO) + + +if MYPY_RUNNING: + from typing import ( + Any, + Callable, + Dict, + Generator, + Generic, + Iterator, + List, + Optional, + Set, + Tuple, + Type, + TypeVar, + Union, + ) + from attr import Attribute # noqa + from .setup_info import SetupInfo + + TAttrsClass = TypeVar("TAttrsClass") + AttrsClass = Generic[TAttrsClass] + TDigestDict = Dict[str, str] + TProjectUrls = Dict[str, str] + TReleaseUrlDict = Dict[str, Union[bool, int, str, TDigestDict]] + TReleasesList = List[TReleaseUrlDict] + TReleasesDict = Dict[str, TReleasesList] + TDownloads = Dict[str, int] + TPackageInfo = Dict[str, Optional[Union[str, List[str], TDownloads, TProjectUrls]]] + TPackage = Dict[str, Union[TPackageInfo, int, TReleasesDict, TReleasesList]] + + +VALID_ALGORITHMS = { + "sha1": 40, + "sha3_224": 56, + "sha512": 128, + "blake2b": 128, + "sha256": 64, + "sha384": 96, + "blake2s": 64, + "sha3_256": 64, + "sha3_512": 128, + "md5": 32, + "sha3_384": 96, + "sha224": 56, +} # type: Dict[str, int] + +PACKAGE_TYPES = { + "sdist", + "bdist_wheel", + "bdist_egg", + "bdist_dumb", + "bdist_wininst", + "bdist_rpm", + "bdist_msi", + "bdist_dmg", +} + + +class PackageEncoder(json.JSONEncoder): + def default(self, obj): # noqa:E0202 # noqa:W0221 + if isinstance(obj, datetime.datetime): + return obj.isoformat() + elif isinstance(obj, PackagingRequirement): + return obj.__dict__ + elif isinstance(obj, set): + return tuple(obj) + elif isinstance(obj, (Specifier, SpecifierSet, Marker)): + return str(obj) + else: + return json.JSONEncoder.default(self, obj) + + +def validate_extras(inst, attrib, value): + # type: ("Dependency", Attribute, Tuple[str, ...]) -> None + duplicates = [k for k in value if value.count(k) > 1] + if duplicates: + raise ValueError("Found duplicate keys: {0}".format(", ".join(duplicates))) + return None + + +def validate_digest(inst, attrib, value): + # type: ("Digest", Attribute, str) -> None + expected_length = VALID_ALGORITHMS[inst.algorithm.lower()] + if len(value) != expected_length: + raise ValueError( + "Expected a digest of length {0!s}, got one of length {1!s}".format( + expected_length, len(value) + ) + ) + return None + + +def get_local_wheel_metadata(wheel_file): + # type: (str) -> Optional[distlib.metadata.Metadata] + parsed_metadata = None + with io.open(wheel_file, "rb") as fh: + with zipfile.ZipFile(fh, mode="r", compression=zipfile.ZIP_DEFLATED) as zf: + metadata = None + for fn in zf.namelist(): + if os.path.basename(fn) == "METADATA": + metadata = fn + break + if metadata is None: + raise RuntimeError("No metadata found in wheel: {0}".format(wheel_file)) + with zf.open(metadata, "r") as metadata_fh: + parsed_metadata = distlib.metadata.Metadata(fileobj=metadata_fh) + return parsed_metadata + + +def get_remote_sdist_metadata(line): + # type: (str) -> SetupInfo + req = Requirement.from_line(line) + try: + _ = req.run_requires() + except SystemExit: + raise RuntimeError("Failed to compute metadata for dependency {0}".format(line)) + else: + return req.line_instance.setup_info + + +def get_remote_wheel_metadata(whl_file): + # type: (str) -> Optional[distlib.metadata.Metadata] + parsed_metadata = None + data = io.BytesIO() + with vistir.contextmanagers.open_file(whl_file) as fp: + for chunk in iter(lambda: fp.read(8096), b""): + data.write(chunk) + with zipfile.ZipFile(data, mode="r", compression=zipfile.ZIP_DEFLATED) as zf: + metadata = None + for fn in zf.namelist(): + if os.path.basename(fn) == "METADATA": + metadata = fn + break + if metadata is None: + raise RuntimeError("No metadata found in wheel: {0}".format(whl_file)) + with zf.open(metadata, "r") as metadata_fh: + parsed_metadata = distlib.metadata.Metadata(fileobj=metadata_fh) + return parsed_metadata + + +def create_specifierset(spec=None): + # type: (Optional[str]) -> SpecifierSet + if isinstance(spec, SpecifierSet): + return spec + elif isinstance(spec, (set, list, tuple)): + spec = " and ".join(spec) + if spec is None: + spec = "" + return SpecifierSet(spec) + + +@attr.s(frozen=True, eq=True) +class ExtrasCollection(object): + #: The name of the extras collection (e.g. 'security') + name = attr.ib(type=str) + #: The dependency the collection belongs to + parent = attr.ib(type="Dependency") + #: The members of the collection + dependencies = attr.ib(factory=set) # type: Set["Dependency"] + + def add_dependency(self, dependency): + # type: ("Dependency") -> "ExtrasCollection" + if not isinstance(dependency, Dependency): + raise TypeError( + "Expected a Dependency instance, received {0!r}".format(dependency) + ) + dependencies = self.dependencies.copy() + dependencies.add(dependency) + return attr.evolve(self, dependencies=dependencies) + + +@attr.s(frozen=True, eq=True) +class Dependency(object): + #: The name of the dependency + name = attr.ib(type=str) + #: A requirement instance + requirement = attr.ib(type=PackagingRequirement, eq=False) + #: The specifier defined in the dependency definition + specifier = attr.ib(type=SpecifierSet, converter=create_specifierset, eq=False) + #: Any extras this dependency declares + extras = attr.ib(factory=tuple, validator=validate_extras) # type: Tuple[str, ...] + #: The name of the extra meta-dependency this one came from (e.g. 'security') + from_extras = attr.ib(default=None, eq=False) # type: Optional[str] + #: The declared specifier set of allowable python versions for this dependency + python_version = attr.ib( + default="", type=SpecifierSet, converter=create_specifierset, eq=False + ) + #: The parent of this dependency (i.e. where it came from) + parent = attr.ib(default=None) # type: Optional[Dependency] + #: The markers for this dependency + markers = attr.ib(default=None, eq=False) # type: Optional[Marker] + _specset_str = attr.ib(default="", type=str) + _python_version_str = attr.ib(default="", type=str) + _marker_str = attr.ib(default="", type=str) + + def __str__(self): + # type: () -> str + return str(self.requirement) + + def as_line(self): + # type: () -> str + line_str = "{0}".format(self.name) + if self.extras: + line_str = "{0}[{1}]".format(line_str, ",".join(self.extras)) + if self.specifier: + line_str = "{0}{1!s}".format(line_str, self.specifier) + py_version_part = "" + if self.python_version: + specifiers = normalize_specifier_set(self.python_version) + markers = [] + if specifiers is not None: + markers = [marker_from_specifier(str(s)) for s in specifiers] + py_version_part = reduce(merge_markers, markers) + if self.markers: + line_str = "{0}; {1}".format(line_str, str(self.markers)) + if py_version_part: + line_str = "{0} and {1}".format(line_str, py_version_part) + elif py_version_part and not self.markers: + line_str = "{0}; {1}".format(line_str, py_version_part) + return line_str + + def pin(self): + # type: () -> "Package" + base_package = get_package(self.name) + sorted_releases = sorted( + base_package.releases.non_yanked_releases, + key=operator.attrgetter("parsed_version"), + reverse=True, + ) + version = next( + iter(self.specifier.filter((r.version for r in sorted_releases))), None + ) + if not version: + version = next( + iter( + self.specifier.filter( + (r.version for r in sorted_releases), prereleases=True + ) + ), + None, + ) + if not version: + raise RuntimeError( + "Failed to resolve {0} ({1!s})".format(self.name, self.specifier) + ) + match = get_package_version(self.name, str(version)) + return match + + @classmethod + def from_requirement(cls, req, parent=None): + # type: (PackagingRequirement, Optional["Dependency"]) -> "Dependency" + from_extras, marker, python_version = None, None, None + specset_str, py_version_str, marker_str = "", "", "" + if req.marker: + marker = Marker(str(req.marker)) + from_extras = next(iter(list(get_contained_extras(marker))), None) + python_version = get_contained_pyversions(marker) + marker = get_without_extra(get_without_pyversion(marker)) + if not str(marker) or not marker or not marker._markers: + marker = None + req.marker = marker + if marker is not None: + marker_str = str(marker) + if req.specifier: + specset_str = str(req.specifier) + if python_version: + py_version_str = str(python_version) + return cls( + name=req.name, + specifier=req.specifier, + extras=tuple(sorted(set(req.extras))) if req.extras is not None else req.extras, + requirement=req, + from_extras=from_extras, + python_version=python_version, + markers=marker, + parent=parent, + specset_str=specset_str, + python_version_str=py_version_str, + marker_str=marker_str, + ) + + @classmethod + def from_info(cls, info): + # type: ("PackageInfo") -> "Dependency" + marker_str = "" + specset_str, py_version_str = "", "" + if info.requires_python: + # XXX: Some markers are improperly formatted -- we already handle most cases + # XXX: but learned about new broken formats, such as + # XXX: python_version in "2.6 2.7 3.2 3.3" (note the lack of commas) + # XXX: as a marker on a dependency of a library called 'pickleshare' + # XXX: Some packages also have invalid markers with stray characters, + # XXX: such as 'algoliasearch' + try: + marker = marker_from_specifier(info.requires_python) + except Exception: + marker_str = "" + else: + if not marker or not marker._markers: + marker_str = "" + else: + marker_str = "{0!s}".format(marker) + req_str = "{0}=={1}".format(info.name, info.version) + if marker_str: + req_str = "{0}; {1}".format(req_str, marker_str) + req = PackagingRequirement(req_str) + requires_python_str = ( + info.requires_python if info.requires_python is not None else "" + ) + if req.specifier: + specset_str = str(req.specifier) + if requires_python_str: + py_version_str = requires_python_str + return cls( + name=info.name, + specifier=req.specifier, + extras=tuple(sorted(set(req.extras))) if req.extras is not None else req.extras, + requirement=req, + from_extras=None, + python_version=SpecifierSet(requires_python_str), + markers=None, + parent=None, + specset_str=specset_str, + python_version_str=py_version_str, + marker_str=marker_str, + ) + + @classmethod + def from_str(cls, depstr, parent=None): + # type: (str, Optional["Dependency"]) -> "Dependency" + try: + req = PackagingRequirement(depstr) + except Exception: + raise + return cls.from_requirement(req, parent=parent) + + def add_parent(self, parent): + # type: ("Dependency") -> "Dependency" + return attr.evolve(self, parent=parent) + + +@attr.s(frozen=True, eq=True) +class Digest(object): + #: The algorithm declared for the digest, e.g. 'sha256' + algorithm = attr.ib( + type=str, validator=attr.validators.in_(VALID_ALGORITHMS.keys()), eq=True + ) + #: The digest value + value = attr.ib(type=str, validator=validate_digest, eq=True) + + def __str__(self): + # type: () -> str + return "{0}:{1}".format(self.algorithm, self.value) + + @classmethod + def create(cls, algorithm, value): + # type: (str, str) -> "Digest" + return cls(algorithm=algorithm, value=value) + + @classmethod + def collection_from_dict(cls, digest_dict): + # type: (TDigestDict) -> List["Digest"] + return [cls.create(k, v) for k, v in digest_dict.items()] + + +# XXX: This is necessary because attrs converters can only be functions, not classmethods +def create_digest_collection(digest_dict): + # type: (TDigestDict) -> List["Digest"] + return Digest.collection_from_dict(digest_dict) + + +def instance_check_converter(expected_type=None, converter=None): + # type: (Optional[Type], Optional[Callable]) -> Callable + def _converter(val): + if expected_type is not None and isinstance(val, expected_type): + return val + return converter(val) + + return _converter + + +@attr.s(frozen=True, eq=True) +class ParsedTag(object): + #: The marker string corresponding to the tag + marker_string = attr.ib(default=None) # type: Optional[str] + #: The python version represented by the tag + python_version = attr.ib(default=None) # type: Optional[str] + #: The platform represented by the tag + platform_system = attr.ib(default=None) # type: Optional[str] + #: the ABI represented by the tag + abi = attr.ib(default=None) # type: Optional[str] + + +def parse_tag(tag): + # type: (Tag) -> ParsedTag + """ + Parse a :class:`~packaging.tags.Tag` instance + + :param :class:`~packaging.tags.Tag` tag: A tag to parse + :return: A parsed tag with combined markers, supported platform and python version + :rtype: :class:`~ParsedTag` + """ + platform_system = None + python_version = None + version = None + marker_str = "" + if tag.platform.startswith("macos"): + platform_system = "Darwin" + elif tag.platform.startswith("manylinux") or tag.platform.startswith("linux"): + platform_system = "Linux" + elif tag.platform.startswith("win32"): + platform_system = "Windows" + if platform_system: + marker_str = 'platform_system == "{}"'.format(platform_system) + if tag.interpreter: + version = tag.interpreter[2:] + py_version_str = "" + if len(version) == 1: + py_version_str = ">={}.0,<{}".format(version, str(int(version) + 1)) + elif len(version) > 1 and len(version) <= 3: + # reverse the existing version so we can add 1 to the first element + # and re-reverse, generating the new version, e.g. [3, 2, 8] => + # [8, 2, 3] => [9, 2, 3] => [3, 2, 9] + next_version_list = list(reversed(version[:])) + next_version_list[0] = str(int(next_version_list[0]) + 1) + next_version = ".".join(list(reversed(next_version_list))) + version = ".".join(version) + py_version_str = ">={},<{}".format(version, next_version) + else: + py_version_str = "{0}".format(version) + python_version = marker_from_specifier(py_version_str) + if python_version: + if marker_str: + marker_str = "{0} and {1!s}".format(marker_str, python_version) + else: + marker_str = str(python_version) + return ParsedTag( + marker_string=marker_str, + python_version=version, + platform_system=platform_system, + abi=tag.abi, + ) + + +@attr.s(frozen=True, eq=True) +class ReleaseUrl(object): + #: The MD5 digest of the given release + md5_digest = attr.ib(type=Digest) + #: The package type of the url + packagetype = attr.ib(type=str, validator=attr.validators.in_(PACKAGE_TYPES)) + #: The upload timestamp from the package + upload_time = attr.ib( + type=datetime.datetime, + converter=instance_check_converter(datetime.datetime, dateutil.parser.parse), # type: ignore + ) + #: The ISO8601 formatted upload timestamp of the package + upload_time_iso_8601 = attr.ib( + type=datetime.datetime, + converter=instance_check_converter(datetime.datetime, dateutil.parser.parse), # type: ignore + ) + #: The size in bytes of the package + size = attr.ib(type=int) + #: The URL of the package + url = attr.ib(type=str) + #: The digests of the package + digests = attr.ib( + converter=instance_check_converter(list, create_digest_collection) # type: ignore + ) # type: List[Digest] + #: The name of the package + name = attr.ib(type=str, default=None) + #: The available comments of the given upload + comment_text = attr.ib(type=str, default="") + #: The number of downloads (deprecated) + downloads = attr.ib(type=int, default=-1) + #: The filename of the current upload + filename = attr.ib(type=str, default="") + #: Whether the upload has a signature + has_sig = attr.ib(type=bool, default=False) + #: The python_version attribute of the upload (e.g. 'source', 'py27', etc) + python_version = attr.ib(type=str, default="source") + #: The 'requires_python' restriction on the package + requires_python = attr.ib(type=str, default=None) + #: A list of valid aprsed tags from the upload + tags = attr.ib(factory=list) # type: List[ParsedTag] + + @property + def is_wheel(self): + # type: () -> bool + return os.path.splitext(self.filename)[-1].lower() == ".whl" + + @property + def is_sdist(self): + # type: () -> bool + return self.python_version == "source" + + @property + def markers(self): + # type: () -> Optional[str] + # TODO: Compare dependencies in parent and add markers for python version + # TODO: Compare dependencies in parent and add markers for platform + # XXX: We can't use wheel-based markers until we do it via derived markers by + # XXX: comparing in the parent (i.e. 'Release' instance or so) and merging + # XXX: down to the common / minimal set of markers otherwise we wind up + # XXX: with an unmanageable set and combinatorial explosion + # if self.is_wheel: + # return self.get_markers_from_wheel() + if self.requires_python: + return marker_from_specifier(self.requires_python) + return None + + @property + def pep508_url(self): + # type: () -> str + markers = self.markers + req_str = "{0} @ {1}#egg={0}".format(self.name, self.url) + if markers: + req_str = "{0}; {1}".format(req_str, markers) + return req_str + + def get_markers_from_wheel(self): + # type: () -> str + supported_platforms = [] # type: List[str] + supported_pyversions = [] + supported_abis = [] + markers = [] + for parsed_tag in self.tags: + if parsed_tag.marker_string: + markers.append(Marker(parsed_tag.marker_string)) + if parsed_tag.python_version: + supported_pyversions.append(parsed_tag.python_version) + if parsed_tag.abi: + supported_abis.append(parsed_tag.abi) + if not (markers or supported_platforms): + return "" + if ( + all(pyversion in supported_pyversions for pyversion in ["2", "3"]) + and not supported_platforms + ): + marker_line = "" + else: + marker_line = " or ".join(["{}".format(str(marker)) for marker in markers]) + return marker_line + + def get_dependencies(self): + # type: () -> Tuple["ReleaseUrl", Dict[str, Union[List[str], str]]] + results = {"requires_python": None} + requires_dist = [] # type: List[str] + if self.is_wheel: + metadata = get_remote_wheel_metadata(self.url) + if metadata is not None: + requires_dist = metadata.run_requires + if not self.requires_python: + results["requires_python"] = metadata._legacy.get("Requires-Python") + else: + try: + metadata = get_remote_sdist_metadata(self.pep508_url) + except Exception: + requires_dist = [] + else: + requires_dist = [str(v) for v in metadata.requires.values()] + results["requires_dist"] = requires_dist + requires_python = getattr(self, "requires_python", results["requires_python"]) + return attr.evolve(self, requires_python=requires_python), results + + @property + def sha256(self): + # type: () -> str + return next( + iter(digest for digest in self.digests if digest.algorithm == "sha256") + ).value + + @classmethod + def create(cls, release_dict, name=None): + # type: (TReleaseUrlDict, Optional[str]) -> "ReleaseUrl" + valid_digest_keys = set("{0}_digest".format(k) for k in VALID_ALGORITHMS.keys()) + digest_keys = set(release_dict.keys()) & valid_digest_keys + creation_kwargs = {} # type: Dict[str, Union[bool, int, str, Digest, TDigestDict]] + creation_kwargs = { + k: v for k, v in release_dict.items() if k not in digest_keys + } + if name is not None: + creation_kwargs["name"] = name + for k in digest_keys: + digest = release_dict[k] + if not isinstance(digest, six.string_types): + raise TypeError("Digests must be strings, got {!r}".format(digest)) + creation_kwargs[k] = Digest.create(k.replace("_digest", ""), digest) + release_url = cls(**filter_dict(creation_kwargs)) # type: ignore + if release_url.is_wheel: + supported_tags = [ + parse_tag(Tag(*tag)) for tag in distlib.wheel.Wheel(release_url.url).tags + ] + release_url = attr.evolve(release_url, tags=supported_tags) + return release_url + + +def create_release_urls_from_list(urls, name=None): + # type: (Union[TReleasesList, List[ReleaseUrl]], Optional[str]) -> List[ReleaseUrl] + url_list = [] + for release_dict in urls: + if isinstance(release_dict, ReleaseUrl): + if name and not release_dict.name: + release_dict = attr.evolve(release_dict, name=name) + url_list.append(release_dict) + continue + url_list.append(ReleaseUrl.create(release_dict, name=name)) + return url_list + + +@attr.s(frozen=True, eq=True) +class ReleaseUrlCollection(Sequence): + #: A list of release URLs + urls = attr.ib(converter=create_release_urls_from_list) + #: the name of the package + name = attr.ib(default=None) # type: Optional[str] + + @classmethod + def create(cls, urls, name=None): + # type: (TReleasesList, Optional[str]) -> "ReleaseUrlCollection" + return cls(urls=urls, name=name) + + @property + def wheels(self): + # type: () -> Iterator[ReleaseUrl] + for url in self.urls: + if not url.is_wheel: + continue + yield url + + @property + def sdists(self): + # type: () -> Iterator[ReleaseUrl] + for url in self.urls: + if not url.is_sdist: + continue + yield url + + def __iter__(self): + # type: () -> Iterator[ReleaseUrl] + return iter(self.urls) + + def __getitem__(self, key): + # type: (int) -> ReleaseUrl + return self.urls.__getitem__(key) + + def __len__(self): + # type: () -> int + return len(self.urls) + + @property + def latest(self): + # type: () -> Optional[ReleaseUrl] + if not self.urls: + return None + return next( + iter(sorted(self.urls, key=operator.attrgetter("upload_time"), reverse=True)) + ) + + @property + def latest_timestamp(self): + # type: () -> Optional[datetime.datetime] + latest = self.latest + if latest is not None: + return latest.upload_time + return None + + def find_package_type(self, type_): + # type: (str) -> Optional[ReleaseUrl] + """ + Given a package type (e.g. sdist, bdist_wheel), find the matching release + + :param str type_: A package type from :const:`~PACKAGE_TYPES` + :return: The package from this collection matching that type, if available + :rtype: Optional[ReleaseUrl] + """ + if type_ not in PACKAGE_TYPES: + raise ValueError( + "Invalid package type: {0}. Expected one of {1}".format( + type_, " ".join(PACKAGE_TYPES) + ) + ) + return next(iter(url for url in self.urls if url.packagetype == type_), None) + + +def convert_release_urls_to_collection(urls=None, name=None): + # type: (Optional[TReleasesList], Optional[str]) -> ReleaseUrlCollection + if urls is None: + urls = [] + urls = create_release_urls_from_list(urls, name=name) + return ReleaseUrlCollection.create(urls, name=name) + + +@attr.s(frozen=True) +class Release(Sequence): + #: The version of the release + version = attr.ib(type=str) + #: The URL collection for the release + urls = attr.ib( + converter=instance_check_converter( # type: ignore + ReleaseUrlCollection, convert_release_urls_to_collection + ), + type=ReleaseUrlCollection, + ) + #: the name of the package + name = attr.ib(default=None) # type: Optional[str] + + def __iter__(self): + # type: () -> Iterator[ReleaseUrlCollection] + return iter(self.urls) + + def __getitem__(self, key): + return self.urls[key] + + def __len__(self): + # type: () -> int + return len(self.urls) + + @property + def yanked(self): + # type: () -> bool + if not self.urls: + return True + return False + + @property + def parsed_version(self): + # type: () -> packaging.version._BaseVersion + return packaging.version.parse(self.version) + + @property + def wheels(self): + # type: () -> Iterator[ReleaseUrl] + return self.urls.wheels + + @property + def sdists(self): + # type: () -> Iterator[ReleaseUrl] + return self.urls.sdists + + @property + def latest(self): + # type: () -> ReleaseUrl + return self.urls.latest + + @property + def latest_timestamp(self): + # type: () -> datetime.datetime + return self.urls.latest_timestamp + + def to_lockfile(self): + # type: () -> Dict[str, Union[List[str], str]] + return { + "hashes": [str(url.sha256) for url in self.urls if url.sha256 is not None], + "version": "=={0}".format(self.version), + } + + +def get_release(version, urls, name=None): + # type: (str, TReleasesList, Optional[str]) -> Release + release_kwargs = {"version": version, "name": name} + if not isinstance(urls, ReleaseUrlCollection): + release_kwargs["urls"] = convert_release_urls_to_collection(urls, name=name) + else: + release_kwargs["urls"] = urls + return Release(**release_kwargs) # type: ignore + + +def get_releases_from_package(releases, name=None): + # type: (TReleasesDict, Optional[str]) -> List[Release] + release_list = [] + for version, urls in releases.items(): + release_list.append(get_release(version, urls, name=name)) + return release_list + + +@attr.s(frozen=True) +class ReleaseCollection(object): + releases = attr.ib( + factory=list, converter=instance_check_converter(list, get_releases_from_package), # type: ignore + ) # type: List[Release] + + def __iter__(self): + # type: () -> Iterator[Release] + return iter(self.releases) + + def __getitem__(self, key): + # type: (str) -> Release + result = next(iter(r for r in self.releases if r.version == key), None) + if result is None: + raise KeyError(key) + return result + + def __len__(self): + # type: () -> int + return len(self.releases) + + def get_latest_lockfile(self): + # type: () -> Dict[str, Union[str, List[str]]] + return self.latest.to_lockfile() + + def wheels(self): + # type: () -> Iterator[ReleaseUrl] + for release in self.sort_releases(): + for wheel in release.wheels: + yield wheel + + def sdists(self): + # type: () -> Iterator[ReleaseUrl] + for release in self.sort_releases(): + for sdist in release.sdists: + yield sdist + + @property + def non_yanked_releases(self): + # type: () -> List[Release] + return list(r for r in self.releases if not r.yanked) + + def sort_releases(self): + # type: () -> List[Release] + return sorted( + self.non_yanked_releases, + key=operator.attrgetter("latest_timestamp"), + reverse=True, + ) + + @property + def latest(self): + # type: () -> Optional[Release] + return next(iter(r for r in self.sort_releases() if not r.yanked)) + + @classmethod + def load(cls, releases, name=None): + # type: (Union[TReleasesDict, List[Release]], Optional[str]) -> "ReleaseCollection" + if not isinstance(releases, list): + releases = get_releases_from_package(releases, name=name) + return cls(releases) + + +def convert_releases_to_collection(releases, name=None): + # type: (TReleasesDict, Optional[str]) -> ReleaseCollection + return ReleaseCollection.load(releases, name=name) + + +def split_keywords(value): + # type: (Union[str, List]) -> List[str] + if value and isinstance(value, six.string_types): + return value.split(",") + elif isinstance(value, list): + return value + return [] + + +def create_dependencies( + requires_dist, # type: Optional[List[Dependency]] + parent=None, # type: Optional[Dependency] +): + # type: (...) -> Optional[Set[Dependency]] + if requires_dist is None: + return None + dependencies = set() + for req in requires_dist: + if not isinstance(req, Dependency): + dependencies.add(Dependency.from_str(req, parent=parent)) + else: + dependencies.add(req) + return dependencies + + +@attr.s(frozen=True) +class PackageInfo(object): + name = attr.ib(type=str) + version = attr.ib(type=str) + package_url = attr.ib(type=str) + summary = attr.ib(type=str, default=None) # type: Optional[str] + author = attr.ib(type=str, default=None) # type: Optional[str] + keywords = attr.ib(factory=list, converter=split_keywords) # type: List[str] + description = attr.ib(type=str, default="") + download_url = attr.ib(type=str, default="") + home_page = attr.ib(type=str, default="") + license = attr.ib(type=str, default="") + maintainer = attr.ib(type=str, default="") + maintainer_email = attr.ib(type=str, default="") + downloads = attr.ib(factory=dict) # type: Dict[str, int] + docs_url = attr.ib(default=None) # type: Optional[str] + platform = attr.ib(type=str, default="") + project_url = attr.ib(type=str, default="") + project_urls = attr.ib(factory=dict) # type: Dict[str, str] + requires_python = attr.ib(default=None) # type: Optional[str] + requires_dist = attr.ib(factory=list) # type: List[Dependency] + release_url = attr.ib(default=None) # type: Optional[str] + description_content_type = attr.ib(type=str, default="text/md") + bugtrack_url = attr.ib(default=None) # type: str + classifiers = attr.ib(factory=list) # type: List[str] + author_email = attr.ib(default=None) # type: Optional[str] + markers = attr.ib(default=None) # type: Optional[str] + dependencies = attr.ib(default=None) # type: Tuple[Dependency] + + @classmethod + def from_json(cls, info_json): + # type: (TPackageInfo) -> "PackageInfo" + return cls(**filter_dict(info_json)) # type: ignore + + def to_dependency(self): + # type: () -> Dependency + return Dependency.from_info(self) + + def create_dependencies(self, force=False): + # type: (bool) -> "PackageInfo" + """ + Create values for **self.dependencies**. + + :param bool force: Sets **self.dependencies** to an empty tuple if it would be + None, defaults to False. + :return: An updated instance of the current object with **self.dependencies** + updated accordingly. + :rtype: :class:`PackageInfo` + """ + if not self.dependencies and not self.requires_dist: + if force: + return attr.evolve(self, dependencies=tuple()) + return self + self_dependency = self.to_dependency() + deps = set() + self_dependencies = tuple() if not self.dependencies else self.dependencies + for dep in self_dependencies: + if dep is None: + continue + new_dep = dep.add_parent(self_dependency) + deps.add(new_dep) + created_deps = create_dependencies(self.requires_dist, parent=self_dependency) + if created_deps is not None: + for dep in created_deps: + if dep is None: + continue + deps.add(dep) + return attr.evolve(self, dependencies=tuple(sorted(deps))) + + +def convert_package_info(info_json): + # type: (Union[TPackageInfo, PackageInfo]) -> PackageInfo + if isinstance(info_json, PackageInfo): + return info_json + return PackageInfo.from_json(info_json) + + +def add_markers_to_dep(d, marker_str): + # type: (str, Union[str, Marker]) -> str + req = PackagingRequirement(d) + existing_marker = getattr(req, "marker", None) + if isinstance(marker_str, Marker): + marker_str = str(marker_str) + if existing_marker is not None: + marker_str = str(merge_markers(existing_marker, marker_str)) + if marker_str: + marker_str = marker_str.replace("'", '"') + req.marker = Marker(marker_str) + return str(req) + + +@attr.s +class Package(object): + info = attr.ib(type=PackageInfo, converter=convert_package_info) + last_serial = attr.ib(type=int) + releases = attr.ib( + type=ReleaseCollection, + converter=instance_check_converter( # type: ignore + ReleaseCollection, convert_releases_to_collection + ), + ) + # XXX: Note: sometimes releases have no urls at the top level (e.g. pyrouge) + urls = attr.ib( + type=ReleaseUrlCollection, + converter=instance_check_converter( # type: ignore + ReleaseUrlCollection, convert_release_urls_to_collection + ), + ) + + @urls.default + def _get_urls_collection(self): + return functools.partial(convert_release_urls_to_collection, urls=[], name=self.name) + + @property + def name(self): + # type: () -> str + return self.info.name + + @property + def version(self): + # type: () -> str + return self.info.version + + @property + def requirement(self): + # type: () -> PackagingRequirement + return self.info.to_dependency().requirement + + @property + def latest_sdist(self): + # type: () -> ReleaseUrl + return next(iter(self.urls.sdists)) + + @property + def latest_wheels(self): + # type: () -> Iterator[ReleaseUrl] + for wheel in self.urls.wheels: + yield wheel + + @property + def dependencies(self): + # type: () -> List[Dependency] + if self.info.dependencies is None and list(self.urls): + rval = self.get_dependencies() + return rval.dependencies + return list(self.info.dependencies) + + def get_dependencies(self): + # type: () -> "Package" + urls = [] # type: List[ReleaseUrl] + deps = set() # type: Set[str] + info = self.info + if info.dependencies is None: + for url in self.urls: + try: + url, dep_dict = url.get_dependencies() + except (RuntimeError, TypeError): + # This happens if we are parsing `setup.py` and we fail + if url.is_sdist: + continue + else: + raise + markers = url.markers + dep_list = dep_dict.get("requires_dist", []) + for dep in dep_list: + # XXX: We need to parse these as requirements and "and" the markers + # XXX: together because they may contain "extra" markers which we + # XXX: will need to parse and remove + deps.add(add_markers_to_dep(dep, markers)) + urls.append(url) + if None in deps: + deps.remove(None) + info = attr.evolve( + self.info, requires_dist=tuple(sorted(deps)) + ).create_dependencies(force=True) + return attr.evolve(self, info=info, urls=urls) + + @classmethod + def from_json(cls, package_json): + # type: (Dict[str, Any]) -> "Package" + info = convert_package_info(package_json["info"]).create_dependencies() + releases = convert_releases_to_collection( + package_json["releases"], name=info.name + ) + urls = convert_release_urls_to_collection(package_json["urls"], name=info.name) + return cls( + info=info, + releases=releases, + urls=urls, + last_serial=package_json["last_serial"], + ) + + def pin_dependencies(self, include_extras=None): + # type: (Optional[List[str]]) -> Tuple[List["Package"], Dict[str, List[SpecifierSet]]] + deps = [] + if include_extras: + include_extras = list(sorted(set(include_extras))) + else: + include_extras = [] + constraints = defaultdict(list) + for dep in self.dependencies: + if dep.from_extras and dep.from_extras not in include_extras: + continue + if dep.specifier: + constraints[dep.name].append(dep.specifier) + try: + pinned = dep.pin() + except requests.exceptions.HTTPError: + continue + deps.append(pinned) + return deps, constraints + + def get_latest_lockfile(self): + # type: () -> Dict[str, Dict[str, Union[List[str], str]]] + lockfile = {} + constraints = {dep.name: dep.specifier for dep in self.dependencies} + deps, _ = self.pin_dependencies() + for dep in deps: + dep = dep.get_dependencies() + for sub_dep in dep.dependencies: + if sub_dep.name not in constraints: + logger.info( + "Adding {0} (from {1}) {2!s}".format( + sub_dep.name, dep.name, sub_dep.specifier + ) + ) + constraints[sub_dep.name] = sub_dep.specifier + else: + existing = "{0} (from {1}): {2!s} + ".format( + sub_dep.name, dep.name, constraints[sub_dep.name] + ) + new_specifier = sub_dep.specifier + merged = constraints[sub_dep.name] & new_specifier + logger.info( + "Updating: {0}{1!s} = {2!s}".format( + existing, new_specifier, merged + ) + ) + constraints[sub_dep.name] = merged + + lockfile.update({dep.info.name: dep.releases.get_latest_lockfile()}) + for sub_dep_name, specset in constraints.items(): + try: + sub_dep_pkg = get_package(sub_dep_name) + except requests.exceptions.HTTPError: + continue + logger.info("Getting package: {0} ({1!s})".format(sub_dep, specset)) + sorted_releases = list( + sorted( + sub_dep_pkg.releases, + key=operator.attrgetter("parsed_version"), + reverse=True, + ) + ) + try: + version = next(iter(specset.filter((r.version for r in sorted_releases)))) + except StopIteration: + logger.info("No version of {0} matches specifier: {1}".format(sub_dep, specset)) + logger.info( + "Available versions: {0}".format( + " ".join([r.version for r in sorted_releases]) + ) + ) + raise + sub_dep_instance = get_package_version(sub_dep_name, version=str(version)) + if sub_dep_instance is None: + continue + lockfile.update( + { + sub_dep_instance.info.name: sub_dep_instance.releases.get_latest_lockfile() + } + ) + # lockfile.update(dep.get_latest_lockfile()) + lockfile.update({self.info.name: self.releases.get_latest_lockfile()}) + return lockfile + + def as_dict(self): + # type: () -> Dict[str, Any] + return json.loads(self.serialize()) + + def serialize(self): + # type: () -> str + return json.dumps(attr.asdict(self), cls=PackageEncoder, indent=4) + + +def get_package(name): + # type: (str) -> Package + url = "https://pypi.org/pypi/{}/json".format(name) + with requests.get(url) as r: + r.raise_for_status() + result = r.json() + package = Package.from_json(result) + return package + + +def get_package_version(name, version): + # type: (str, str) -> Package + url = "https://pypi.org/pypi/{0}/{1}/json".format(name, version) + with requests.get(url) as r: + r.raise_for_status() + result = r.json() + package = Package.from_json(result) + return package + + +def get_package_from_requirement(req): + # type: (PackagingRequirement) -> Tuple[Package, Set[str]] + versions = set() + if is_pinned_requirement(req): + version = get_pinned_version(req) + versions.add(version) + pkg = get_package_version(req.name, version) + else: + pkg = get_package(req.name) + sorted_releases = list( + sorted(pkg.releases, key=operator.attrgetter("parsed_version"), reverse=True) + ) + versions = set(req.specifier.filter((r.version for r in sorted_releases))) + version = next(iter(req.specifier.filter((r.version for r in sorted_releases)))) + if pkg.version not in versions: + pkg = get_package_version(pkg.name, version) + return pkg, versions diff --git a/src/requirementslib/models/utils.py b/src/requirementslib/models/utils.py index 9b6beb64..6c3b7de8 100644 --- a/src/requirementslib/models/utils.py +++ b/src/requirementslib/models/utils.py @@ -723,7 +723,7 @@ def get_pinned_version(ireq): except AttributeError: raise TypeError("Expected InstallRequirement, not {}".format(type(ireq).__name__)) - if ireq.editable: + if getattr(ireq, "editable", False): raise ValueError("InstallRequirement is editable") if not specifier: raise ValueError("InstallRequirement has no version specification") diff --git a/tests/conftest.py b/tests/conftest.py index 0ad56c1d..e788420e 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,10 +1,15 @@ # -*- coding=utf-8 -*- from __future__ import absolute_import, print_function +import contextlib +import io +import json import os +import random import shutil import warnings +import distlib.wheel import pip_shims import pytest import requests @@ -144,6 +149,70 @@ def pipfile_dir(fixture_dir): return fixture_dir / "pipfile" +@pytest.fixture +def package_json(fixture_dir, request): + name = request.param["name"] + json_path = fixture_dir / "{0}.json".format(name) + return json.loads(json_path.read_text()) + + +@pytest.fixture +def monkeypatch_wheel_download(monkeypatch, fixture_dir): + @contextlib.contextmanager + def open_file(link, session=None, stream=True): + link_filename = os.path.basename(link) + dirname = distlib.wheel.Wheel(link_filename).name + wheel_path = fixture_dir / "wheels" / dirname / link_filename + buff = io.BytesIO(wheel_path.read_bytes()) + yield buff + + with monkeypatch.context() as m: + m.setattr(vistir.contextmanagers, "open_file", open_file) + yield + + +@pytest.fixture +def gen_metadata(request): + name = request.param.get("name", "test-package") + version = request.param.get( + version, + "{0}.{1}.{2}".format( + random.randint(0, 5), random.randint(0, 10), random.randint(0, 10) + ), + ) + default_packages = ['enum34 ; python_version < "3.4"', "six", "requests"] + packages = "\n".join( + [ + "Requires-Dist: {0}".format(pkg) + for pkg in request.param.get("packages", default_packages) + ] + ) + return """ +Metadata-Version: 2.1 +Name: {name} +Version: {version} +Summary: This is a test package +Home-page: http://test-package.test +Author: Test Author +Author-email: Fake-Author@test-package.test +License: MIT +Download-URL: https://github.com/this-is-fake/fake +Platform: UNKNOWN +Classifier: Development Status :: 4 - Beta +Classifier: Intended Audience :: Developers +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 2.7 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +{packages} +""".format( + name=name, version=version, packages=packages + ) + + @pytest.fixture def test_artifact(artifact_dir, pathlib_tmpdir, request): import requirementslib.utils diff --git a/tests/fixtures/celery.json b/tests/fixtures/celery.json new file mode 100644 index 00000000..1ca2d926 --- /dev/null +++ b/tests/fixtures/celery.json @@ -0,0 +1,4160 @@ +{ + "info": { + "author": "Ask Solem", + "author_email": "auvipy@gmail.com", + "bugtrack_url": null, + "classifiers": [ + "Development Status :: 5 - Production/Stable", + "License :: OSI Approved :: BSD License", + "Operating System :: OS Independent", + "Programming Language :: Python", + "Programming Language :: Python :: 2", + "Programming Language :: Python :: 2.7", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.5", + "Programming Language :: Python :: 3.6", + "Programming Language :: Python :: 3.7", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: Implementation :: CPython", + "Programming Language :: Python :: Implementation :: PyPy", + "Topic :: Software Development :: Object Brokering", + "Topic :: System :: Distributed Computing" + ], + "description": ".. image:: http://docs.celeryproject.org/en/latest/_images/celery-banner-small.png\n\n|build-status| |coverage| |license| |wheel| |pyversion| |pyimp| |ocbackerbadge| |ocsponsorbadge|\n\n:Version: 4.4.0 (cliffs)\n:Web: http://celeryproject.org/\n:Download: https://pypi.org/project/celery/\n:Source: https://github.com/celery/celery/\n:Keywords: task, queue, job, async, rabbitmq, amqp, redis,\n python, distributed, actors\n\nDonations\n=========\n\nThis project relies on your generous donations.\n\nIf you are using Celery to create a commercial product, please consider becoming our `backer`_ or our `sponsor`_ to ensure Celery's future.\n\n.. _`backer`: https://opencollective.com/celery#backer\n.. _`sponsor`: https://opencollective.com/celery#sponsor\n\nFor enterprise\n==============\n\nAvailable as part of the Tidelift Subscription.\n\nThe maintainers of ``celery`` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. `Learn more. `_\n\nWhat's a Task Queue?\n====================\n\nTask queues are used as a mechanism to distribute work across threads or\nmachines.\n\nA task queue's input is a unit of work, called a task, dedicated worker\nprocesses then constantly monitor the queue for new work to perform.\n\nCelery communicates via messages, usually using a broker\nto mediate between clients and workers. To initiate a task a client puts a\nmessage on the queue, the broker then delivers the message to a worker.\n\nA Celery system can consist of multiple workers and brokers, giving way\nto high availability and horizontal scaling.\n\nCelery is written in Python, but the protocol can be implemented in any\nlanguage. In addition to Python there's node-celery_ for Node.js,\na `PHP client`_ and `gocelery`_ for golang.\n\nLanguage interoperability can also be achieved by using webhooks\nin such a way that the client enqueues an URL to be requested by a worker.\n\n.. _node-celery: https://github.com/mher/node-celery\n.. _`PHP client`: https://github.com/gjedeer/celery-php\n.. _`gocelery`: https://github.com/gocelery/gocelery\n\nWhat do I need?\n===============\n\nCelery version 4.3 runs on,\n\n- Python (2.7, 3.8, 3.5, 3.6, 3.7)\n- PyPy2.7 (7.2)\n- PyPy3.5 (7.1)\n- PyPy3.6 (7.6)\n\n\n4.x.x is the last version to support Python 2.7,\nand from the next major version (Celery 5.x) Python 3.6 or newer is required.\n\nIf you're running an older version of Python, you need to be running\nan older version of Celery:\n\n- Python 2.6: Celery series 3.1 or earlier.\n- Python 2.5: Celery series 3.0 or earlier.\n- Python 2.4 was Celery series 2.2 or earlier.\n\nCelery is a project with minimal funding,\nso we don't support Microsoft Windows.\nPlease don't open any issues related to that platform.\n\n*Celery* is usually used with a message broker to send and receive messages.\nThe RabbitMQ, Redis transports are feature complete,\nbut there's also experimental support for a myriad of other solutions, including\nusing SQLite for local development.\n\n*Celery* can run on a single machine, on multiple machines, or even\nacross datacenters.\n\nGet Started\n===========\n\nIf this is the first time you're trying to use Celery, or you're\nnew to Celery 4.4 coming from previous versions then you should read our\ngetting started tutorials:\n\n- `First steps with Celery`_\n\n Tutorial teaching you the bare minimum needed to get started with Celery.\n\n- `Next steps`_\n\n A more complete overview, showing more features.\n\n.. _`First steps with Celery`:\n http://docs.celeryproject.org/en/latest/getting-started/first-steps-with-celery.html\n\n.. _`Next steps`:\n http://docs.celeryproject.org/en/latest/getting-started/next-steps.html\n\nCelery is...\n=============\n\n- **Simple**\n\n Celery is easy to use and maintain, and does *not need configuration files*.\n\n It has an active, friendly community you can talk to for support,\n like at our `mailing-list`_, or the IRC channel.\n\n Here's one of the simplest applications you can make::\n\n from celery import Celery\n\n app = Celery('hello', broker='amqp://guest@localhost//')\n\n @app.task\n def hello():\n return 'hello world'\n\n- **Highly Available**\n\n Workers and clients will automatically retry in the event\n of connection loss or failure, and some brokers support\n HA in way of *Primary/Primary* or *Primary/Replica* replication.\n\n- **Fast**\n\n A single Celery process can process millions of tasks a minute,\n with sub-millisecond round-trip latency (using RabbitMQ,\n py-librabbitmq, and optimized settings).\n\n- **Flexible**\n\n Almost every part of *Celery* can be extended or used on its own,\n Custom pool implementations, serializers, compression schemes, logging,\n schedulers, consumers, producers, broker transports, and much more.\n\nIt supports...\n================\n\n - **Message Transports**\n\n - RabbitMQ_, Redis_, Amazon SQS\n\n - **Concurrency**\n\n - Prefork, Eventlet_, gevent_, single threaded (``solo``)\n\n - **Result Stores**\n\n - AMQP, Redis\n - memcached\n - SQLAlchemy, Django ORM\n - Apache Cassandra, IronCache, Elasticsearch\n\n - **Serialization**\n\n - *pickle*, *json*, *yaml*, *msgpack*.\n - *zlib*, *bzip2* compression.\n - Cryptographic message signing.\n\n.. _`Eventlet`: http://eventlet.net/\n.. _`gevent`: http://gevent.org/\n\n.. _RabbitMQ: https://rabbitmq.com\n.. _Redis: https://redis.io\n.. _SQLAlchemy: http://sqlalchemy.org\n\nFramework Integration\n=====================\n\nCelery is easy to integrate with web frameworks, some of which even have\nintegration packages:\n\n +--------------------+------------------------+\n | `Django`_ | not needed |\n +--------------------+------------------------+\n | `Pyramid`_ | `pyramid_celery`_ |\n +--------------------+------------------------+\n | `Pylons`_ | `celery-pylons`_ |\n +--------------------+------------------------+\n | `Flask`_ | not needed |\n +--------------------+------------------------+\n | `web2py`_ | `web2py-celery`_ |\n +--------------------+------------------------+\n | `Tornado`_ | `tornado-celery`_ |\n +--------------------+------------------------+\n\nThe integration packages aren't strictly necessary, but they can make\ndevelopment easier, and sometimes they add important hooks like closing\ndatabase connections at ``fork``.\n\n.. _`Django`: https://djangoproject.com/\n.. _`Pylons`: http://pylonsproject.org/\n.. _`Flask`: http://flask.pocoo.org/\n.. _`web2py`: http://web2py.com/\n.. _`Bottle`: https://bottlepy.org/\n.. _`Pyramid`: http://docs.pylonsproject.org/en/latest/docs/pyramid.html\n.. _`pyramid_celery`: https://pypi.org/project/pyramid_celery/\n.. _`celery-pylons`: https://pypi.org/project/celery-pylons/\n.. _`web2py-celery`: https://code.google.com/p/web2py-celery/\n.. _`Tornado`: http://www.tornadoweb.org/\n.. _`tornado-celery`: https://github.com/mher/tornado-celery/\n\n.. _celery-documentation:\n\nDocumentation\n=============\n\nThe `latest documentation`_ is hosted at Read The Docs, containing user guides,\ntutorials, and an API reference.\n\n\u6700\u65b0\u7684\u4e2d\u6587\u6587\u6863\u6258\u7ba1\u5728 https://www.celerycn.io/ \u4e2d\uff0c\u5305\u542b\u7528\u6237\u6307\u5357\u3001\u6559\u7a0b\u3001API\u63a5\u53e3\u7b49\u3002\n\n.. _`latest documentation`: http://docs.celeryproject.org/en/latest/\n\n.. _celery-installation:\n\nInstallation\n============\n\nYou can install Celery either via the Python Package Index (PyPI)\nor from source.\n\nTo install using ``pip``:\n\n::\n\n\n $ pip install -U Celery\n\n.. _bundles:\n\nBundles\n-------\n\nCelery also defines a group of bundles that can be used\nto install Celery and the dependencies for a given feature.\n\nYou can specify these in your requirements or on the ``pip``\ncommand-line by using brackets. Multiple bundles can be specified by\nseparating them by commas.\n\n::\n\n\n $ pip install \"celery[librabbitmq]\"\n\n $ pip install \"celery[librabbitmq,redis,auth,msgpack]\"\n\nThe following bundles are available:\n\nSerializers\n~~~~~~~~~~~\n\n:``celery[auth]``:\n for using the ``auth`` security serializer.\n\n:``celery[msgpack]``:\n for using the msgpack serializer.\n\n:``celery[yaml]``:\n for using the yaml serializer.\n\nConcurrency\n~~~~~~~~~~~\n\n:``celery[eventlet]``:\n for using the ``eventlet`` pool.\n\n:``celery[gevent]``:\n for using the ``gevent`` pool.\n\nTransports and Backends\n~~~~~~~~~~~~~~~~~~~~~~~\n\n:``celery[librabbitmq]``:\n for using the librabbitmq C library.\n\n:``celery[redis]``:\n for using Redis as a message transport or as a result backend.\n\n:``celery[sqs]``:\n for using Amazon SQS as a message transport.\n\n:``celery[tblib``]:\n for using the ``task_remote_tracebacks`` feature.\n\n:``celery[memcache]``:\n for using Memcached as a result backend (using ``pylibmc``)\n\n:``celery[pymemcache]``:\n for using Memcached as a result backend (pure-Python implementation).\n\n:``celery[cassandra]``:\n for using Apache Cassandra as a result backend with DataStax driver.\n\n:``celery[azureblockblob]``:\n for using Azure Storage as a result backend (using ``azure-storage``)\n\n:``celery[s3]``:\n for using S3 Storage as a result backend.\n\n:``celery[couchbase]``:\n for using Couchbase as a result backend.\n\n:``celery[arangodb]``:\n for using ArangoDB as a result backend.\n\n:``celery[elasticsearch]``:\n for using Elasticsearch as a result backend.\n\n:``celery[riak]``:\n for using Riak as a result backend.\n\n:``celery[cosmosdbsql]``:\n for using Azure Cosmos DB as a result backend (using ``pydocumentdb``)\n\n:``celery[zookeeper]``:\n for using Zookeeper as a message transport.\n\n:``celery[sqlalchemy]``:\n for using SQLAlchemy as a result backend (*supported*).\n\n:``celery[pyro]``:\n for using the Pyro4 message transport (*experimental*).\n\n:``celery[slmq]``:\n for using the SoftLayer Message Queue transport (*experimental*).\n\n:``celery[consul]``:\n for using the Consul.io Key/Value store as a message transport or result backend (*experimental*).\n\n:``celery[django]``:\n specifies the lowest version possible for Django support.\n\n You should probably not use this in your requirements, it's here\n for informational purposes only.\n\n\n.. _celery-installing-from-source:\n\nDownloading and installing from source\n--------------------------------------\n\nDownload the latest version of Celery from PyPI:\n\nhttps://pypi.org/project/celery/\n\nYou can install it by doing the following,:\n\n::\n\n\n $ tar xvfz celery-0.0.0.tar.gz\n $ cd celery-0.0.0\n $ python setup.py build\n # python setup.py install\n\nThe last command must be executed as a privileged user if\nyou aren't currently using a virtualenv.\n\n.. _celery-installing-from-git:\n\nUsing the development version\n-----------------------------\n\nWith pip\n~~~~~~~~\n\nThe Celery development version also requires the development\nversions of ``kombu``, ``amqp``, ``billiard``, and ``vine``.\n\nYou can install the latest snapshot of these using the following\npip commands:\n\n::\n\n\n $ pip install https://github.com/celery/celery/zipball/master#egg=celery\n $ pip install https://github.com/celery/billiard/zipball/master#egg=billiard\n $ pip install https://github.com/celery/py-amqp/zipball/master#egg=amqp\n $ pip install https://github.com/celery/kombu/zipball/master#egg=kombu\n $ pip install https://github.com/celery/vine/zipball/master#egg=vine\n\nWith git\n~~~~~~~~\n\nPlease see the Contributing section.\n\n.. _getting-help:\n\nGetting Help\n============\n\n.. _mailing-list:\n\nMailing list\n------------\n\nFor discussions about the usage, development, and future of Celery,\nplease join the `celery-users`_ mailing list.\n\n.. _`celery-users`: https://groups.google.com/group/celery-users/\n\n.. _irc-channel:\n\nIRC\n---\n\nCome chat with us on IRC. The **#celery** channel is located at the `Freenode`_\nnetwork.\n\n.. _`Freenode`: https://freenode.net\n\n.. _bug-tracker:\n\nBug tracker\n===========\n\nIf you have any suggestions, bug reports, or annoyances please report them\nto our issue tracker at https://github.com/celery/celery/issues/\n\n.. _wiki:\n\nWiki\n====\n\nhttps://github.com/celery/celery/wiki\n\nCredits\n=======\n\n.. _contributing-short:\n\nContributors\n------------\n\nThis project exists thanks to all the people who contribute. Development of\n`celery` happens at GitHub: https://github.com/celery/celery\n\nYou're highly encouraged to participate in the development\nof `celery`. If you don't like GitHub (for some reason) you're welcome\nto send regular patches.\n\nBe sure to also read the `Contributing to Celery`_ section in the\ndocumentation.\n\n.. _`Contributing to Celery`:\n http://docs.celeryproject.org/en/master/contributing.html\n\n|oc-contributors|\n\n.. |oc-contributors| image:: https://opencollective.com/celery/contributors.svg?width=890&button=false\n :target: https://github.com/celery/celery/graphs/contributors\n\nBackers\n-------\n\nThank you to all our backers! \ud83d\ude4f [`Become a backer`_]\n\n.. _`Become a backer`: https://opencollective.com/celery#backer\n\n|oc-backers|\n\n.. |oc-backers| image:: https://opencollective.com/celery/backers.svg?width=890\n :target: https://opencollective.com/celery#backers\n\nSponsors\n--------\n\nSupport this project by becoming a sponsor. Your logo will show up here with a\nlink to your website. [`Become a sponsor`_]\n\n.. _`Become a sponsor`: https://opencollective.com/celery#sponsor\n\n|oc-sponsors|\n\n.. |oc-sponsors| image:: https://opencollective.com/celery/sponsor/0/avatar.svg\n :target: https://opencollective.com/celery/sponsor/0/website\n\n.. _license:\n\nLicense\n=======\n\nThis software is licensed under the `New BSD License`. See the ``LICENSE``\nfile in the top distribution directory for the full license text.\n\n.. # vim: syntax=rst expandtab tabstop=4 shiftwidth=4 shiftround\n\n.. |build-status| image:: https://secure.travis-ci.org/celery/celery.png?branch=master\n :alt: Build status\n :target: https://travis-ci.org/celery/celery\n\n.. |coverage| image:: https://codecov.io/github/celery/celery/coverage.svg?branch=master\n :target: https://codecov.io/github/celery/celery?branch=master\n\n.. |license| image:: https://img.shields.io/pypi/l/celery.svg\n :alt: BSD License\n :target: https://opensource.org/licenses/BSD-3-Clause\n\n.. |wheel| image:: https://img.shields.io/pypi/wheel/celery.svg\n :alt: Celery can be installed via wheel\n :target: https://pypi.org/project/celery/\n\n.. |pyversion| image:: https://img.shields.io/pypi/pyversions/celery.svg\n :alt: Supported Python versions.\n :target: https://pypi.org/project/celery/\n\n.. |pyimp| image:: https://img.shields.io/pypi/implementation/celery.svg\n :alt: Support Python implementations.\n :target: https://pypi.org/project/celery/\n\n.. |ocbackerbadge| image:: https://opencollective.com/celery/backers/badge.svg\n :alt: Backers on Open Collective\n :target: #backers\n\n.. |ocsponsorbadge| image:: https://opencollective.com/celery/sponsors/badge.svg\n :alt: Sponsors on Open Collective\n :target: #sponsors\n\n.. |downloads| image:: https://pepy.tech/badge/celery\n :alt: Downloads\n :target: https://pepy.tech/project/celery\n\n\n", + "description_content_type": "", + "docs_url": "https://pythonhosted.org/celery/", + "download_url": "", + "downloads": { + "last_day": -1, + "last_month": -1, + "last_week": -1 + }, + "home_page": "http://celeryproject.org", + "keywords": "task job queue distributed messaging actor", + "license": "BSD", + "maintainer": "", + "maintainer_email": "", + "name": "celery", + "package_url": "https://pypi.org/project/celery/", + "platform": "any", + "project_url": "https://pypi.org/project/celery/", + "project_urls": { + "Homepage": "http://celeryproject.org" + }, + "release_url": "https://pypi.org/project/celery/4.4.0/", + "requires_dist": [ + "pytz (>dev)", + "billiard (<4.0,>=3.6.1)", + "kombu (<4.7,>=4.6.7)", + "vine (==1.3.0)", + "pyArango (>=1.3.2) ; extra == 'arangodb'", + "cryptography ; extra == 'auth'", + "azure-storage (==0.36.0) ; extra == 'azureblockblob'", + "azure-common (==1.1.5) ; extra == 'azureblockblob'", + "azure-storage-common (==1.1.0) ; extra == 'azureblockblob'", + "brotli (>=1.0.0) ; (platform_python_implementation == \"CPython\") and extra == 'brotli'", + "brotlipy (>=0.7.0) ; (platform_python_implementation == \"PyPy\") and extra == 'brotli'", + "cassandra-driver ; extra == 'cassandra'", + "python-consul ; extra == 'consul'", + "pydocumentdb (==2.3.2) ; extra == 'cosmosdbsql'", + "couchbase ; extra == 'couchbase'", + "couchbase-cffi ; (platform_python_implementation == \"PyPy\") and extra == 'couchbase'", + "pycouchdb ; extra == 'couchdb'", + "Django (>=1.11) ; extra == 'django'", + "boto3 (>=1.9.178) ; extra == 'dynamodb'", + "elasticsearch ; extra == 'elasticsearch'", + "eventlet (>=0.24.1) ; extra == 'eventlet'", + "gevent ; extra == 'gevent'", + "librabbitmq (>=1.5.0) ; extra == 'librabbitmq'", + "backports.lzma ; (python_version < \"3.3\") and extra == 'lzma'", + "pylibmc ; extra == 'memcache'", + "pymongo[srv] (>=3.3.0) ; extra == 'mongodb'", + "msgpack ; extra == 'msgpack'", + "python-memcached ; extra == 'pymemcache'", + "pyro4 ; extra == 'pyro'", + "redis (>=3.2.0) ; extra == 'redis'", + "riak (>=2.0) ; extra == 'riak'", + "boto3 (>=1.9.125) ; extra == 's3'", + "softlayer-messaging (>=1.0.3) ; extra == 'slmq'", + "ephem ; extra == 'solar'", + "sqlalchemy ; extra == 'sqlalchemy'", + "boto3 (>=1.9.125) ; extra == 'sqs'", + "pycurl ; extra == 'sqs'", + "tblib (>=1.3.0) ; (python_version < \"3.8.0\") and extra == 'tblib'", + "tblib (>=1.5.0) ; (python_version >= \"3.8.0\") and extra == 'tblib'", + "PyYAML (>=3.10) ; extra == 'yaml'", + "kazoo (>=1.3.1) ; extra == 'zookeeper'", + "zstandard ; extra == 'zstd'" + ], + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "summary": "Distributed Task Queue.", + "version": "4.4.0" + }, + "last_serial": 6308640, + "releases": { + "0.1.10": [ + { + "comment_text": "", + "digests": { + "md5": "f014724574211a4388fc0f2f2030cbf3", + "sha256": "97cf6609f6f1d4feef90694acba84cd36f1ed0442615d1f9e603a7dab042f1d5" + }, + "downloads": -1, + "filename": "celery-0.1.10.tar.gz", + "has_sig": false, + "md5_digest": "f014724574211a4388fc0f2f2030cbf3", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 58005, + "upload_time": "2009-05-11T12:53:20", + "upload_time_iso_8601": "2009-05-11T12:53:20.521919Z", + "url": "https://files.pythonhosted.org/packages/e4/c5/91b850759f576123085a3a60ee8356ce477ee467dbbf9ff6eec458e2237a/celery-0.1.10.tar.gz" + } + ], + "0.1.11": [ + { + "comment_text": "", + "digests": { + "md5": "67b7bd27c0412e4360eaed115aa46d1f", + "sha256": "7e281e3401acbd61328badf5c4b6f6a5cc00b9fd06733377754f3e29777aa23e" + }, + "downloads": -1, + "filename": "celery-0.1.11.tar.gz", + "has_sig": false, + "md5_digest": "67b7bd27c0412e4360eaed115aa46d1f", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 53134, + "upload_time": "2009-05-12T14:11:57", + "upload_time_iso_8601": "2009-05-12T14:11:57.536352Z", + "url": "https://files.pythonhosted.org/packages/fa/08/66b08efbe6e31e3bd7a235dab39aeafef2229dc4ccd1aaf48aaa4aa1952c/celery-0.1.11.tar.gz" + } + ], + "0.1.12": [ + { + "comment_text": "", + "digests": { + "md5": "ce560d3dac3b92bd01bb2bf39e69e0c5", + "sha256": "0ebf4d5f61452c50c8601c550a579a25d41ca447f3a1ebc59e4d2e59b24ae23e" + }, + "downloads": -1, + "filename": "celery-0.1.12.tar.gz", + "has_sig": false, + "md5_digest": "ce560d3dac3b92bd01bb2bf39e69e0c5", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 45502, + "upload_time": "2009-05-18T16:48:01", + "upload_time_iso_8601": "2009-05-18T16:48:01.569477Z", + "url": "https://files.pythonhosted.org/packages/01/ef/e63cda3896838b4231b73dac84213c7c559b30fbeb60dcc84d58f13b0f65/celery-0.1.12.tar.gz" + } + ], + "0.1.13": [ + { + "comment_text": "", + "digests": { + "md5": "7be6b0a2350055a5a39ad9d004dc0b19", + "sha256": "a8aa3d1c873ef6e2fcf0a1a4a1343360fadb76b6273c2097d1778c3308df7802" + }, + "downloads": -1, + "filename": "celery-0.1.13.tar.gz", + "has_sig": false, + "md5_digest": "7be6b0a2350055a5a39ad9d004dc0b19", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 245409, + "upload_time": "2009-05-19T12:52:16", + "upload_time_iso_8601": "2009-05-19T12:52:16.159662Z", + "url": "https://files.pythonhosted.org/packages/2c/40/b042ab9a23fe862f0243af651552a76d656c8f8c6593fb683e94758b07ae/celery-0.1.13.tar.gz" + } + ], + "0.1.14": [ + { + "comment_text": "", + "digests": { + "md5": "9fccaba71ef42dc60a9b96b450e84280", + "sha256": "f5a98b8a64916990abab043a551b9bb9155611b9bf0227389a02f76b699d3cf1" + }, + "downloads": -1, + "filename": "celery-0.1.14.tar.gz", + "has_sig": false, + "md5_digest": "9fccaba71ef42dc60a9b96b450e84280", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 245230, + "upload_time": "2009-05-19T13:10:10", + "upload_time_iso_8601": "2009-05-19T13:10:10.373285Z", + "url": "https://files.pythonhosted.org/packages/e8/d0/b3c2b77335f0d77661412d0fc3d7ee5ba268a7791cd614ff09a5737de93e/celery-0.1.14.tar.gz" + } + ], + "0.1.15": [ + { + "comment_text": "", + "digests": { + "md5": "a69642c5a741c575a7df6219008708b1", + "sha256": "c10bf64919d95501dbebd6bbd780ad06e150141522b1ac75d42669e390cbb3ab" + }, + "downloads": -1, + "filename": "celery-0.1.15.tar.gz", + "has_sig": false, + "md5_digest": "a69642c5a741c575a7df6219008708b1", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 276842, + "upload_time": "2009-05-19T16:21:07", + "upload_time_iso_8601": "2009-05-19T16:21:07.650308Z", + "url": "https://files.pythonhosted.org/packages/94/98/361d09b0042f22c2eae96e41516d0bb7675f2dcb2f0906e0c87b4496d7d0/celery-0.1.15.tar.gz" + } + ], + "0.1.2": [ + { + "comment_text": "", + "digests": { + "md5": "a63df9f3ce1883b90fdcd18df4ae79f7", + "sha256": "bc1d99ede8e9525b121029d724282dcda5191220a946f4695c7ad371f2c0561a" + }, + "downloads": -1, + "filename": "celery-0.1.2.tar.gz", + "has_sig": false, + "md5_digest": "a63df9f3ce1883b90fdcd18df4ae79f7", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 11383, + "upload_time": "2009-04-27T12:49:20", + "upload_time_iso_8601": "2009-04-27T12:49:20.215689Z", + "url": "https://files.pythonhosted.org/packages/c9/b7/4ea5dba86291f3c04c54b90388b39fa22cf55010cb93ca57f25b978987e0/celery-0.1.2.tar.gz" + } + ], + "0.1.4": [ + { + "comment_text": "", + "digests": { + "md5": "0eeae544975b5a51d7c12f2156fc17f1", + "sha256": "380e4d4c0cafb3f5f9a365639571b105284258293bdce92fc9049806929ad307" + }, + "downloads": -1, + "filename": "celery-0.1.4.tar.gz", + "has_sig": false, + "md5_digest": "0eeae544975b5a51d7c12f2156fc17f1", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 12873, + "upload_time": "2009-04-27T16:25:42", + "upload_time_iso_8601": "2009-04-27T16:25:42.898129Z", + "url": "https://files.pythonhosted.org/packages/c5/bd/b6d02275036d749ed04eeca6fa4791f8da0c12364ac534f50cf4cb0f67d0/celery-0.1.4.tar.gz" + } + ], + "0.1.6": [ + { + "comment_text": "", + "digests": { + "md5": "a037f7f1f4319efdeb8dea2872c07716", + "sha256": "3ea2ee74edb5071749855eba66316e3c080668eaac682db3199a0cc3318e27fc" + }, + "downloads": -1, + "filename": "celery-0.1.6.tar.gz", + "has_sig": false, + "md5_digest": "a037f7f1f4319efdeb8dea2872c07716", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 29537, + "upload_time": "2009-04-29T16:50:02", + "upload_time_iso_8601": "2009-04-29T16:50:02.322478Z", + "url": "https://files.pythonhosted.org/packages/c1/6b/2adaf75ea00d95e1acc6a669b8cec3e5d8de8152b942dd59888099b8a5bf/celery-0.1.6.tar.gz" + } + ], + "0.1.7": [ + { + "comment_text": "", + "digests": { + "md5": "8a8c0444e3e7b23b01c703db1ff74e19", + "sha256": "ee8b7ae0d974b2db1af1d2415e2441f1862284c9335e57b699be10228e0018e7" + }, + "downloads": -1, + "filename": "celery-0.1.7.tar.gz", + "has_sig": false, + "md5_digest": "8a8c0444e3e7b23b01c703db1ff74e19", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 32059, + "upload_time": "2009-04-30T14:32:02", + "upload_time_iso_8601": "2009-04-30T14:32:02.607127Z", + "url": "https://files.pythonhosted.org/packages/65/41/2ec777848ba6ba6d255f8f618bb5f7dba7401d40fc8cbca6ecc714ebd6e8/celery-0.1.7.tar.gz" + } + ], + "0.1.8": [ + { + "comment_text": "", + "digests": { + "md5": "aad8ea8df4c7b7b05aad7c37f6b12e26", + "sha256": "7a297c58c1f9e40358d788238bb316b7c668ccda7c9bb5f6b933dd19c7eaf0bb" + }, + "downloads": -1, + "filename": "celery-0.1.8.tar.gz", + "has_sig": false, + "md5_digest": "aad8ea8df4c7b7b05aad7c37f6b12e26", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 50456, + "upload_time": "2009-05-07T12:30:48", + "upload_time_iso_8601": "2009-05-07T12:30:48.181182Z", + "url": "https://files.pythonhosted.org/packages/5f/07/e57c2365cba307801a3b44d40c773297f2ee7c9f7f0b9a22db66d53e88da/celery-0.1.8.tar.gz" + } + ], + "0.2.0": [ + { + "comment_text": "", + "digests": { + "md5": "16e8e984153d898e6a2841d2b904fb0c", + "sha256": "aff01560ddc41099de467fdfb71147fbcb44a8a36ba77636c3316e6c5c1c0917" + }, + "downloads": -1, + "filename": "celery-0.2.0.tar.gz", + "has_sig": false, + "md5_digest": "16e8e984153d898e6a2841d2b904fb0c", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 374824, + "upload_time": "2009-05-27T18:19:48", + "upload_time_iso_8601": "2009-05-27T18:19:48.085180Z", + "url": "https://files.pythonhosted.org/packages/0a/8b/b533a83bf19fdaab487a7f1b2cd11f546336858e321292be7b56b8f2375e/celery-0.2.0.tar.gz" + } + ], + "0.3.0": [ + { + "comment_text": "", + "digests": { + "md5": "16a76c204f3cf5f3c37281fa1007d084", + "sha256": "a1c8623921dc89bdf39db9cba4d3b3641e058d20ae9ae8ffde7b67dc9b3d81f2" + }, + "downloads": -1, + "filename": "celery-0.3.0.tar.gz", + "has_sig": false, + "md5_digest": "16a76c204f3cf5f3c37281fa1007d084", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 427156, + "upload_time": "2009-06-08T18:05:54", + "upload_time_iso_8601": "2009-06-08T18:05:54.025526Z", + "url": "https://files.pythonhosted.org/packages/3c/00/d4786a6a1bde4138292cb46e4f76e6964610cdf2032eb5e7cdc59ad0bfb4/celery-0.3.0.tar.gz" + } + ], + "0.3.20": [ + { + "comment_text": "", + "digests": { + "md5": "2a00ad8c98e47f2be80197834e611a43", + "sha256": "69f5c8c5b80053069b087d66056883c2b6cadad479776020eb20343f2b01f29a" + }, + "downloads": -1, + "filename": "celery-0.3.20.tar.gz", + "has_sig": false, + "md5_digest": "2a00ad8c98e47f2be80197834e611a43", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 437683, + "upload_time": "2009-06-25T20:53:37", + "upload_time_iso_8601": "2009-06-25T20:53:37.474499Z", + "url": "https://files.pythonhosted.org/packages/31/82/ff63b78e39221ff0303eef2a870d290349a72f00d36c660ebe6fd82b3d8a/celery-0.3.20.tar.gz" + } + ], + "0.3.7": [ + { + "comment_text": "", + "digests": { + "md5": "4142a4b09e37f7ecd0cb199c137fe882", + "sha256": "d0797a1e31039f55a08f6f67f4cc0e0c9c32f987fd0dee93666c6f132aff4e0d" + }, + "downloads": -1, + "filename": "celery-0.3.7.tar.gz", + "has_sig": false, + "md5_digest": "4142a4b09e37f7ecd0cb199c137fe882", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 455872, + "upload_time": "2009-06-16T23:48:03", + "upload_time_iso_8601": "2009-06-16T23:48:03.750483Z", + "url": "https://files.pythonhosted.org/packages/07/32/977a11aab74ffe369a73be38bcfb6a209e3fdbff59efb7bc4993b396f5ab/celery-0.3.7.tar.gz" + } + ], + "0.4.0": [ + { + "comment_text": "", + "digests": { + "md5": "e55043f5abd461b66dd05fe605d39884", + "sha256": "0a48b662542dedb3576e5d413927e2a4d92c188aa043eb8fffa5e941ae87ea2b" + }, + "downloads": -1, + "filename": "celery-0.4.0.tar.gz", + "has_sig": false, + "md5_digest": "e55043f5abd461b66dd05fe605d39884", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 448254, + "upload_time": "2009-07-01T19:42:42", + "upload_time_iso_8601": "2009-07-01T19:42:42.599194Z", + "url": "https://files.pythonhosted.org/packages/c9/43/4a38e3082fa78cfbbcef6f4e50661689f97bf15da1923fdaad915888347b/celery-0.4.0.tar.gz" + } + ], + "0.4.1": [ + { + "comment_text": "", + "digests": { + "md5": "e2dbd6d28f7636e088ef77b6df54b82c", + "sha256": "38669031b8164a413f80def985a40bee57d7cc39915a7298090c50652b240d47" + }, + "downloads": -1, + "filename": "celery-0.4.1.tar.gz", + "has_sig": false, + "md5_digest": "e2dbd6d28f7636e088ef77b6df54b82c", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 448418, + "upload_time": "2009-07-02T14:09:41", + "upload_time_iso_8601": "2009-07-02T14:09:41.127082Z", + "url": "https://files.pythonhosted.org/packages/7c/30/d0b0912934c447ffcee595cc80fc5eb60ef412474dc22635756e10671fcd/celery-0.4.1.tar.gz" + } + ], + "0.6.0": [ + { + "comment_text": "", + "digests": { + "md5": "0545f89033e1639bbb1be0974465577c", + "sha256": "6ac5e64af23000a7a1a4645850b064698b025561b090c0c331542bcd9270576b" + }, + "downloads": -1, + "filename": "celery-0.6.0.tar.gz", + "has_sig": false, + "md5_digest": "0545f89033e1639bbb1be0974465577c", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 460242, + "upload_time": "2009-08-07T11:32:02", + "upload_time_iso_8601": "2009-08-07T11:32:02.598345Z", + "url": "https://files.pythonhosted.org/packages/ab/f0/b716dcd55d8e70b26b26836a2c12e03a0eee2804c261daf1b8801f88a7ff/celery-0.6.0.tar.gz" + } + ], + "0.8.0": [ + { + "comment_text": "", + "digests": { + "md5": "a98604e9ce736026f4dee88000146d99", + "sha256": "6a8cb2cd10689cc9b5a33f15d3479471b5c689e31e74432c7db75f7dd4c3a3ef" + }, + "downloads": -1, + "filename": "celery-0.8.0.tar.gz", + "has_sig": false, + "md5_digest": "a98604e9ce736026f4dee88000146d99", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 489924, + "upload_time": "2009-09-22T15:07:52", + "upload_time_iso_8601": "2009-09-22T15:07:52.052163Z", + "url": "https://files.pythonhosted.org/packages/0e/7c/027ffc99fe53a21dd90f536e0e8353d997a1e1b10061cb0c8a4371846dad/celery-0.8.0.tar.gz" + } + ], + "0.8.1": [ + { + "comment_text": "", + "digests": { + "md5": "65738c5afe9c92ee38654deaee583289", + "sha256": "ed3e9ade5599cf4744c854bceeadc0c081363765aa20b130414d0478aed93374" + }, + "downloads": -1, + "filename": "celery-0.8.1.tar.gz", + "has_sig": false, + "md5_digest": "65738c5afe9c92ee38654deaee583289", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 739072, + "upload_time": "2009-11-17T15:29:43", + "upload_time_iso_8601": "2009-11-17T15:29:43.629153Z", + "url": "https://files.pythonhosted.org/packages/93/e0/e82b8a220cb6715958ab0f7f425ffa8ca26a46f4a89ace326973a59156c3/celery-0.8.1.tar.gz" + } + ], + "0.8.2": [ + { + "comment_text": "", + "digests": { + "md5": "1d434f9a3a69f8200196b00f69fa5bb0", + "sha256": "373fdafdb4c02a67bde9012ed74df7495e458919b09c895e78ec420437ab00fb" + }, + "downloads": -1, + "filename": "celery-0.8.2.tar.gz", + "has_sig": false, + "md5_digest": "1d434f9a3a69f8200196b00f69fa5bb0", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 735863, + "upload_time": "2009-11-20T15:45:22", + "upload_time_iso_8601": "2009-11-20T15:45:22.002794Z", + "url": "https://files.pythonhosted.org/packages/2f/ca/a2a748e4827e7709717bc6fca7be018a4cb61e877d5ed41050c0476d5d72/celery-0.8.2.tar.gz" + } + ], + "0.8.3": [ + { + "comment_text": "", + "digests": { + "md5": "0d7f6f9a2bbe15d6f93e037ecf67d54a", + "sha256": "c396f638c71e3fa5fe7fdd7369852ce3da3752fee2ad901700a878c8fbe88be2" + }, + "downloads": -1, + "filename": "celery-0.8.3.tar.gz", + "has_sig": false, + "md5_digest": "0d7f6f9a2bbe15d6f93e037ecf67d54a", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 733046, + "upload_time": "2009-12-22T09:45:41", + "upload_time_iso_8601": "2009-12-22T09:45:41.806687Z", + "url": "https://files.pythonhosted.org/packages/36/08/5e99b4510e35de3ccf8897e42f06578dafba77a35f7b324158d0a880fa54/celery-0.8.3.tar.gz" + } + ], + "0.8.4": [ + { + "comment_text": "", + "digests": { + "md5": "953a0cacf3b5d8de94348d3ed958122e", + "sha256": "4d28623b98677d781cc6a0212b9e199f86a257571eaa52d0aafa9f87b3d626b0" + }, + "downloads": -1, + "filename": "celery-0.8.4.tar.gz", + "has_sig": false, + "md5_digest": "953a0cacf3b5d8de94348d3ed958122e", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 733355, + "upload_time": "2010-02-05T13:57:40", + "upload_time_iso_8601": "2010-02-05T13:57:40.634120Z", + "url": "https://files.pythonhosted.org/packages/c5/5a/69213c88917f99d526fed81438ffeaafeb3aeb539de3c670b331e698dbcc/celery-0.8.4.tar.gz" + } + ], + "1.0.0": [ + { + "comment_text": "", + "digests": { + "md5": "0e711cb074eff8ef205ef1274b30e8ad", + "sha256": "41eba3baf263be8d24a15e37a27cee8af524edced04ceacb38d0e4121f47a0c6" + }, + "downloads": -1, + "filename": "celery-1.0.0.tar.gz", + "has_sig": false, + "md5_digest": "0e711cb074eff8ef205ef1274b30e8ad", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1462227, + "upload_time": "2010-02-10T16:01:07", + "upload_time_iso_8601": "2010-02-10T16:01:07.281364Z", + "url": "https://files.pythonhosted.org/packages/07/2a/4f5bc54e1cd7fba16b84f0b6b9e187956a607a9dffe8003a15852b1a465c/celery-1.0.0.tar.gz" + } + ], + "1.0.1": [ + { + "comment_text": "", + "digests": { + "md5": "164ab6192d7513f5a098b735a6b42afc", + "sha256": "0993d9f0e7a3544dcdd92f4fdc83374fa11e8d7d1c06c96ac932264b368e32e7" + }, + "downloads": -1, + "filename": "celery-1.0.1.tar.gz", + "has_sig": false, + "md5_digest": "164ab6192d7513f5a098b735a6b42afc", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1482530, + "upload_time": "2010-03-20T19:05:08", + "upload_time_iso_8601": "2010-03-20T19:05:08.467055Z", + "url": "https://files.pythonhosted.org/packages/c7/f5/205c192eb466811ad06b2ae314265324d3e37b77403e28152a62f8e54f5d/celery-1.0.1.tar.gz" + } + ], + "1.0.2": [ + { + "comment_text": "", + "digests": { + "md5": "927b8999d928784b062c13994f88e130", + "sha256": "b8699481b3dbe75e1fbe89ff3e0eacb74de135dfe830dd2747b99fa0ebd4e0b8" + }, + "downloads": -1, + "filename": "celery-1.0.2.tar.gz", + "has_sig": false, + "md5_digest": "927b8999d928784b062c13994f88e130", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1485539, + "upload_time": "2010-03-31T13:29:12", + "upload_time_iso_8601": "2010-03-31T13:29:12.671889Z", + "url": "https://files.pythonhosted.org/packages/15/b3/d2975f3ce803a40997a73dd73a07c9a0a0012c02581a8f562f1b950cb1ca/celery-1.0.2.tar.gz" + } + ], + "1.0.3": [ + { + "comment_text": "", + "digests": { + "md5": "b01092e6112137f7d2b403f5cd16133e", + "sha256": "3b586331ce7a9ea51a018988072ef59e293550a5733e818f0d522ec0df54a8e0" + }, + "downloads": -1, + "filename": "celery-1.0.3.tar.gz", + "has_sig": false, + "md5_digest": "b01092e6112137f7d2b403f5cd16133e", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1496971, + "upload_time": "2010-05-15T15:28:22", + "upload_time_iso_8601": "2010-05-15T15:28:22.255769Z", + "url": "https://files.pythonhosted.org/packages/af/8f/4b4527b523bf18eb7ac6d8a490ff51df60c0e52baf8e37796e3da73e0609/celery-1.0.3.tar.gz" + } + ], + "1.0.4": [ + { + "comment_text": "", + "digests": { + "md5": "7ba41bbf305e7677a26162704ebb9327", + "sha256": "98e72b7014f40fdea79a70db800b502658f79b8e77b2ebb9ab1cbf94c1d9c8de" + }, + "downloads": -1, + "filename": "celery-1.0.4.tar.gz", + "has_sig": false, + "md5_digest": "7ba41bbf305e7677a26162704ebb9327", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1502398, + "upload_time": "2010-05-31T11:01:25", + "upload_time_iso_8601": "2010-05-31T11:01:25.629724Z", + "url": "https://files.pythonhosted.org/packages/11/67/482f346d8ac04154a4575d8daf1e1f25d10d62a33f61902e272cc5809d8b/celery-1.0.4.tar.gz" + } + ], + "1.0.5": [ + { + "comment_text": "", + "digests": { + "md5": "c93f7522c2ce98a32e1cc1a970a7dba1", + "sha256": "70494f0b31c3e54663a6164371ec04c0b08c50bee8f97d173a574ad492d408eb" + }, + "downloads": -1, + "filename": "celery-1.0.5.tar.gz", + "has_sig": false, + "md5_digest": "c93f7522c2ce98a32e1cc1a970a7dba1", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1507642, + "upload_time": "2010-06-01T15:00:23", + "upload_time_iso_8601": "2010-06-01T15:00:23.378370Z", + "url": "https://files.pythonhosted.org/packages/a2/10/f51deedda46be3051d5db96905a2835264ff8022b2f20b8fae67a326d163/celery-1.0.5.tar.gz" + } + ], + "1.0.6": [ + { + "comment_text": "", + "digests": { + "md5": "88ae6a25b0f63b79a9a654b8694a93c6", + "sha256": "eda05043686b3c554c66112ceabca79e0f162467afefaf951671510491c59071" + }, + "downloads": -1, + "filename": "celery-1.0.6.tar.gz", + "has_sig": false, + "md5_digest": "88ae6a25b0f63b79a9a654b8694a93c6", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1502650, + "upload_time": "2010-06-30T10:03:18", + "upload_time_iso_8601": "2010-06-30T10:03:18.768517Z", + "url": "https://files.pythonhosted.org/packages/97/d8/5b798239afd16b5712ea360698ca6bbffd28214947d36eb125b49e341e17/celery-1.0.6.tar.gz" + } + ], + "2.0.0": [ + { + "comment_text": "", + "digests": { + "md5": "b9b14d1092a10f6436435b27cd7a15f9", + "sha256": "9e7340aaec3926d90f78e4bc96175b6deb6b50367c5de978955ca6cabf85e2dd" + }, + "downloads": -1, + "filename": "celery-2.0.0.tar.gz", + "has_sig": false, + "md5_digest": "b9b14d1092a10f6436435b27cd7a15f9", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1561868, + "upload_time": "2010-07-02T14:50:39", + "upload_time_iso_8601": "2010-07-02T14:50:39.629604Z", + "url": "https://files.pythonhosted.org/packages/9c/c9/f69b9915c62f4105383834180e1c4a7ff36da1cf90608a939ee578173879/celery-2.0.0.tar.gz" + } + ], + "2.0.1": [ + { + "comment_text": "", + "digests": { + "md5": "b5b523890ea22281ee2dff6a0767abb8", + "sha256": "336bba335cf7c79a7c5d4e692f7d84fa80f5b0cbb56ceda61ee70408c071b046" + }, + "downloads": -1, + "filename": "celery-2.0.1.tar.gz", + "has_sig": false, + "md5_digest": "b5b523890ea22281ee2dff6a0767abb8", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1071118, + "upload_time": "2010-07-09T15:41:41", + "upload_time_iso_8601": "2010-07-09T15:41:41.150547Z", + "url": "https://files.pythonhosted.org/packages/72/53/247ab78e12f2b8c2fc7a4740779167dff9791c86230ca657a5fa7bbffd0a/celery-2.0.1.tar.gz" + } + ], + "2.0.2": [ + { + "comment_text": "", + "digests": { + "md5": "b0e3aa6a4df49bacd45305bc9ab8f9ae", + "sha256": "e4171d41a4c63ae639c0c7b1c00a6e361f97ce04d5d0ede3165723b62e440e28" + }, + "downloads": -1, + "filename": "celery-2.0.2.tar.gz", + "has_sig": false, + "md5_digest": "b0e3aa6a4df49bacd45305bc9ab8f9ae", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1078142, + "upload_time": "2010-07-23T23:23:23", + "upload_time_iso_8601": "2010-07-23T23:23:23.525795Z", + "url": "https://files.pythonhosted.org/packages/3e/da/591df660751e72c8456d149f1593acb1ed40eb01c9d9f2799d2a5f8e34f3/celery-2.0.2.tar.gz" + } + ], + "2.0.3": [ + { + "comment_text": "", + "digests": { + "md5": "824e934e56e5e4ac2d5b8bbe6eba8c50", + "sha256": "078ba7affd258df1eead635b1ed378da25af0aaa002d63ba9ba8f2e290cc7e30" + }, + "downloads": -1, + "filename": "celery-2.0.3.tar.gz", + "has_sig": false, + "md5_digest": "824e934e56e5e4ac2d5b8bbe6eba8c50", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1082823, + "upload_time": "2010-08-27T12:53:02", + "upload_time_iso_8601": "2010-08-27T12:53:02.745489Z", + "url": "https://files.pythonhosted.org/packages/ae/4e/b3797d6b1ec7f60ac460492fe118115ff636970e0bb6d6ab53f3aa1384f8/celery-2.0.3.tar.gz" + } + ], + "2.1.0": [ + { + "comment_text": "", + "digests": { + "md5": "dd7e2b38357a1c9641233d4627884109", + "sha256": "78d306d094e094e29ea3dbd766a8f6d0586686d8b70e8e1bcf099612ee4285dc" + }, + "downloads": -1, + "filename": "celery-2.1.0.tar.gz", + "has_sig": false, + "md5_digest": "dd7e2b38357a1c9641233d4627884109", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1424761, + "upload_time": "2010-10-08T11:49:28", + "upload_time_iso_8601": "2010-10-08T11:49:28.632644Z", + "url": "https://files.pythonhosted.org/packages/93/b1/bf36d36ff626c686699f5a9162faec0914620f740d79604a7a1033c85d9d/celery-2.1.0.tar.gz" + } + ], + "2.1.1": [ + { + "comment_text": "", + "digests": { + "md5": "5ecf0d03a5b4050ba6d207d28515ef7d", + "sha256": "3f161e65f7126aae20898d4b0b2c41f51d602d39a28612e0bc4e1ab2912f34ab" + }, + "downloads": -1, + "filename": "celery-2.1.1.tar.gz", + "has_sig": false, + "md5_digest": "5ecf0d03a5b4050ba6d207d28515ef7d", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1427895, + "upload_time": "2010-10-14T14:22:54", + "upload_time_iso_8601": "2010-10-14T14:22:54.007507Z", + "url": "https://files.pythonhosted.org/packages/35/a8/19c376a01d086491c166d1644a357b8cd18c13db3a7ae3d08953d338ad86/celery-2.1.1.tar.gz" + } + ], + "2.1.2": [ + { + "comment_text": "", + "digests": { + "md5": "54037484df43ca1104e3685da8fd2fa6", + "sha256": "f209ca3d19d953477bffb25e2e5a9911e20a38127bfc21beb68f26655b121ba0" + }, + "downloads": -1, + "filename": "celery-2.1.2.tar.gz", + "has_sig": false, + "md5_digest": "54037484df43ca1104e3685da8fd2fa6", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1429767, + "upload_time": "2010-10-29T15:28:02", + "upload_time_iso_8601": "2010-10-29T15:28:02.562252Z", + "url": "https://files.pythonhosted.org/packages/be/34/606caa843ae459d3f3f05c8b03a9cc699038b427c4d67dfff1e9e5df0f14/celery-2.1.2.tar.gz" + } + ], + "2.1.3": [ + { + "comment_text": "", + "digests": { + "md5": "029476100b9ba4763abc06da4fea2358", + "sha256": "80f6104ef7dbe46d5aadf044a755d7112eb31f083d73c90e1352e10faf5a1ccb" + }, + "downloads": -1, + "filename": "celery-2.1.3.tar.gz", + "has_sig": false, + "md5_digest": "029476100b9ba4763abc06da4fea2358", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1430582, + "upload_time": "2010-11-09T16:02:03", + "upload_time_iso_8601": "2010-11-09T16:02:03.661686Z", + "url": "https://files.pythonhosted.org/packages/50/57/c9432fb792e72598ae7102e8b25ea2d522d680b120c8456b27b58245348f/celery-2.1.3.tar.gz" + } + ], + "2.1.4": [ + { + "comment_text": "", + "digests": { + "md5": "1930be498c3278180d11e772435076ec", + "sha256": "156154cc009c06e2e787ddc7184b036168473a859067ad9a4b33de4ffa89278e" + }, + "downloads": -1, + "filename": "celery-2.1.4.tar.gz", + "has_sig": false, + "md5_digest": "1930be498c3278180d11e772435076ec", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1442476, + "upload_time": "2010-12-03T16:11:49", + "upload_time_iso_8601": "2010-12-03T16:11:49.603043Z", + "url": "https://files.pythonhosted.org/packages/81/9d/3dcc36bded082122f22ba18c51317a61bf6b42ca965a40b66ff86d3dcf66/celery-2.1.4.tar.gz" + } + ], + "2.2.0": [ + { + "comment_text": "", + "digests": { + "md5": "16e043ef274ccf2d658b6b0ee843f67b", + "sha256": "b4bd3bf091248eb21572ba829ea0fb96a35d8d6e50f9095937567d4f249b0453" + }, + "downloads": -1, + "filename": "celery-2.2.0.tar.bz2", + "has_sig": false, + "md5_digest": "16e043ef274ccf2d658b6b0ee843f67b", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1405656, + "upload_time": "2011-02-01T11:05:07", + "upload_time_iso_8601": "2011-02-01T11:05:07.169728Z", + "url": "https://files.pythonhosted.org/packages/26/67/4507c8b17966429d84be4e33b70c9ce197748cf72157c97e2da8fbf7581c/celery-2.2.0.tar.bz2" + }, + { + "comment_text": "", + "digests": { + "md5": "5affe85cab7fcb61c28218963c8d7eb3", + "sha256": "d3bfce8dcc753cfff4ce31397b27e13dfd10c321b4bdd4c4c386cd858bc42849" + }, + "downloads": -1, + "filename": "celery-2.2.0.tar.gz", + "has_sig": false, + "md5_digest": "5affe85cab7fcb61c28218963c8d7eb3", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1486172, + "upload_time": "2011-02-01T11:02:41", + "upload_time_iso_8601": "2011-02-01T11:02:41.954271Z", + "url": "https://files.pythonhosted.org/packages/8d/81/0985bf4888493ebabb03cf14d1ace62e825771d1cdc93f3ba7df95e0ddd6/celery-2.2.0.tar.gz" + }, + { + "comment_text": "", + "digests": { + "md5": "8ecb541e1d34143495f8899677cc8c7d", + "sha256": "d643b7748ae1423964be9ddac2e0a184205499c594529f94a78686659d3aba48" + }, + "downloads": -1, + "filename": "celery-2.2.0.zip", + "has_sig": false, + "md5_digest": "8ecb541e1d34143495f8899677cc8c7d", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1693636, + "upload_time": "2011-02-01T11:05:10", + "upload_time_iso_8601": "2011-02-01T11:05:10.813490Z", + "url": "https://files.pythonhosted.org/packages/1d/4d/afa05d9d26b167a367b13e553d3c4c0ee3a84d1cd82e34f210fd39ed3705/celery-2.2.0.zip" + } + ], + "2.2.1": [ + { + "comment_text": "", + "digests": { + "md5": "6055ffcd9ee9123257ad4d9bc0146c0a", + "sha256": "75e814bbad082fb9b0370e55d8bee7ecb8032d8104967d83e49157efd99ada3b" + }, + "downloads": -1, + "filename": "celery-2.2.1.tar.bz2", + "has_sig": false, + "md5_digest": "6055ffcd9ee9123257ad4d9bc0146c0a", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1430407, + "upload_time": "2011-02-02T16:15:25", + "upload_time_iso_8601": "2011-02-02T16:15:25.474043Z", + "url": "https://files.pythonhosted.org/packages/50/7c/021e3e877f2c7bed8c1a5c8b76f3bdf6f29f74bb37f6a6d5bdd32c162880/celery-2.2.1.tar.bz2" + }, + { + "comment_text": "", + "digests": { + "md5": "67a6a49ff4598b612decc0672b7758d5", + "sha256": "1c5e9dfff1b12d492b30d09220fa7e38eb13a74368cf53c440574d3f36ade912" + }, + "downloads": -1, + "filename": "celery-2.2.1.tar.gz", + "has_sig": false, + "md5_digest": "67a6a49ff4598b612decc0672b7758d5", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1486647, + "upload_time": "2011-02-02T16:15:22", + "upload_time_iso_8601": "2011-02-02T16:15:22.510710Z", + "url": "https://files.pythonhosted.org/packages/f2/20/5393530f65effecbca5e344d97f3fd200c2ea87de1d5b9e15f4edced2a70/celery-2.2.1.tar.gz" + }, + { + "comment_text": "", + "digests": { + "md5": "44c9e908cba22593a83414d8e1514977", + "sha256": "f6395749ae24c96d9e1caddb0e95257d3cc16b24d6e6ec3f038dc2f83f84bc63" + }, + "downloads": -1, + "filename": "celery-2.2.1.zip", + "has_sig": false, + "md5_digest": "44c9e908cba22593a83414d8e1514977", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1694096, + "upload_time": "2011-02-02T16:15:19", + "upload_time_iso_8601": "2011-02-02T16:15:19.243781Z", + "url": "https://files.pythonhosted.org/packages/e2/d6/8eba060c3c29c6225c3bb944de78d80c930c97a302d4851879919d132e1f/celery-2.2.1.zip" + } + ], + "2.2.10": [ + { + "comment_text": "", + "digests": { + "md5": "898bc87e54f278055b561316ba73e222", + "sha256": "dc6379c9bd0d799ed44e6a905d54b29fc0c7a514152e366bb3ef939e03291ab6" + }, + "downloads": -1, + "filename": "celery-2.2.10.tar.gz", + "has_sig": false, + "md5_digest": "898bc87e54f278055b561316ba73e222", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1502041, + "upload_time": "2012-02-07T17:41:26", + "upload_time_iso_8601": "2012-02-07T17:41:26.485599Z", + "url": "https://files.pythonhosted.org/packages/b1/64/860fd50e45844c83442e7953effcddeff66b2851d90b2d784f7201c111b8/celery-2.2.10.tar.gz" + } + ], + "2.2.2": [ + { + "comment_text": "", + "digests": { + "md5": "428716ef52f1e1f1fee4656c2705e708", + "sha256": "2e1188384b6974a4b83308cb7699c0e0b2a06fb36bc8ee00d1616473fcee3815" + }, + "downloads": -1, + "filename": "celery-2.2.2.tar.bz2", + "has_sig": false, + "md5_digest": "428716ef52f1e1f1fee4656c2705e708", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1430918, + "upload_time": "2011-02-03T23:25:18", + "upload_time_iso_8601": "2011-02-03T23:25:18.939510Z", + "url": "https://files.pythonhosted.org/packages/b0/ea/cd451a99eacda0404deea3ddeda1c3ddb05d92208cf973661f1873d95821/celery-2.2.2.tar.bz2" + }, + { + "comment_text": "", + "digests": { + "md5": "a3960153b8a7126a121bf2977e328fea", + "sha256": "6a8e9d1a884b51c43a87b3dfda9761f1b7e581af03e62858b259ead69660fdeb" + }, + "downloads": -1, + "filename": "celery-2.2.2.tar.gz", + "has_sig": false, + "md5_digest": "a3960153b8a7126a121bf2977e328fea", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1487313, + "upload_time": "2011-02-03T23:25:15", + "upload_time_iso_8601": "2011-02-03T23:25:15.645846Z", + "url": "https://files.pythonhosted.org/packages/93/dd/56b2743eb789bbd360f93af019d6bb4bb5f95f00ebbd49615218c1e3d758/celery-2.2.2.tar.gz" + }, + { + "comment_text": "", + "digests": { + "md5": "6c95343deb235a196973ef78408344fb", + "sha256": "8494c657625521de2cb21960e3154f8f7063321ae9e801fa531c89900b5d0a8d" + }, + "downloads": -1, + "filename": "celery-2.2.2.zip", + "has_sig": false, + "md5_digest": "6c95343deb235a196973ef78408344fb", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1695007, + "upload_time": "2011-02-03T23:25:22", + "upload_time_iso_8601": "2011-02-03T23:25:22.645233Z", + "url": "https://files.pythonhosted.org/packages/94/a1/668e99f614b1e442063086f2b0ac822e65471d0bc20f5c6b239003ffc819/celery-2.2.2.zip" + } + ], + "2.2.3": [ + { + "comment_text": "", + "digests": { + "md5": "3074e37245e2985c3bbc3aa6960fb750", + "sha256": "e26df3222d5ad05a8f2a2600fa1ce3c0d37bcbc4f46a29bde2568f312e0e68c1" + }, + "downloads": -1, + "filename": "celery-2.2.3.tar.bz2", + "has_sig": false, + "md5_digest": "3074e37245e2985c3bbc3aa6960fb750", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1430852, + "upload_time": "2011-02-12T16:20:37", + "upload_time_iso_8601": "2011-02-12T16:20:37.538381Z", + "url": "https://files.pythonhosted.org/packages/2e/b8/58e2864a35ab0203e599f3725a63d39e3a564d56f816d4f4c82cbcee6833/celery-2.2.3.tar.bz2" + }, + { + "comment_text": "", + "digests": { + "md5": "3878277c08157fd84d8632b99f9e7c03", + "sha256": "8633709fb08bded0b806d1c5ea3f7bb496e20df8f28673d3939985f31b49e0e0" + }, + "downloads": -1, + "filename": "celery-2.2.3.tar.gz", + "has_sig": false, + "md5_digest": "3878277c08157fd84d8632b99f9e7c03", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1488878, + "upload_time": "2011-02-12T16:20:34", + "upload_time_iso_8601": "2011-02-12T16:20:34.567837Z", + "url": "https://files.pythonhosted.org/packages/44/82/f1f91578918064eb402d0f52f6cc8b5086cb0a1e5bff886f800ea0b4abbd/celery-2.2.3.tar.gz" + }, + { + "comment_text": "", + "digests": { + "md5": "e5a990a84eceaeaf8add61a41b138eea", + "sha256": "10a3f89972e308d054e4ff5c714d1823a2508e603c119ec8893dbbe76fdc01e7" + }, + "downloads": -1, + "filename": "celery-2.2.3.zip", + "has_sig": false, + "md5_digest": "e5a990a84eceaeaf8add61a41b138eea", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1695686, + "upload_time": "2011-02-12T16:20:40", + "upload_time_iso_8601": "2011-02-12T16:20:40.952658Z", + "url": "https://files.pythonhosted.org/packages/af/92/2a1988d889cf60e3008a51782b52900f5377e0b71ad7820d539555673168/celery-2.2.3.zip" + } + ], + "2.2.4": [ + { + "comment_text": "", + "digests": { + "md5": "4bbdcf92735ac7366228bf578f9b1147", + "sha256": "72d4faec321e38321f0f891fe0be023de081eb9fb0cb0c4cdf4651914412f13b" + }, + "downloads": -1, + "filename": "celery-2.2.4.tar.gz", + "has_sig": false, + "md5_digest": "4bbdcf92735ac7366228bf578f9b1147", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1492204, + "upload_time": "2011-02-19T23:45:31", + "upload_time_iso_8601": "2011-02-19T23:45:31.442510Z", + "url": "https://files.pythonhosted.org/packages/df/04/886803c5d26f9d50d1440f2557314b70f08b7a521d9ab06fac48e26ad719/celery-2.2.4.tar.gz" + } + ], + "2.2.5": [ + { + "comment_text": "", + "digests": { + "md5": "d523c914a7c2761c70a4cc9058fdd6e8", + "sha256": "8f379b1b98cf9dd118896b6fe42721fa432016f3c34319fadd0772e6ef556a13" + }, + "downloads": -1, + "filename": "celery-2.2.5.tar.gz", + "has_sig": false, + "md5_digest": "d523c914a7c2761c70a4cc9058fdd6e8", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1500347, + "upload_time": "2011-03-28T18:32:27", + "upload_time_iso_8601": "2011-03-28T18:32:27.548130Z", + "url": "https://files.pythonhosted.org/packages/74/01/53909028798a5a5b3563cc621ac0c6f4a88b1a6ee970702763863c7b0daf/celery-2.2.5.tar.gz" + } + ], + "2.2.6": [ + { + "comment_text": "", + "digests": { + "md5": "0c8f5ec2535e2aaf692fd0227a5bb407", + "sha256": "244430e9c1b90fc70bb5eb45e3f20ea18201e59de5a35d27e2a74cfb0cd6d125" + }, + "downloads": -1, + "filename": "celery-2.2.6.tar.gz", + "has_sig": false, + "md5_digest": "0c8f5ec2535e2aaf692fd0227a5bb407", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1501710, + "upload_time": "2011-04-15T15:25:15", + "upload_time_iso_8601": "2011-04-15T15:25:15.798614Z", + "url": "https://files.pythonhosted.org/packages/53/86/466b51b3fb2b5e319b7ba855927f327028e05d87b8229087cdfb0dd6a6bb/celery-2.2.6.tar.gz" + } + ], + "2.2.7": [ + { + "comment_text": "", + "digests": { + "md5": "5826cf891eaa6175cc7aab67818094fe", + "sha256": "6a46d78ef81da35abab1c71627679ab7630d9666b3a774e2c4d8fb560a4b9da0" + }, + "downloads": -1, + "filename": "celery-2.2.7.tar.gz", + "has_sig": false, + "md5_digest": "5826cf891eaa6175cc7aab67818094fe", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1502018, + "upload_time": "2011-06-13T16:18:41", + "upload_time_iso_8601": "2011-06-13T16:18:41.013844Z", + "url": "https://files.pythonhosted.org/packages/9c/eb/d63bf7c1d5548c7cb18a6fb415934a90ff845d32872a659738900da188cb/celery-2.2.7.tar.gz" + } + ], + "2.2.8": [ + { + "comment_text": "", + "digests": { + "md5": "5aa94bea787b1fbb10c066c6b51dbafc", + "sha256": "cacd7be5b657513d6b2a49ef0c4418bfd057b1cc45c779bb9194671af4364e15" + }, + "downloads": -1, + "filename": "celery-2.2.8.tar.gz", + "has_sig": false, + "md5_digest": "5aa94bea787b1fbb10c066c6b51dbafc", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1502049, + "upload_time": "2011-11-25T17:54:23", + "upload_time_iso_8601": "2011-11-25T17:54:23.954411Z", + "url": "https://files.pythonhosted.org/packages/91/e9/a33c624d1d4e4ad1a13bd97ca26b44366522771af66fd9c9b584af1eb673/celery-2.2.8.tar.gz" + } + ], + "2.2.9": [ + { + "comment_text": "", + "digests": { + "md5": "21cd9d3c25fa3e855af480b96c345dc0", + "sha256": "216236e82ec0fbe7d097ef8c1182def355faf2fb07b039aa5e6ad846e1f11c14" + }, + "downloads": -1, + "filename": "celery-2.2.9.tar.gz", + "has_sig": false, + "md5_digest": "21cd9d3c25fa3e855af480b96c345dc0", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1503856, + "upload_time": "2011-12-13T12:11:38", + "upload_time_iso_8601": "2011-12-13T12:11:38.995901Z", + "url": "https://files.pythonhosted.org/packages/23/a4/e49af8e757ece2987e47f04a56feeb135d7c65cbb45b13b6d147dbc57fe5/celery-2.2.9.tar.gz" + } + ], + "2.3.0": [ + { + "comment_text": "", + "digests": { + "md5": "b2eec534b0bca07e5dd50c470ee99017", + "sha256": "313ed37f39176b2e734f6cae970ccd7b84b2aad7b186eb2a4adf9c12efbb3144" + }, + "downloads": -1, + "filename": "celery-2.3.0.tar.gz", + "has_sig": false, + "md5_digest": "b2eec534b0bca07e5dd50c470ee99017", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 865346, + "upload_time": "2011-08-05T17:19:41", + "upload_time_iso_8601": "2011-08-05T17:19:41.978442Z", + "url": "https://files.pythonhosted.org/packages/69/da/ac56e297e0a3e442dd60fad008daa222e74b57df24b5450dcd73d99d9f4e/celery-2.3.0.tar.gz" + } + ], + "2.3.1": [ + { + "comment_text": "", + "digests": { + "md5": "d41c6448f47148040e630a72faa8126e", + "sha256": "d832af6ca5ae0a94a9b5ccfa0cd853bee8b1f0b54226f4513bf3526f9e4df481" + }, + "downloads": -1, + "filename": "celery-2.3.1.tar.gz", + "has_sig": false, + "md5_digest": "d41c6448f47148040e630a72faa8126e", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 866144, + "upload_time": "2011-08-07T23:25:00", + "upload_time_iso_8601": "2011-08-07T23:25:00.096051Z", + "url": "https://files.pythonhosted.org/packages/57/af/feac53f2b6fc5e971d60c1da8217efdc5f986cc147af119e588e3c9d7347/celery-2.3.1.tar.gz" + } + ], + "2.3.2": [ + { + "comment_text": "", + "digests": { + "md5": "39c812d7bd14c54c4f24609dfe20e1bd", + "sha256": "ef75a7417138ca414ac8bc4539207bf21cdda8011e8790b15d65c1c2dbfd5e9a" + }, + "downloads": -1, + "filename": "celery-2.3.2.tar.gz", + "has_sig": false, + "md5_digest": "39c812d7bd14c54c4f24609dfe20e1bd", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 870999, + "upload_time": "2011-09-07T17:57:06", + "upload_time_iso_8601": "2011-09-07T17:57:06.784281Z", + "url": "https://files.pythonhosted.org/packages/5d/c8/188313effbbfdf1e88f312c2014bb72be62286a124f1d1bda306a67ca758/celery-2.3.2.tar.gz" + } + ], + "2.3.3": [ + { + "comment_text": "", + "digests": { + "md5": "fa6c661cf037b1b95ec81e67386bccb7", + "sha256": "f26240e98b73c84c4a2776abe1f2d3b0853dc36d19025f68f358be8e98a88e2e" + }, + "downloads": -1, + "filename": "celery-2.3.3.tar.gz", + "has_sig": false, + "md5_digest": "fa6c661cf037b1b95ec81e67386bccb7", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 871312, + "upload_time": "2011-09-16T18:08:16", + "upload_time_iso_8601": "2011-09-16T18:08:16.153329Z", + "url": "https://files.pythonhosted.org/packages/38/10/a5d84d3bdee3e37f34a9f413999222c42531d3b4d1873dd32ff2e3269e21/celery-2.3.3.tar.gz" + } + ], + "2.3.4": [ + { + "comment_text": "", + "digests": { + "md5": "f4b3693aac331d0c47b7f9c66aabdfe0", + "sha256": "59ee7c99c412b0df7e5396a5d617a0f7ac8c2060432e5983ff71b7a7dd8936dc" + }, + "downloads": -1, + "filename": "celery-2.3.4.tar.gz", + "has_sig": false, + "md5_digest": "f4b3693aac331d0c47b7f9c66aabdfe0", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 871648, + "upload_time": "2011-11-25T17:47:51", + "upload_time_iso_8601": "2011-11-25T17:47:51.982305Z", + "url": "https://files.pythonhosted.org/packages/ca/00/5ddb92f4053eca182e3506d51aa202d2306b8b98884a6bcc685c19a99588/celery-2.3.4.tar.gz" + } + ], + "2.3.5": [ + { + "comment_text": "", + "digests": { + "md5": "23893e021d172ebf330f850fe9366b99", + "sha256": "696501cda0fb0384624290028c3cd11fe2008cd47cfa8e09493c2d738fc44007" + }, + "downloads": -1, + "filename": "celery-2.3.5.tar.gz", + "has_sig": false, + "md5_digest": "23893e021d172ebf330f850fe9366b99", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 871796, + "upload_time": "2011-12-28T14:23:04", + "upload_time_iso_8601": "2011-12-28T14:23:04.895711Z", + "url": "https://files.pythonhosted.org/packages/01/0a/ea2859892c53b8829ceee0bff028645e237afcf4680d8278f5f5ff971ec4/celery-2.3.5.tar.gz" + } + ], + "2.4.0": [ + { + "comment_text": "", + "digests": { + "md5": "ebf718d2f50af2b81eba8e9c939c1c50", + "sha256": "81fd64381c1834a90b9d4661fa5bdd1313900acc467e7f9cee887d8780de8fb9" + }, + "downloads": -1, + "filename": "celery-2.4.0.tar.gz", + "has_sig": false, + "md5_digest": "ebf718d2f50af2b81eba8e9c939c1c50", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 887849, + "upload_time": "2011-11-04T16:27:40", + "upload_time_iso_8601": "2011-11-04T16:27:40.093799Z", + "url": "https://files.pythonhosted.org/packages/e1/af/4869eb4780d3013e069b3083afba2dec1d760ea17fee8095fd2f6380fdeb/celery-2.4.0.tar.gz" + } + ], + "2.4.1": [ + { + "comment_text": "", + "digests": { + "md5": "482b2ed34e9055f4138d92e6dc272475", + "sha256": "c77652ca179d14473975822dbfb1b5dab950c88c171ef6bc2257ddb9066e6790" + }, + "downloads": -1, + "filename": "celery-2.4.1.tar.gz", + "has_sig": false, + "md5_digest": "482b2ed34e9055f4138d92e6dc272475", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 887466, + "upload_time": "2011-11-07T22:47:12", + "upload_time_iso_8601": "2011-11-07T22:47:12.797071Z", + "url": "https://files.pythonhosted.org/packages/70/d1/d3ce2909255ce04994359b9961d4158d8ec3e726d121549e1dab5b8be76a/celery-2.4.1.tar.gz" + } + ], + "2.4.2": [ + { + "comment_text": "", + "digests": { + "md5": "79539ddc91d9f94c08de2a45107eebbc", + "sha256": "be56ff5a92892e352291810da31d5d413b656dc435d0268c8fe9cdf9f9b06b16" + }, + "downloads": -1, + "filename": "celery-2.4.2.tar.gz", + "has_sig": false, + "md5_digest": "79539ddc91d9f94c08de2a45107eebbc", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 888524, + "upload_time": "2011-11-14T12:32:59", + "upload_time_iso_8601": "2011-11-14T12:32:59.990052Z", + "url": "https://files.pythonhosted.org/packages/8a/72/110885bf8fbbb6d0e75998ca6604d870811bda3c7af49dde9d25f86ddba9/celery-2.4.2.tar.gz" + } + ], + "2.4.3": [ + { + "comment_text": "", + "digests": { + "md5": "4fa3ca632ce2e9fad9fcd99fa23d221e", + "sha256": "a832c1220b1bb4206dbb57515c1bbc164aeddae797977d7f99cc1b94dff40de0" + }, + "downloads": -1, + "filename": "celery-2.4.3.tar.gz", + "has_sig": false, + "md5_digest": "4fa3ca632ce2e9fad9fcd99fa23d221e", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 888539, + "upload_time": "2011-11-22T18:21:12", + "upload_time_iso_8601": "2011-11-22T18:21:12.916880Z", + "url": "https://files.pythonhosted.org/packages/ad/bc/0d6abd73655bf4844e018628b5868a124358af4e8a2896a965e58c188506/celery-2.4.3.tar.gz" + } + ], + "2.4.4": [ + { + "comment_text": "", + "digests": { + "md5": "e168bc9856b263edcb0801a04eb9ee9f", + "sha256": "7d6e5b12717aa688e10007862bd62a65f540b8c6b5e23a67f99341e1abfc0cc4" + }, + "downloads": -1, + "filename": "celery-2.4.4.tar.gz", + "has_sig": false, + "md5_digest": "e168bc9856b263edcb0801a04eb9ee9f", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 889111, + "upload_time": "2011-11-25T18:24:08", + "upload_time_iso_8601": "2011-11-25T18:24:08.827869Z", + "url": "https://files.pythonhosted.org/packages/b8/5d/9394e874de3151defad5eb77cb2827798ac777e90cb2b9dd2ea0c938e92d/celery-2.4.4.tar.gz" + } + ], + "2.4.5": [ + { + "comment_text": "", + "digests": { + "md5": "a8648b3fa9e0cdd6b6a4be71d7f496c8", + "sha256": "9203ab223f8c36b7c60fcf7ab3012a0c2a8be13517d5e3007d2866d15a06be67" + }, + "downloads": -1, + "filename": "celery-2.4.5.tar.gz", + "has_sig": true, + "md5_digest": "a8648b3fa9e0cdd6b6a4be71d7f496c8", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 892282, + "upload_time": "2011-12-02T18:39:18", + "upload_time_iso_8601": "2011-12-02T18:39:18.843132Z", + "url": "https://files.pythonhosted.org/packages/d7/a5/21ddeeb1afc5ab23b470133716bc030fa391e2002944bbf6f5ce31748ef6/celery-2.4.5.tar.gz" + } + ], + "2.4.6": [ + { + "comment_text": "", + "digests": { + "md5": "a480dd8741b0d5ed694b6a36a25a47ce", + "sha256": "59d2c8067bb10d6558e524131e38d5c7684fba0211dbd58229bc73f16334f0b4" + }, + "downloads": -1, + "filename": "celery-2.4.6.tar.gz", + "has_sig": false, + "md5_digest": "a480dd8741b0d5ed694b6a36a25a47ce", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 892396, + "upload_time": "2011-12-28T14:26:21", + "upload_time_iso_8601": "2011-12-28T14:26:21.292212Z", + "url": "https://files.pythonhosted.org/packages/d6/ab/3741995520ca6b13bc1ecb3844f6eac4402ca374a589383c714f9cd60503/celery-2.4.6.tar.gz" + } + ], + "2.4.7": [ + { + "comment_text": "", + "digests": { + "md5": "4c9072ec0ec0480b63e1e4ad4765d5ce", + "sha256": "bc30eca26a0adc23b00fc7362be36adcd6aaeed31059e393ae20745b9babbfeb" + }, + "downloads": -1, + "filename": "celery-2.4.7.tar.gz", + "has_sig": false, + "md5_digest": "4c9072ec0ec0480b63e1e4ad4765d5ce", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 892513, + "upload_time": "2012-07-11T00:42:19", + "upload_time_iso_8601": "2012-07-11T00:42:19.224120Z", + "url": "https://files.pythonhosted.org/packages/9c/7f/e4adc8a54010c7668cb99ebdd45da74bf6a87da9d92396788c9f993d5e5b/celery-2.4.7.tar.gz" + } + ], + "2.5.0": [ + { + "comment_text": "", + "digests": { + "md5": "0a207f123bed26c8e9634cd0c179abc0", + "sha256": "d4f2ea1dd01cd3b82f85b8e402b3efd29dd3d12a96b8e9f66c094fe606ea0cb8" + }, + "downloads": -1, + "filename": "celery-2.5.0.tar.gz", + "has_sig": false, + "md5_digest": "0a207f123bed26c8e9634cd0c179abc0", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 941813, + "upload_time": "2012-02-24T17:19:56", + "upload_time_iso_8601": "2012-02-24T17:19:56.972928Z", + "url": "https://files.pythonhosted.org/packages/9f/97/4f73bc4d1ec2533485addb24650a96e9c184fb47cc861ca44687df31177e/celery-2.5.0.tar.gz" + } + ], + "2.5.1": [ + { + "comment_text": "", + "digests": { + "md5": "c0912f29b69929219b353c748e0bf936", + "sha256": "aa9950aec83b38eae74382a690e8d9bfd58ec510823b61a142d563489aa753b3" + }, + "downloads": -1, + "filename": "celery-2.5.1.tar.gz", + "has_sig": false, + "md5_digest": "c0912f29b69929219b353c748e0bf936", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 942335, + "upload_time": "2012-03-01T13:51:14", + "upload_time_iso_8601": "2012-03-01T13:51:14.094533Z", + "url": "https://files.pythonhosted.org/packages/2b/2b/8328e9bc884e66f0b19c80528c64e56782a7bed4873e0aa4bdb4585fc4a4/celery-2.5.1.tar.gz" + } + ], + "2.5.2": [ + { + "comment_text": "", + "digests": { + "md5": "2c49deb7bdf470d9f77916d688e68687", + "sha256": "702af4ecd05b2cde1a6a964dedf1e7e370f90f3b1c37c07cae2382d6c983c12c" + }, + "downloads": -1, + "filename": "celery-2.5.2.tar.gz", + "has_sig": false, + "md5_digest": "2c49deb7bdf470d9f77916d688e68687", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 945885, + "upload_time": "2012-04-13T17:36:51", + "upload_time_iso_8601": "2012-04-13T17:36:51.726034Z", + "url": "https://files.pythonhosted.org/packages/5b/d3/6af7f863f79218b20995172a9a8af8e1ee28dc73ab1df0b858a29daacb7d/celery-2.5.2.tar.gz" + } + ], + "2.5.3": [ + { + "comment_text": "", + "digests": { + "md5": "a3361c800fb8455e1e50024aaa940f07", + "sha256": "30bef144a62fb978dd81bef848f30f8df30b5e9a22171dc582b8d3332acae726" + }, + "downloads": -1, + "filename": "celery-2.5.3.tar.gz", + "has_sig": false, + "md5_digest": "a3361c800fb8455e1e50024aaa940f07", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 946218, + "upload_time": "2012-04-16T19:51:37", + "upload_time_iso_8601": "2012-04-16T19:51:37.526451Z", + "url": "https://files.pythonhosted.org/packages/43/2c/d515f5b12fc1474697730094a5f9b09bfa870544f08c39b012a8f831d45d/celery-2.5.3.tar.gz" + } + ], + "2.5.5": [ + { + "comment_text": "", + "digests": { + "md5": "9fa40c1300d18e176db63f833a378647", + "sha256": "0aa6a5660a21d5b33ae6192035c1711302199329d714f8a48ddf8c88d93b9c83" + }, + "downloads": -1, + "filename": "celery-2.5.5.tar.gz", + "has_sig": false, + "md5_digest": "9fa40c1300d18e176db63f833a378647", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 945555, + "upload_time": "2012-06-07T12:18:26", + "upload_time_iso_8601": "2012-06-07T12:18:26.169237Z", + "url": "https://files.pythonhosted.org/packages/8e/69/318d91bc367134a85db5749cd50ecee5e3c87455df040ef4c51251c6bbbb/celery-2.5.5.tar.gz" + } + ], + "3.0.0": [ + { + "comment_text": "", + "digests": { + "md5": "4db351ac5943424c020386322816b0c2", + "sha256": "04c625c37aa456ccf92038be638a9f4ff152527de73c4e3f46e80268b83a0810" + }, + "downloads": -1, + "filename": "celery-3.0.0.tar.gz", + "has_sig": false, + "md5_digest": "4db351ac5943424c020386322816b0c2", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 955774, + "upload_time": "2012-07-07T13:59:33", + "upload_time_iso_8601": "2012-07-07T13:59:33.983349Z", + "url": "https://files.pythonhosted.org/packages/88/3e/d2a0d310fd4a0ab7dca0fbde1b5d531f6409536559bba0cdbb98997bc58d/celery-3.0.0.tar.gz" + } + ], + "3.0.1": [ + { + "comment_text": "", + "digests": { + "md5": "64cd59537ddda0b32ef3e54935650771", + "sha256": "1fcef1cf270455ddf76190130ad4b11b3edf1b2a2d39c9bec42beed9a9b62683" + }, + "downloads": -1, + "filename": "celery-3.0.1.tar.gz", + "has_sig": false, + "md5_digest": "64cd59537ddda0b32ef3e54935650771", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 957999, + "upload_time": "2012-07-10T19:10:26", + "upload_time_iso_8601": "2012-07-10T19:10:26.946182Z", + "url": "https://files.pythonhosted.org/packages/b4/e2/1790137c63291d180a127cd24f0e13ca200c391ad2f654fb5279b8e1faa9/celery-3.0.1.tar.gz" + } + ], + "3.0.10": [ + { + "comment_text": "", + "digests": { + "md5": "41247bf42627f5ca26bd9de597f4922a", + "sha256": "5df5e8e79956cbd3e1a8d7a982f196be0d487212a7b25765b58f45a0ef52f934" + }, + "downloads": -1, + "filename": "celery-3.0.10.tar.gz", + "has_sig": false, + "md5_digest": "41247bf42627f5ca26bd9de597f4922a", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1217114, + "upload_time": "2012-09-20T16:35:50", + "upload_time_iso_8601": "2012-09-20T16:35:50.817111Z", + "url": "https://files.pythonhosted.org/packages/bc/58/9eb5433c3c565abf50ab48c77cdb8d4fb97a3ad963c7125980036f5d655c/celery-3.0.10.tar.gz" + } + ], + "3.0.11": [ + { + "comment_text": "", + "digests": { + "md5": "1d54cbb3a784424ddc9bfdd4d7be617b", + "sha256": "cf21361896a095bc602fe531b56fe6b58961233053fac43952abdeaa569e4951" + }, + "downloads": -1, + "filename": "celery-3.0.11.tar.gz", + "has_sig": false, + "md5_digest": "1d54cbb3a784424ddc9bfdd4d7be617b", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1218453, + "upload_time": "2012-09-26T17:04:01", + "upload_time_iso_8601": "2012-09-26T17:04:01.456893Z", + "url": "https://files.pythonhosted.org/packages/99/66/d45be99ad0b8fff1327d41fbd8be8a760085de3b2abc5a0df8818adcc56c/celery-3.0.11.tar.gz" + } + ], + "3.0.12": [ + { + "comment_text": "", + "digests": { + "md5": "a428b84562f61955d752bdff5e612f80", + "sha256": "716a465327ded5048893d518eafdade5eb09eb9d941e6efdbdaaac73b0251d3d" + }, + "downloads": -1, + "filename": "celery-3.0.12.tar.gz", + "has_sig": false, + "md5_digest": "a428b84562f61955d752bdff5e612f80", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1218262, + "upload_time": "2012-11-06T14:36:47", + "upload_time_iso_8601": "2012-11-06T14:36:47.241192Z", + "url": "https://files.pythonhosted.org/packages/25/e1/c0002aa3d1a267c31aac647c3cd3c7df8b07959238f17812971f4d630b6e/celery-3.0.12.tar.gz" + } + ], + "3.0.13": [ + { + "comment_text": "", + "digests": { + "md5": "5ca2ed5f71203240c4e7894f4aa7a77d", + "sha256": "1a8d045c94bfda832db2afbc786e8c99ac0e094d6019a5d89c8adfe04f396d6a" + }, + "downloads": -1, + "filename": "celery-3.0.13.tar.gz", + "has_sig": false, + "md5_digest": "5ca2ed5f71203240c4e7894f4aa7a77d", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1223019, + "upload_time": "2013-01-07T16:00:37", + "upload_time_iso_8601": "2013-01-07T16:00:37.111172Z", + "url": "https://files.pythonhosted.org/packages/e1/d4/41233c02bef4440ae598485fc08bbaacf709b65001dc3fb3d142bbd45483/celery-3.0.13.tar.gz" + } + ], + "3.0.14": [ + { + "comment_text": "", + "digests": { + "md5": "7fb39e064233becce9b13b7f9dfaca08", + "sha256": "57006a6e477282a2e55ace498729bf13218ac2c7ad5d9d920ad86b2469458df2" + }, + "downloads": -1, + "filename": "celery-3.0.14.tar.gz", + "has_sig": false, + "md5_digest": "7fb39e064233becce9b13b7f9dfaca08", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1229097, + "upload_time": "2013-02-08T17:51:03", + "upload_time_iso_8601": "2013-02-08T17:51:03.401577Z", + "url": "https://files.pythonhosted.org/packages/ec/48/794f01cd79907a36de4d9bf512b80dd91ab33fb4f70134de5df56414aa94/celery-3.0.14.tar.gz" + } + ], + "3.0.15": [ + { + "comment_text": "", + "digests": { + "md5": "5ac83d2cdcacf230897d9bffcf0ddbd9", + "sha256": "c20637d2ad68ddc407f4fba89e3afccbe7a9c55a3b79059579ba9fcf5de5d976" + }, + "downloads": -1, + "filename": "celery-3.0.15.tar.gz", + "has_sig": false, + "md5_digest": "5ac83d2cdcacf230897d9bffcf0ddbd9", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1229180, + "upload_time": "2013-02-11T16:32:31", + "upload_time_iso_8601": "2013-02-11T16:32:31.930096Z", + "url": "https://files.pythonhosted.org/packages/47/d0/1db53a66fbbcd77e8594c7a45576a5d4325b01e3640ecfbdfedc79883ecf/celery-3.0.15.tar.gz" + } + ], + "3.0.16": [ + { + "comment_text": "", + "digests": { + "md5": "ebc0636683df28b7d2dc8b06a948eecb", + "sha256": "31dc01e2e9c52825419d760422de7a6ce6fc789960fa087e8227ff4a528a2120" + }, + "downloads": -1, + "filename": "celery-3.0.16.tar.gz", + "has_sig": false, + "md5_digest": "ebc0636683df28b7d2dc8b06a948eecb", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1233799, + "upload_time": "2013-03-08T15:40:41", + "upload_time_iso_8601": "2013-03-08T15:40:41.783771Z", + "url": "https://files.pythonhosted.org/packages/e7/49/bc7f9312d2269f8717ec7706e9b9283bbf68baaef8c5a0e8b1a0add9e31b/celery-3.0.16.tar.gz" + } + ], + "3.0.17": [ + { + "comment_text": "", + "digests": { + "md5": "50491556f2b521d249da6f30112dfcb9", + "sha256": "554d1e0c7cd8346aa372bb7f2b971441eee8e192a6a3855c89bad4d33b7bd947" + }, + "downloads": -1, + "filename": "celery-3.0.17.tar.gz", + "has_sig": false, + "md5_digest": "50491556f2b521d249da6f30112dfcb9", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1235117, + "upload_time": "2013-03-22T16:06:25", + "upload_time_iso_8601": "2013-03-22T16:06:25.651019Z", + "url": "https://files.pythonhosted.org/packages/d8/83/9e7f8df01cbcf3727ba80dcb8ef85f4dad7b10ab504447ca349bc732f0d5/celery-3.0.17.tar.gz" + } + ], + "3.0.18": [ + { + "comment_text": "", + "digests": { + "md5": "ca1a7027e229c9cc99a16d9852cebc3e", + "sha256": "00350c6041efb19136857693d2b90a85afbe9dfce4f9a473ce945405fa3dd8a9" + }, + "downloads": -1, + "filename": "celery-3.0.18.tar.gz", + "has_sig": false, + "md5_digest": "ca1a7027e229c9cc99a16d9852cebc3e", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1240084, + "upload_time": "2013-04-12T16:20:10", + "upload_time_iso_8601": "2013-04-12T16:20:10.053224Z", + "url": "https://files.pythonhosted.org/packages/03/a9/b803a9593a2ca103e273e51e53e5527a6647a39cd0d71cec7ede42d24695/celery-3.0.18.tar.gz" + } + ], + "3.0.19": [ + { + "comment_text": "", + "digests": { + "md5": "267c4fe4fdff3f7b722ca24327f49d64", + "sha256": "70ce2ff1143d964378b3e50817366256a036e78422e85cd89724d5e6ef022e55" + }, + "downloads": -1, + "filename": "celery-3.0.19.tar.gz", + "has_sig": false, + "md5_digest": "267c4fe4fdff3f7b722ca24327f49d64", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1242004, + "upload_time": "2013-04-17T15:19:30", + "upload_time_iso_8601": "2013-04-17T15:19:30.135279Z", + "url": "https://files.pythonhosted.org/packages/aa/f7/c9f193f422364f97e51278771b6922213bce1962eacdd242e3a28283a4e5/celery-3.0.19.tar.gz" + } + ], + "3.0.2": [ + { + "comment_text": "", + "digests": { + "md5": "da94277538270855921809f2dee67614", + "sha256": "1dcb412d4c94dd46b25c392c5aafd5852ff9ada69ebc81a4570b85743ac605d6" + }, + "downloads": -1, + "filename": "celery-3.0.2.tar.gz", + "has_sig": false, + "md5_digest": "da94277538270855921809f2dee67614", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 961658, + "upload_time": "2012-07-20T17:36:59", + "upload_time_iso_8601": "2012-07-20T17:36:59.166671Z", + "url": "https://files.pythonhosted.org/packages/22/f0/e3e09fbd5ffe0b08c6918fdbda004e95c28ce2914310588148e39ef3813c/celery-3.0.2.tar.gz" + } + ], + "3.0.20": [ + { + "comment_text": "", + "digests": { + "md5": "13c62d862d3cc108c4b661d7ea58f0c7", + "sha256": "a401afb35fb909710a1483f2a2657c9f72010e307985b42125c04547fb935727" + }, + "downloads": -1, + "filename": "celery-3.0.20.tar.gz", + "has_sig": false, + "md5_digest": "13c62d862d3cc108c4b661d7ea58f0c7", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1094641, + "upload_time": "2013-06-28T14:41:36", + "upload_time_iso_8601": "2013-06-28T14:41:36.185262Z", + "url": "https://files.pythonhosted.org/packages/f8/24/c89cbc65ce1909ad9888a5fb8c8ac8229a83fda46a20e587bf713b0a4c1b/celery-3.0.20.tar.gz" + } + ], + "3.0.21": [ + { + "comment_text": "", + "digests": { + "md5": "73885b62957af0b844f41d4acca9778c", + "sha256": "c1a76a94ba0d766630678df4912e211dc916f73143a189f8a6e37148ad2ffa53" + }, + "downloads": -1, + "filename": "celery-3.0.21.tar.gz", + "has_sig": false, + "md5_digest": "73885b62957af0b844f41d4acca9778c", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1094747, + "upload_time": "2013-07-05T15:18:15", + "upload_time_iso_8601": "2013-07-05T15:18:15.843842Z", + "url": "https://files.pythonhosted.org/packages/30/1b/a95d938e7b3f2c983cc5fa1ec0b50750d471b9421d7c992810a4ed78752e/celery-3.0.21.tar.gz" + } + ], + "3.0.22": [ + { + "comment_text": "", + "digests": { + "md5": "faa7881c5d051257829b5a292c922da3", + "sha256": "2ba77bc0dc0c9079e6aa1b3649174c3d002bc0896e9a155f435ef5d761406e89" + }, + "downloads": -1, + "filename": "celery-3.0.22.tar.gz", + "has_sig": false, + "md5_digest": "faa7881c5d051257829b5a292c922da3", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1095861, + "upload_time": "2013-08-16T16:01:52", + "upload_time_iso_8601": "2013-08-16T16:01:52.547191Z", + "url": "https://files.pythonhosted.org/packages/42/80/54076a5b6ff52db5106dcacf512c5714aac389d9d3d1e403cc0929bca75f/celery-3.0.22.tar.gz" + } + ], + "3.0.23": [ + { + "comment_text": "", + "digests": { + "md5": "095a80df47adf153f2826429282ae176", + "sha256": "d266c4428bd31de7fe5ba364a35717e4a592b574158363302ad4f13601835ace" + }, + "downloads": -1, + "filename": "celery-3.0.23.tar.gz", + "has_sig": false, + "md5_digest": "095a80df47adf153f2826429282ae176", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1096420, + "upload_time": "2013-09-02T12:00:29", + "upload_time_iso_8601": "2013-09-02T12:00:29.186159Z", + "url": "https://files.pythonhosted.org/packages/30/26/ce4cdbae333ff95c1bd3d433a5f000882508cb0f0e5cfb24bf6da74e7b70/celery-3.0.23.tar.gz" + } + ], + "3.0.24": [ + { + "comment_text": "", + "digests": { + "md5": "e864856a849468f277031ac2c5fd65b6", + "sha256": "68620192ec0b2212e64c307b5588c6c02f6a56e21160f3f3323653f7e44aafdf" + }, + "downloads": -1, + "filename": "celery-3.0.24.tar.gz", + "has_sig": false, + "md5_digest": "e864856a849468f277031ac2c5fd65b6", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1097427, + "upload_time": "2013-10-11T16:37:44", + "upload_time_iso_8601": "2013-10-11T16:37:44.536773Z", + "url": "https://files.pythonhosted.org/packages/7f/60/40867734f08257bd0fdf25daa08a860e4b38127cfeae7768dc33809478aa/celery-3.0.24.tar.gz" + } + ], + "3.0.25": [ + { + "comment_text": "", + "digests": { + "md5": "f869b9ddca813f33e844e77fc9708a19", + "sha256": "3e8c74cc76819082204754a699cb3372176e7c95a19c8b2e1057b463392fb734" + }, + "downloads": -1, + "filename": "celery-3.0.25.tar.gz", + "has_sig": true, + "md5_digest": "f869b9ddca813f33e844e77fc9708a19", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1099104, + "upload_time": "2014-07-10T20:58:29", + "upload_time_iso_8601": "2014-07-10T20:58:29.073468Z", + "url": "https://files.pythonhosted.org/packages/4e/9d/560053fdb8e79cb6c6afcf9ef0fd9ee5a5038c2ea0d4b88fa5e530ba72e5/celery-3.0.25.tar.gz" + } + ], + "3.0.3": [ + { + "comment_text": "", + "digests": { + "md5": "65058a8c11c50480d6468154b2718d52", + "sha256": "2bf1660eda36efd4343c82934f951609ccce2c215f0abc06c151d981b4fc57d1" + }, + "downloads": -1, + "filename": "celery-3.0.3.tar.gz", + "has_sig": false, + "md5_digest": "65058a8c11c50480d6468154b2718d52", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 961793, + "upload_time": "2012-07-20T22:21:04", + "upload_time_iso_8601": "2012-07-20T22:21:04.756199Z", + "url": "https://files.pythonhosted.org/packages/94/b4/acc895c29f371083388d8b3037ac10a9d462b8e1368e2e43fc2b61c9dc3f/celery-3.0.3.tar.gz" + } + ], + "3.0.4": [ + { + "comment_text": "", + "digests": { + "md5": "f4844c044716b1d3adbae6cb545ff24d", + "sha256": "9e0bca9bed35c05d66c3b5357b643a6f1e1ccaec5d59c89ab4ec2c3b830be274" + }, + "downloads": -1, + "filename": "celery-3.0.4.tar.gz", + "has_sig": false, + "md5_digest": "f4844c044716b1d3adbae6cb545ff24d", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1058430, + "upload_time": "2012-07-26T21:06:38", + "upload_time_iso_8601": "2012-07-26T21:06:38.011882Z", + "url": "https://files.pythonhosted.org/packages/3c/4a/ae7988ee5afc3864261fdaef132348dfefe5c3168b2505711f774b253292/celery-3.0.4.tar.gz" + } + ], + "3.0.5": [ + { + "comment_text": "", + "digests": { + "md5": "bf2ea38d572c7bd976810b6b4b6c1e3d", + "sha256": "d56704aa8db8be54dde1fd41cf3946c210ac712f358816a95e418a987030a18e" + }, + "downloads": -1, + "filename": "celery-3.0.5.tar.gz", + "has_sig": false, + "md5_digest": "bf2ea38d572c7bd976810b6b4b6c1e3d", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1058986, + "upload_time": "2012-08-01T17:33:00", + "upload_time_iso_8601": "2012-08-01T17:33:00.063440Z", + "url": "https://files.pythonhosted.org/packages/6f/26/4df4631d72323152ca04f441a792fe6b875b168dae00ce29eb28e95f7227/celery-3.0.5.tar.gz" + } + ], + "3.0.6": [ + { + "comment_text": "", + "digests": { + "md5": "71429442f8250be5a809faf140556340", + "sha256": "65cbfedff0443a9e9a098be7b0fd496c174b13d24612092f7ac3eef18df3c3b9" + }, + "downloads": -1, + "filename": "celery-3.0.6.tar.gz", + "has_sig": false, + "md5_digest": "71429442f8250be5a809faf140556340", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1208874, + "upload_time": "2012-08-17T22:20:07", + "upload_time_iso_8601": "2012-08-17T22:20:07.228420Z", + "url": "https://files.pythonhosted.org/packages/f8/b7/4db2e65f366ec254edb4e5c21f38710598eb35c1174a065ca19f927783ff/celery-3.0.6.tar.gz" + } + ], + "3.0.7": [ + { + "comment_text": "", + "digests": { + "md5": "a3b2240ad928c13bd8e075f0f5ec0d4b", + "sha256": "1a05c1f9d8de3c11f1f9e7a3f62277186f5c7f250ce168af17ca79325d73ce4a" + }, + "downloads": -1, + "filename": "celery-3.0.7.tar.gz", + "has_sig": false, + "md5_digest": "a3b2240ad928c13bd8e075f0f5ec0d4b", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1210218, + "upload_time": "2012-08-24T16:55:21", + "upload_time_iso_8601": "2012-08-24T16:55:21.594830Z", + "url": "https://files.pythonhosted.org/packages/e1/d2/01f5437437f570359ea33183073b9364f8f70d5b767fa21358b8056909f4/celery-3.0.7.tar.gz" + } + ], + "3.0.8": [ + { + "comment_text": "", + "digests": { + "md5": "248c47aa21440b9c716512ead00272f0", + "sha256": "a992e4f28391920bf0c6e1a17ca79b6a3d15b334710913c93103b66b210f1fe3" + }, + "downloads": -1, + "filename": "celery-3.0.8.tar.gz", + "has_sig": false, + "md5_digest": "248c47aa21440b9c716512ead00272f0", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1211460, + "upload_time": "2012-08-29T16:05:38", + "upload_time_iso_8601": "2012-08-29T16:05:38.607795Z", + "url": "https://files.pythonhosted.org/packages/a9/d1/e4dd4d9755bd338538ad6608be74c95c096bfff6c1efe91b134dc4424dc7/celery-3.0.8.tar.gz" + } + ], + "3.0.9": [ + { + "comment_text": "", + "digests": { + "md5": "894d5dcc281be4a6d0dce16c9cc02e57", + "sha256": "5ca0156feb7de5fec47e0aa8e275039cb78e1f32842b59635c786a877e45b1de" + }, + "downloads": -1, + "filename": "celery-3.0.9.tar.gz", + "has_sig": false, + "md5_digest": "894d5dcc281be4a6d0dce16c9cc02e57", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1213486, + "upload_time": "2012-08-31T16:58:17", + "upload_time_iso_8601": "2012-08-31T16:58:17.854866Z", + "url": "https://files.pythonhosted.org/packages/5d/18/11116de4b0d30a2e596df870fea4e0bd0b2e5c90d0e895c1d5c17edad6b1/celery-3.0.9.tar.gz" + } + ], + "3.1.0": [ + { + "comment_text": "", + "digests": { + "md5": "1283d31277361748855a43f6869b8c47", + "sha256": "b7abee4860cf1ee056a040950578c9c26278f46207df299e80f4ac74171eaf0f" + }, + "downloads": -1, + "filename": "celery-3.1.0.tar.gz", + "has_sig": true, + "md5_digest": "1283d31277361748855a43f6869b8c47", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1267586, + "upload_time": "2013-11-09T23:04:06", + "upload_time_iso_8601": "2013-11-09T23:04:06.666458Z", + "url": "https://files.pythonhosted.org/packages/4c/41/73889bb38bce56ace75772fe253eeb2b5f27317acbf946573b83d55aa602/celery-3.1.0.tar.gz" + } + ], + "3.1.1": [ + { + "comment_text": "", + "digests": { + "md5": "22396dd44cb3147a6d79c25f8960abab", + "sha256": "a9b816a7451d42b129e915d373132ae578f882acd8795d26343a84e887aabc68" + }, + "downloads": -1, + "filename": "celery-3.1.1.tar.gz", + "has_sig": true, + "md5_digest": "22396dd44cb3147a6d79c25f8960abab", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1269075, + "upload_time": "2013-11-11T19:21:46", + "upload_time_iso_8601": "2013-11-11T19:21:46.638890Z", + "url": "https://files.pythonhosted.org/packages/c9/7d/df5ceb367c8c8d8372a28aa384166f8f998f62f8c4b1028794df38cc7163/celery-3.1.1.tar.gz" + } + ], + "3.1.10": [ + { + "comment_text": "", + "digests": { + "md5": "c56a63e89de1c507ff20d676120c7b13", + "sha256": "1cfdcc12b8208df414386e0c9ae0cef7aff7ee11babf63c3319e0e991972059e" + }, + "downloads": -1, + "filename": "celery-3.1.10-py27-none-any.whl", + "has_sig": true, + "md5_digest": "c56a63e89de1c507ff20d676120c7b13", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 512857, + "upload_time": "2014-03-22T21:47:15", + "upload_time_iso_8601": "2014-03-22T21:47:15.696509Z", + "url": "https://files.pythonhosted.org/packages/69/fb/5595ddf29fd1feaf5abd062ad997b547ee3096b5ee62ec83008a1ac34973/celery-3.1.10-py27-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "b172ac3047be77cadda516214a720cb6", + "sha256": "0c292e17d439db20e10e07dd78ef51ec1d748af78cf247b69ee02bbce4923d36" + }, + "downloads": -1, + "filename": "celery-3.1.10.tar.gz", + "has_sig": true, + "md5_digest": "b172ac3047be77cadda516214a720cb6", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1287618, + "upload_time": "2014-03-22T21:45:48", + "upload_time_iso_8601": "2014-03-22T21:45:48.479439Z", + "url": "https://files.pythonhosted.org/packages/6d/00/46c60054e46e7dd3728c52a19b16dcedbec743612ca51a2e3297b3946655/celery-3.1.10.tar.gz" + } + ], + "3.1.11": [ + { + "comment_text": "", + "digests": { + "md5": "338c5d39c0c1f46e8e3b6882cae2cc4f", + "sha256": "9154ba723a7486c003639932b8ec1a69d7dee6837110647a6077cc7ac501e15e" + }, + "downloads": -1, + "filename": "celery-3.1.11-py27-none-any.whl", + "has_sig": true, + "md5_digest": "338c5d39c0c1f46e8e3b6882cae2cc4f", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 513865, + "upload_time": "2014-04-16T23:45:42", + "upload_time_iso_8601": "2014-04-16T23:45:42.996722Z", + "url": "https://files.pythonhosted.org/packages/f4/c4/63d760c4b578f3b82478af47696eb55ec03852a2ef8e17aa7c0426187adf/celery-3.1.11-py27-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f7ae17cd1e21e391d970368f1fb6427e", + "sha256": "7614e789a997a540bab589ca763f1006c6881e64479e8a03f72b225c25ff5250" + }, + "downloads": -1, + "filename": "celery-3.1.11.tar.gz", + "has_sig": true, + "md5_digest": "f7ae17cd1e21e391d970368f1fb6427e", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1289359, + "upload_time": "2014-04-16T23:44:59", + "upload_time_iso_8601": "2014-04-16T23:44:59.786853Z", + "url": "https://files.pythonhosted.org/packages/95/fa/7534da21cab73646d53211ebd620ade01317d08a2eb21a0801bbb2613695/celery-3.1.11.tar.gz" + } + ], + "3.1.12": [ + { + "comment_text": "", + "digests": { + "md5": "16cbb616c5ece32eff74debda26caf4c", + "sha256": "211e6f3e9b9429831ebacca3be03c097eb75eb82ac6a00273269c30e41b8e839" + }, + "downloads": -1, + "filename": "celery-3.1.12-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "16cbb616c5ece32eff74debda26caf4c", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 513519, + "upload_time": "2014-06-09T22:16:51", + "upload_time_iso_8601": "2014-06-09T22:16:51.550111Z", + "url": "https://files.pythonhosted.org/packages/0f/2a/4888ef72f74c22729fa06cb8f7c60ad1f00f41cdd6d0e4237f119a234d38/celery-3.1.12-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "31927b26c3225fac0250ac4fe2849824", + "sha256": "22c8fba96b7522afacdf3ee6fd3da7b10b90f76de88686d13ee939da361254b1" + }, + "downloads": -1, + "filename": "celery-3.1.12.tar.gz", + "has_sig": true, + "md5_digest": "31927b26c3225fac0250ac4fe2849824", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1291525, + "upload_time": "2014-06-09T22:16:03", + "upload_time_iso_8601": "2014-06-09T22:16:03.090357Z", + "url": "https://files.pythonhosted.org/packages/d0/bf/447ba1a5f6914722541dae537085c210ce0a0897638742facac99070732b/celery-3.1.12.tar.gz" + } + ], + "3.1.13": [ + { + "comment_text": "", + "digests": { + "md5": "facd8c237e1b4e1185ebc1de6d1f8433", + "sha256": "38fbef3e6f5a8513f28d8c9f66be08a40d6784fa56f50ffe8de9926767c7032a" + }, + "downloads": -1, + "filename": "celery-3.1.13-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "facd8c237e1b4e1185ebc1de6d1f8433", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 513621, + "upload_time": "2014-07-10T21:11:14", + "upload_time_iso_8601": "2014-07-10T21:11:14.627413Z", + "url": "https://files.pythonhosted.org/packages/e9/ac/7ae35524916523726072361375c810c79b4976581a751431bd1cee1f5c04/celery-3.1.13-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "549aa12b13f77d1363e9087d3deb4742", + "sha256": "04b921326a64f17af5ba9c94e5189a498b36d8c01bebd215d12abeee0f55940c" + }, + "downloads": -1, + "filename": "celery-3.1.13.tar.gz", + "has_sig": true, + "md5_digest": "549aa12b13f77d1363e9087d3deb4742", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1292738, + "upload_time": "2014-07-10T21:01:29", + "upload_time_iso_8601": "2014-07-10T21:01:29.239899Z", + "url": "https://files.pythonhosted.org/packages/0d/d7/197fee639c230eb8ec5d17f8388e99aa59fb1e71e8ea0496cb206849c964/celery-3.1.13.tar.gz" + } + ], + "3.1.14": [ + { + "comment_text": "", + "digests": { + "md5": "c37b580b2827b4edb8e309c69faadd6b", + "sha256": "ab12d39a39af4bce3dadf520b6d73e044202bfc55ba670677718b5a8b967ae4f" + }, + "downloads": -1, + "filename": "celery-3.1.14-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "c37b580b2827b4edb8e309c69faadd6b", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 513922, + "upload_time": "2014-09-08T14:53:41", + "upload_time_iso_8601": "2014-09-08T14:53:41.374980Z", + "url": "https://files.pythonhosted.org/packages/8c/d4/19b76fb1f22c3a2d3e3cfc9ded52fdf952bec6566aacb0c407fd32b4c316/celery-3.1.14-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "9afdefe648ff12284c0beab8d9ce7f5a", + "sha256": "c6a72c73046560f58076e83cda6fb63b778bb379ffe07e01655a38e2f54c373c" + }, + "downloads": -1, + "filename": "celery-3.1.14.tar.gz", + "has_sig": true, + "md5_digest": "9afdefe648ff12284c0beab8d9ce7f5a", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1295021, + "upload_time": "2014-09-08T14:53:29", + "upload_time_iso_8601": "2014-09-08T14:53:29.262056Z", + "url": "https://files.pythonhosted.org/packages/98/87/fbb1e7095c4a5e3cce4bf22c18ea32fa635877491418fa91cdb77cd2d447/celery-3.1.14.tar.gz" + } + ], + "3.1.15": [ + { + "comment_text": "", + "digests": { + "md5": "434a911245b021a0af867f354ef4af31", + "sha256": "7111697b3332ac22dd7047d492d70218d0a8ee0aa24246f6aec44274692033aa" + }, + "downloads": -1, + "filename": "celery-3.1.15-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "434a911245b021a0af867f354ef4af31", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 513935, + "upload_time": "2014-09-14T23:28:59", + "upload_time_iso_8601": "2014-09-14T23:28:59.140361Z", + "url": "https://files.pythonhosted.org/packages/26/1d/09af39b4da466c93eab0cc9e0c0225764b619ce69fe0951d10a9ab04ffa3/celery-3.1.15-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "670382ef244228b645a91c65bc200ab4", + "sha256": "84715d0b9c76818af45f7eeba76532afddff2030a313beecd0e9e2eae4dbe9e3" + }, + "downloads": -1, + "filename": "celery-3.1.15.tar.gz", + "has_sig": true, + "md5_digest": "670382ef244228b645a91c65bc200ab4", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1295292, + "upload_time": "2014-09-14T23:28:51", + "upload_time_iso_8601": "2014-09-14T23:28:51.166506Z", + "url": "https://files.pythonhosted.org/packages/a8/88/295ccc83ccc78c3f493a342a541e57ef48080fc489c0cb9b374a5afc34a0/celery-3.1.15.tar.gz" + } + ], + "3.1.16": [ + { + "comment_text": "", + "digests": { + "md5": "498b515252b94dc69e7808e19ed38d88", + "sha256": "e84498376fb052415040696b79fb0f185e3c732729670109b4f1e2303be6c9f5" + }, + "downloads": -1, + "filename": "celery-3.1.16-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "498b515252b94dc69e7808e19ed38d88", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 514222, + "upload_time": "2014-10-03T22:36:35", + "upload_time_iso_8601": "2014-10-03T22:36:35.250138Z", + "url": "https://files.pythonhosted.org/packages/85/7f/0cd3d70eac0e022df72c4bd42a958b64ca0034b9469f0422aced56b5f368/celery-3.1.16-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "465f0b707886349eb9ec962dc866789d", + "sha256": "83079c2974b3e1ac7517b33cde829db59fc2f560482c85ee4f2c751d3dd4f8f3" + }, + "downloads": -1, + "filename": "celery-3.1.16.tar.gz", + "has_sig": true, + "md5_digest": "465f0b707886349eb9ec962dc866789d", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1296002, + "upload_time": "2014-10-03T22:37:40", + "upload_time_iso_8601": "2014-10-03T22:37:40.682952Z", + "url": "https://files.pythonhosted.org/packages/2c/87/22c4cb487cdce239b1945507e5366d3c9074f94c61504b88e873a9474905/celery-3.1.16.tar.gz" + } + ], + "3.1.17": [ + { + "comment_text": "", + "digests": { + "md5": "e0978680f5a340ce4d022897f3e43c42", + "sha256": "1743aa8689bd2867c5ab3af00a8742635eb560963b1b93e14cd22d66fb77e135" + }, + "downloads": -1, + "filename": "celery-3.1.17-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "e0978680f5a340ce4d022897f3e43c42", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 514940, + "upload_time": "2014-11-19T15:32:07", + "upload_time_iso_8601": "2014-11-19T15:32:07.401738Z", + "url": "https://files.pythonhosted.org/packages/12/28/0b6cfb91734fe3bbf57fea6e87d9796977c54f5c5640e87183a695f61118/celery-3.1.17-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "e37f5d93b960bf68fc26c1325f30fd16", + "sha256": "cfe2b653268bd586e2d08a75e886f7be3be55ba372f72e2f5747aeb76c470362" + }, + "downloads": -1, + "filename": "celery-3.1.17.tar.gz", + "has_sig": true, + "md5_digest": "e37f5d93b960bf68fc26c1325f30fd16", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1297008, + "upload_time": "2014-11-19T15:31:59", + "upload_time_iso_8601": "2014-11-19T15:31:59.282605Z", + "url": "https://files.pythonhosted.org/packages/b5/2e/0c95c6b95d4d9fcb8b00bdc38921448570761b006aab0ed8380fd398ee28/celery-3.1.17.tar.gz" + } + ], + "3.1.18": [ + { + "comment_text": "", + "digests": { + "md5": "692453eb7257cc7b70b538fb3fc2f395", + "sha256": "dbf59618d5a9eff172d25021f36614be5af0501e4527975ca504b95863f14fed" + }, + "downloads": -1, + "filename": "celery-3.1.18-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "692453eb7257cc7b70b538fb3fc2f395", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 515913, + "upload_time": "2015-04-22T17:47:41", + "upload_time_iso_8601": "2015-04-22T17:47:41.749180Z", + "url": "https://files.pythonhosted.org/packages/94/50/2b824c2a2b53a05763a71138fa494f913b272511ead9757522a9ab3c0077/celery-3.1.18-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1c25973250f75788fb9c690d4fc68957", + "sha256": "0924f94070c6fc57d408b169848c5b38832668fffe060e48b4803fb23e0e3eaf" + }, + "downloads": -1, + "filename": "celery-3.1.18.tar.gz", + "has_sig": true, + "md5_digest": "1c25973250f75788fb9c690d4fc68957", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1298756, + "upload_time": "2015-04-22T17:47:30", + "upload_time_iso_8601": "2015-04-22T17:47:30.221215Z", + "url": "https://files.pythonhosted.org/packages/2f/b9/8a5d74bb351c5082465aaddf8772cfe6d4e954da68f3ac0f79bfd48f22df/celery-3.1.18.tar.gz" + } + ], + "3.1.19": [ + { + "comment_text": "", + "digests": { + "md5": "14b6cc4882dcc60252273e27c0a7650c", + "sha256": "434b4e62308428b0e83fbcd1cebb8853beb230237b1b23484063fcf1ff610b6e" + }, + "downloads": -1, + "filename": "celery-3.1.19-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "14b6cc4882dcc60252273e27c0a7650c", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 517433, + "upload_time": "2015-10-26T20:08:29", + "upload_time_iso_8601": "2015-10-26T20:08:29.530970Z", + "url": "https://files.pythonhosted.org/packages/55/e1/65d2b3ded641a5388055bdd8845a9a8e5b60e0bfd8280fc2bd85f931dc3a/celery-3.1.19-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "fba8c4b269814dc6dbc36abb0e66c384", + "sha256": "bd6a21290c822ecf78947a7dbc8b2270d88a5fa08a7a2bfcd908bb3d5ed66b71" + }, + "downloads": -1, + "filename": "celery-3.1.19.tar.gz", + "has_sig": true, + "md5_digest": "fba8c4b269814dc6dbc36abb0e66c384", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1302241, + "upload_time": "2015-10-26T20:08:23", + "upload_time_iso_8601": "2015-10-26T20:08:23.990225Z", + "url": "https://files.pythonhosted.org/packages/f2/76/7178b22c4fb72575b31a62e223996b359c6630adaeb4ec283523dd35c430/celery-3.1.19.tar.gz" + } + ], + "3.1.2": [ + { + "comment_text": "", + "digests": { + "md5": "3150cfee9a02edc2d0d4ad63f23dcb5b", + "sha256": "c07900e865ac54ba2baf5858acc55afb2ef5ec03d912691f1768a300ee57f5ba" + }, + "downloads": -1, + "filename": "celery-3.1.2.tar.gz", + "has_sig": true, + "md5_digest": "3150cfee9a02edc2d0d4ad63f23dcb5b", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1269319, + "upload_time": "2013-11-12T20:14:47", + "upload_time_iso_8601": "2013-11-12T20:14:47.477871Z", + "url": "https://files.pythonhosted.org/packages/b3/5d/286b4b3fa243689302126f4314fde8cddfc16699d77c7a308e1cc57528f2/celery-3.1.2.tar.gz" + } + ], + "3.1.20": [ + { + "comment_text": "", + "digests": { + "md5": "899b8fb9c042a56344e4a64c5fa8d05c", + "sha256": "3071b71ef8c43178ace8435002b11f2ff06db7690f07d960540eab7f4183ddf7" + }, + "downloads": -1, + "filename": "celery-3.1.20-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "899b8fb9c042a56344e4a64c5fa8d05c", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 518570, + "upload_time": "2016-01-23T02:48:30", + "upload_time_iso_8601": "2016-01-23T02:48:30.480767Z", + "url": "https://files.pythonhosted.org/packages/b9/ad/5233202888d305f7a5392a9c0729affe0b877168746ad4f666737750a10c/celery-3.1.20-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "025128230881de934461f1f2702ef721", + "sha256": "d02f191c3d92a851c9d2028e91baf2a0f2734cd3b659743d3624011d1ef7a6d5" + }, + "downloads": -1, + "filename": "celery-3.1.20.tar.gz", + "has_sig": true, + "md5_digest": "025128230881de934461f1f2702ef721", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1308238, + "upload_time": "2016-01-23T02:48:18", + "upload_time_iso_8601": "2016-01-23T02:48:18.530241Z", + "url": "https://files.pythonhosted.org/packages/b2/67/ddda25b215d47d2e07617d0aa5ee95ab69feb5fee3319ba11a62fe14c17e/celery-3.1.20.tar.gz" + } + ], + "3.1.21": [ + { + "comment_text": "", + "digests": { + "md5": "f20eef56635e8b0f34a1fa21a40ced04", + "sha256": "0d29beedd0805acea9c0f03d86194ec3e8ffa94e81034c083c1d3102079841f5" + }, + "downloads": -1, + "filename": "celery-3.1.21-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "f20eef56635e8b0f34a1fa21a40ced04", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 520206, + "upload_time": "2016-03-04T19:20:03", + "upload_time_iso_8601": "2016-03-04T19:20:03.449647Z", + "url": "https://files.pythonhosted.org/packages/07/07/f1269cb12a4644a428f35b8adfb764b9345dd7d5d3cec7f88222b20ab995/celery-3.1.21-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "27f313c7e4d0fb1bee0cd5f1decee180", + "sha256": "f7d0edfe85af73a16ab1c74975974e91a9f4cc48fe66bc3b46bcf3b9e103c746" + }, + "downloads": -1, + "filename": "celery-3.1.21.tar.gz", + "has_sig": true, + "md5_digest": "27f313c7e4d0fb1bee0cd5f1decee180", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1310301, + "upload_time": "2016-03-04T19:19:50", + "upload_time_iso_8601": "2016-03-04T19:19:50.034184Z", + "url": "https://files.pythonhosted.org/packages/9c/d0/5b784a5846d8b44f90a40bc46f99203b708ab11d4f8e79f590defbff0116/celery-3.1.21.tar.gz" + } + ], + "3.1.22": [ + { + "comment_text": "", + "digests": { + "md5": "11d441f8307bd67817e714f9aaf6d633", + "sha256": "4fd6fd2d096dcf2f0c19e0f15ea3520fd6a1f57a33791484edb0cf33495b9159" + }, + "downloads": -1, + "filename": "celery-3.1.22-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "11d441f8307bd67817e714f9aaf6d633", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 520385, + "upload_time": "2016-03-08T00:03:46", + "upload_time_iso_8601": "2016-03-08T00:03:46.862195Z", + "url": "https://files.pythonhosted.org/packages/5f/c7/7c904284a7d6f8caecf7b14354ed88f40ec76a451193aa626900c09ededa/celery-3.1.22-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "af6f4e529e80dbaa8f800192fba8f83f", + "sha256": "7e511421f967dee31756626e611d56aa1eb5b48383d3274f0a320b0254636a84" + }, + "downloads": -1, + "filename": "celery-3.1.22.tar.gz", + "has_sig": true, + "md5_digest": "af6f4e529e80dbaa8f800192fba8f83f", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1310504, + "upload_time": "2016-03-08T00:03:25", + "upload_time_iso_8601": "2016-03-08T00:03:25.456393Z", + "url": "https://files.pythonhosted.org/packages/0f/9e/2af998899beb9cb27f201799b5b6d2ff13c0bebb61f151abf72f07a1158e/celery-3.1.22.tar.gz" + } + ], + "3.1.23": [ + { + "comment_text": "", + "digests": { + "md5": "b2b5e20bd9042246f7b2c295d98315da", + "sha256": "eaf5dee3becbc35c7754a2d4482d53bdf72ea3f85dd258525259983262081474" + }, + "downloads": -1, + "filename": "celery-3.1.23-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "b2b5e20bd9042246f7b2c295d98315da", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 520409, + "upload_time": "2016-03-10T02:12:07", + "upload_time_iso_8601": "2016-03-10T02:12:07.628865Z", + "url": "https://files.pythonhosted.org/packages/de/df/59f5df67082ef46b86bc754b82f8cf187b835eea8a56ea8907813e75ad6d/celery-3.1.23-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c6f10f956a49424d553ab1391ab39ab2", + "sha256": "1a359c815837f9dbf193a7dbc6addafa34612c077ff70c66e3b16e14eebd2418" + }, + "downloads": -1, + "filename": "celery-3.1.23.tar.gz", + "has_sig": true, + "md5_digest": "c6f10f956a49424d553ab1391ab39ab2", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1310624, + "upload_time": "2016-03-10T02:11:51", + "upload_time_iso_8601": "2016-03-10T02:11:51.964658Z", + "url": "https://files.pythonhosted.org/packages/ea/a6/6da0bac3ea8abbc2763fd2664af2955702f97f140f2d7277069445532b7c/celery-3.1.23.tar.gz" + } + ], + "3.1.24": [ + { + "comment_text": "", + "digests": { + "md5": "6d52079a2b15077b973823f1adb01e17", + "sha256": "25396191954521184cc15018f776a2a2278b04dd4213d94f795daef4b7961b4b" + }, + "downloads": -1, + "filename": "celery-3.1.24-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "6d52079a2b15077b973823f1adb01e17", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 526285, + "upload_time": "2016-10-01T00:18:42", + "upload_time_iso_8601": "2016-10-01T00:18:42.935217Z", + "url": "https://files.pythonhosted.org/packages/c8/82/f46379046f2150d92085c0814affb4bedbd1c7f9703e569c8575fd7f1a4f/celery-3.1.24-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "50a713dd38cf9b3574cb93745a467c59", + "sha256": "99b8085ff3013c8cebb9211857fadf5f402882ccada863d67c4d74db60be027a" + }, + "downloads": -1, + "filename": "celery-3.1.24.tar.gz", + "has_sig": true, + "md5_digest": "50a713dd38cf9b3574cb93745a467c59", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1330180, + "upload_time": "2016-10-01T00:17:20", + "upload_time_iso_8601": "2016-10-01T00:17:20.814163Z", + "url": "https://files.pythonhosted.org/packages/dd/c0/f30014ce9426871010007e1994d3eaab8beb2929d4ca497456b7a97671fc/celery-3.1.24.tar.gz" + } + ], + "3.1.25": [ + { + "comment_text": "", + "digests": { + "md5": "43b51c87cb22cf6cb94e68102481e139", + "sha256": "1954a224805f3835e5b6f5998ec9fe51db3413cc49e59fc720d314c7913427cf" + }, + "downloads": -1, + "filename": "celery-3.1.25-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "43b51c87cb22cf6cb94e68102481e139", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 526186, + "upload_time": "2016-11-05T01:51:13", + "upload_time_iso_8601": "2016-11-05T01:51:13.481247Z", + "url": "https://files.pythonhosted.org/packages/13/28/b45b7d4c13695f321522566747e0a4a9c8883515f664e0487974e5f79d16/celery-3.1.25-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "81ebed2cccbc03c2d8adcba4fefac3bb", + "sha256": "6ced63033bc663e60c992564954dbb5c84c43899f7f1a04b739957350f6b55f3" + }, + "downloads": -1, + "filename": "celery-3.1.25.tar.gz", + "has_sig": true, + "md5_digest": "81ebed2cccbc03c2d8adcba4fefac3bb", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1330179, + "upload_time": "2016-11-05T01:52:13", + "upload_time_iso_8601": "2016-11-05T01:52:13.671524Z", + "url": "https://files.pythonhosted.org/packages/62/8d/5d9e8cddd987b409b9a332a5eb73c2d01ea42ab83865e8e8a011326c16dc/celery-3.1.25.tar.gz" + } + ], + "3.1.26-1": [ + { + "comment_text": "", + "digests": { + "md5": "07ec6a80726a3625ed5ef6d5a6180156", + "sha256": "66ee284c8721fb64ed220f03c011955ce7530e87350b903fd4438e996afc0a94" + }, + "downloads": -1, + "filename": "celery-3.1.26-1.tar.gz", + "has_sig": true, + "md5_digest": "07ec6a80726a3625ed5ef6d5a6180156", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 7703034, + "upload_time": "2018-03-24T09:29:54", + "upload_time_iso_8601": "2018-03-24T09:29:54.432606Z", + "url": "https://files.pythonhosted.org/packages/64/b8/1121f9a9fc30d267c877864b3d77a4f5309521c2e04b5d7ddf49b0096297/celery-3.1.26-1.tar.gz" + }, + { + "comment_text": "", + "digests": { + "md5": "8dbeb133fc145dfdbb5d590f87930f53", + "sha256": "f546c07dfa7cd0d450ef0543ce6205a681923005c45dc7baeebfffc33ff671b2" + }, + "downloads": -1, + "filename": "celery-3.1.26.post1-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "8dbeb133fc145dfdbb5d590f87930f53", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": null, + "size": 613613, + "upload_time": "2018-03-24T09:29:09", + "upload_time_iso_8601": "2018-03-24T09:29:09.639328Z", + "url": "https://files.pythonhosted.org/packages/a4/9a/3efa5da23cecc3f955c6ffbc78391b2e5a8befd766607fda6e6061daa9a5/celery-3.1.26.post1-py2.py3-none-any.whl" + } + ], + "3.1.26.post2": [ + { + "comment_text": "", + "digests": { + "md5": "6ba493b09ba39e58074b19c38438a3bd", + "sha256": "60211897aee321266ff043fe2b33eaac825dfe9f46843cf964fc97507a186334" + }, + "downloads": -1, + "filename": "celery-3.1.26.post2-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "6ba493b09ba39e58074b19c38438a3bd", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": null, + "size": 526344, + "upload_time": "2018-03-24T16:56:39", + "upload_time_iso_8601": "2018-03-24T16:56:39.954413Z", + "url": "https://files.pythonhosted.org/packages/b1/27/cd2e097208f60a0512b8b3201f8bd93c1db359c3fa35cab2f405aa1d45a7/celery-3.1.26.post2-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "a16881249d81591cdf5ce0dfb092ea80", + "sha256": "5493e172ae817b81ba7d09443ada114886765a8ce02f16a56e6fac68d953a9b2" + }, + "downloads": -1, + "filename": "celery-3.1.26.post2.tar.gz", + "has_sig": true, + "md5_digest": "a16881249d81591cdf5ce0dfb092ea80", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1337633, + "upload_time": "2018-03-24T16:56:48", + "upload_time_iso_8601": "2018-03-24T16:56:48.602419Z", + "url": "https://files.pythonhosted.org/packages/33/f3/c6f66e311dd0be1eedcf6d256e4138caca537d81c1b903d4ab3699ada889/celery-3.1.26.post2.tar.gz" + } + ], + "3.1.3": [ + { + "comment_text": "", + "digests": { + "md5": "e563897cde5ef792404bd09ff992b7aa", + "sha256": "902cf1ba70bbbc275c9d488355524627179d3d658afcf485c37ee0deea3a4ff5" + }, + "downloads": -1, + "filename": "celery-3.1.3-py26-none-any.whl", + "has_sig": true, + "md5_digest": "e563897cde5ef792404bd09ff992b7aa", + "packagetype": "bdist_wheel", + "python_version": "2.6", + "requires_python": null, + "size": 495576, + "upload_time": "2013-11-14T12:43:13", + "upload_time_iso_8601": "2013-11-14T12:43:13.539689Z", + "url": "https://files.pythonhosted.org/packages/51/d7/f06267f720bb3e24409ff0461253d71eeb186accea685053fda2a81c994f/celery-3.1.3-py26-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "161320e9eb166793afd44d54b19ca073", + "sha256": "ffce9982e27bbd37f76d862ef686be0b27c2ca936131e34a7fa9ebcd3c092d46" + }, + "downloads": -1, + "filename": "celery-3.1.3-py27-none-any.whl", + "has_sig": true, + "md5_digest": "161320e9eb166793afd44d54b19ca073", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 492621, + "upload_time": "2013-11-14T12:41:49", + "upload_time_iso_8601": "2013-11-14T12:41:49.214591Z", + "url": "https://files.pythonhosted.org/packages/3d/dc/f624ebe7075e9c868b27229c396c45e8159569e1ebf76f1da3179dc452c4/celery-3.1.3-py27-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "291f2b3037c05085e02bf703a15b809b", + "sha256": "7c2849a89a88bc73dfb67c82574cb7f17d579756c1d16e849bee6156a91d3b7e" + }, + "downloads": -1, + "filename": "celery-3.1.3-py33-none-any.whl", + "has_sig": true, + "md5_digest": "291f2b3037c05085e02bf703a15b809b", + "packagetype": "bdist_wheel", + "python_version": "3.3", + "requires_python": null, + "size": 495578, + "upload_time": "2013-11-14T12:44:12", + "upload_time_iso_8601": "2013-11-14T12:44:12.424196Z", + "url": "https://files.pythonhosted.org/packages/f9/e3/385b465e50d38f1d50a9001c3825ed99da0e548e9a4873483b23e47f8216/celery-3.1.3-py33-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "a8f95994762ed63e7f04e1ea572cdd47", + "sha256": "767380e32547d5ec2d9a915f28708d4fb65a55c6c910d0ec717e1d08470d1d1c" + }, + "downloads": -1, + "filename": "celery-3.1.3.tar.gz", + "has_sig": true, + "md5_digest": "a8f95994762ed63e7f04e1ea572cdd47", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1269548, + "upload_time": "2013-11-13T00:53:34", + "upload_time_iso_8601": "2013-11-13T00:53:34.686525Z", + "url": "https://files.pythonhosted.org/packages/e4/78/8ab04c00f49b4a8ddc788710e45dde020dad9c5f86fcb67c77725f0dbc28/celery-3.1.3.tar.gz" + } + ], + "3.1.4": [ + { + "comment_text": "", + "digests": { + "md5": "60aa694cb6542ebb43a417f4005c4dfc", + "sha256": "8e2d1e1599426db1a555cd0148567b7549dd66144dbed88244d4dcb2443b8cbc" + }, + "downloads": -1, + "filename": "celery-3.1.4.tar.gz", + "has_sig": true, + "md5_digest": "60aa694cb6542ebb43a417f4005c4dfc", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1270322, + "upload_time": "2013-11-16T00:15:54", + "upload_time_iso_8601": "2013-11-16T00:15:54.547740Z", + "url": "https://files.pythonhosted.org/packages/50/dd/8fe90a0d421388e5097e6bccaa82d69f0b1f6fa6ea4f8a7cd6cff1e642c4/celery-3.1.4.tar.gz" + } + ], + "3.1.5": [ + { + "comment_text": "", + "digests": { + "md5": "a8ff438460e562d21dd762cbba7bb6e2", + "sha256": "56797e4ab88c702e2a2a25002b2c38ba2fa183270fe3db843f2f72943e4406df" + }, + "downloads": -1, + "filename": "celery-3.1.5.tar.gz", + "has_sig": true, + "md5_digest": "a8ff438460e562d21dd762cbba7bb6e2", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1262355, + "upload_time": "2013-11-21T18:31:51", + "upload_time_iso_8601": "2013-11-21T18:31:51.867814Z", + "url": "https://files.pythonhosted.org/packages/f1/9e/15df5bc43eb89203a08073f60ce25ff8268a9236247e04a908627ac7d614/celery-3.1.5.tar.gz" + } + ], + "3.1.6": [ + { + "comment_text": "", + "digests": { + "md5": "00eebe44a44fe060c7cd184d15ae0bd9", + "sha256": "320708cc2fb1cd1ca552330bb9c326c927668de1fee3b1e53ac6245e53d79e95" + }, + "downloads": -1, + "filename": "celery-3.1.6.tar.gz", + "has_sig": true, + "md5_digest": "00eebe44a44fe060c7cd184d15ae0bd9", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1264225, + "upload_time": "2013-12-02T18:06:20", + "upload_time_iso_8601": "2013-12-02T18:06:20.012446Z", + "url": "https://files.pythonhosted.org/packages/00/ee/2a47b9e710e7e6d19a0197be214b6c044c40e055f2cbdd4c86ce0158d660/celery-3.1.6.tar.gz" + } + ], + "3.1.7": [ + { + "comment_text": "", + "digests": { + "md5": "63a452d4338372d0a22de1961130907e", + "sha256": "4a46dd4eba08831605d0373d9f90c150580ab0bd0a5e50021baef16403d06304" + }, + "downloads": -1, + "filename": "celery-3.1.7.tar.gz", + "has_sig": true, + "md5_digest": "63a452d4338372d0a22de1961130907e", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1271174, + "upload_time": "2013-12-17T18:08:01", + "upload_time_iso_8601": "2013-12-17T18:08:01.768105Z", + "url": "https://files.pythonhosted.org/packages/0c/62/6c20da627bdc4a48dbc27dc9d986ac13268999b043a5e4b3e8aacd200db2/celery-3.1.7.tar.gz" + } + ], + "3.1.8": [ + { + "comment_text": "", + "digests": { + "md5": "a5631b69adde9e7c7af22f8ee2fd57e0", + "sha256": "0786c9aa2e1656baa96f8816a2a41886a49edd3e928f93f83b2820b2a072bbb9" + }, + "downloads": -1, + "filename": "celery-3.1.8.tar.gz", + "has_sig": true, + "md5_digest": "a5631b69adde9e7c7af22f8ee2fd57e0", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1276228, + "upload_time": "2014-01-17T22:48:45", + "upload_time_iso_8601": "2014-01-17T22:48:45.094907Z", + "url": "https://files.pythonhosted.org/packages/5a/f9/7c7b3b1952151986544747e9c5de5f629c3d4bb3fd233c29dfaa0b7fbb33/celery-3.1.8.tar.gz" + } + ], + "3.1.9": [ + { + "comment_text": "", + "digests": { + "md5": "6a39de14825619b10fa1af4c989af44b", + "sha256": "804daff247c9aa63ca3aeab95d49eb5c1f17441652db911e8219e92ae2b9d354" + }, + "downloads": -1, + "filename": "celery-3.1.9-py27-none-any.whl", + "has_sig": true, + "md5_digest": "6a39de14825619b10fa1af4c989af44b", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 508152, + "upload_time": "2014-02-10T18:45:44", + "upload_time_iso_8601": "2014-02-10T18:45:44.074669Z", + "url": "https://files.pythonhosted.org/packages/7a/9c/c1f6ce0d80b8f7ee2eeb36bf9437a9b3f1c4edc4d3c37b9806ecd0c04426/celery-3.1.9-py27-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "5742a95c0bb07cc5159216aae3b025fb", + "sha256": "4a9ee7e7c4928577368187c4a1006a7e0755106fe83bac2de14971abe7ddfc2c" + }, + "downloads": -1, + "filename": "celery-3.1.9.tar.gz", + "has_sig": true, + "md5_digest": "5742a95c0bb07cc5159216aae3b025fb", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1280858, + "upload_time": "2014-02-10T18:45:41", + "upload_time_iso_8601": "2014-02-10T18:45:41.034999Z", + "url": "https://files.pythonhosted.org/packages/cd/64/8499d48b0a147ca62ab95019506424f4af620de11c04b003912ff98ca0f2/celery-3.1.9.tar.gz" + } + ], + "4.0.0": [ + { + "comment_text": "", + "digests": { + "md5": "21ba26ac8d5cd7af8fc8eb89ffca1edc", + "sha256": "ede3c75b205560000403a8e5f0c73f201779e669a1c45b42c69294bd6d4951bc" + }, + "downloads": -1, + "filename": "celery-4.0.0-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "21ba26ac8d5cd7af8fc8eb89ffca1edc", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 395281, + "upload_time": "2016-11-04T20:56:14", + "upload_time_iso_8601": "2016-11-04T20:56:14.925104Z", + "url": "https://files.pythonhosted.org/packages/4b/19/745db97793f786644df142f059beea7c784fa3e856758bb5c18891004d49/celery-4.0.0-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "a4407621012e759ebd62368309b12145", + "sha256": "3e38a9a7f2868f774dffbb49e3afd2e56f57875deb06cb3ee3808f572601a8f0" + }, + "downloads": -1, + "filename": "celery-4.0.0.tar.gz", + "has_sig": true, + "md5_digest": "a4407621012e759ebd62368309b12145", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1319440, + "upload_time": "2016-11-04T20:56:10", + "upload_time_iso_8601": "2016-11-04T20:56:10.321081Z", + "url": "https://files.pythonhosted.org/packages/47/a6/1b5f1cc0a720ef17abd4ab4ee47e769d6bd4bad38b5b7fec3248ff33b4fc/celery-4.0.0.tar.gz" + } + ], + "4.0.0rc3": [ + { + "comment_text": "", + "digests": { + "md5": "674569d86ff5a61d68f953924e7095b3", + "sha256": "5fd54f075d98bb9a226b594d1d9ef18b2f56e1981bdfa4f2bab999bd601544a9" + }, + "downloads": -1, + "filename": "celery-4.0.0rc3-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "674569d86ff5a61d68f953924e7095b3", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 553447, + "upload_time": "2016-07-08T22:31:58", + "upload_time_iso_8601": "2016-07-08T22:31:58.737265Z", + "url": "https://files.pythonhosted.org/packages/33/00/c8979f8302cf1ff31bbab31ac328073f0c23f49cf3d55cb2c5d67ed76954/celery-4.0.0rc3-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7e81b659a3beffeadace397694f1dfe8", + "sha256": "3f108e0801fd4b5f7c98ec23c046b8d0585a15b7c9b1f907ea7b2c38b97684d1" + }, + "downloads": -1, + "filename": "celery-4.0.0rc3.tar.gz", + "has_sig": true, + "md5_digest": "7e81b659a3beffeadace397694f1dfe8", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1347201, + "upload_time": "2016-07-08T22:31:52", + "upload_time_iso_8601": "2016-07-08T22:31:52.974580Z", + "url": "https://files.pythonhosted.org/packages/0c/4e/be8d89c18693ee8c5edb6a59c84ac77891b15a75a9cd0d5d70dfaa106d81/celery-4.0.0rc3.tar.gz" + } + ], + "4.0.0rc4": [ + { + "comment_text": "", + "digests": { + "md5": "f135366bcfa9bd81d5f321cea77860a9", + "sha256": "afe08e3f67984b8f4e64f263beb9aab6bb3b6eb2d71965db1e6328bd8f290bea" + }, + "downloads": -1, + "filename": "celery-4.0.0rc4-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "f135366bcfa9bd81d5f321cea77860a9", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 392195, + "upload_time": "2016-09-08T22:30:45", + "upload_time_iso_8601": "2016-09-08T22:30:45.538069Z", + "url": "https://files.pythonhosted.org/packages/c2/22/a526c291b39542c8110df5f53973169897b83e96051a0a888b4fc6e8af94/celery-4.0.0rc4-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "b88a34a9710e0ad576d6a23e40e28e7a", + "sha256": "142e6a3c7c119f1adf82abf384cb9cadccd9b84b34515e3a128c2400adc6e38c" + }, + "downloads": -1, + "filename": "celery-4.0.0rc4.tar.gz", + "has_sig": true, + "md5_digest": "b88a34a9710e0ad576d6a23e40e28e7a", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1393289, + "upload_time": "2016-09-08T22:30:40", + "upload_time_iso_8601": "2016-09-08T22:30:40.665167Z", + "url": "https://files.pythonhosted.org/packages/d2/5a/769c88e59712154a257efa187abbcd8344d627f9b18d06562569820c19e0/celery-4.0.0rc4.tar.gz" + } + ], + "4.0.0rc5": [ + { + "comment_text": "", + "digests": { + "md5": "1819d7e6b7f34911bdf8589e96d91bd4", + "sha256": "7ba32f126a1e33c00adf55814e7725335ca00ddc7da170e2f0ea350d07ea5f99" + }, + "downloads": -1, + "filename": "celery-4.0.0rc5-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "1819d7e6b7f34911bdf8589e96d91bd4", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 402434, + "upload_time": "2016-10-15T01:07:12", + "upload_time_iso_8601": "2016-10-15T01:07:12.600662Z", + "url": "https://files.pythonhosted.org/packages/3c/19/7176f49b519ebf1d43ad048c4484e927964d70997d667296bfbbf7c87cf2/celery-4.0.0rc5-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "e9dc8284b060c79323dd059e3137f283", + "sha256": "1d6b819a1454eb641e4ca2c212038e79697c5ad2cb67d613dc56c8a64130dc82" + }, + "downloads": -1, + "filename": "celery-4.0.0rc5.tar.gz", + "has_sig": true, + "md5_digest": "e9dc8284b060c79323dd059e3137f283", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1406534, + "upload_time": "2016-10-15T01:07:08", + "upload_time_iso_8601": "2016-10-15T01:07:08.568657Z", + "url": "https://files.pythonhosted.org/packages/6d/5a/5075c6a3eca3120d41916014d281f71c4109427c53ff34f5728ae9f07148/celery-4.0.0rc5.tar.gz" + } + ], + "4.0.0rc6": [ + { + "comment_text": "", + "digests": { + "md5": "6911ddb9057ed4d992d41fe97ed03ed5", + "sha256": "cded408aa194919dd169037ca64a3c3c944922d4b438f447f5073d0ff9129a88" + }, + "downloads": -1, + "filename": "celery-4.0.0rc6-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "6911ddb9057ed4d992d41fe97ed03ed5", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 413338, + "upload_time": "2016-10-22T02:42:31", + "upload_time_iso_8601": "2016-10-22T02:42:31.486695Z", + "url": "https://files.pythonhosted.org/packages/75/1d/1ca75e00cb5f9d6a86385a3575305d94e6980bc606aa94673035a708dcbc/celery-4.0.0rc6-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1658210588996c839146308a3e7c4ade", + "sha256": "50f1dd544f2b956f88f9139d707f5909d8ade3dd87e93fc372b1a00d5b180e9c" + }, + "downloads": -1, + "filename": "celery-4.0.0rc6.tar.gz", + "has_sig": true, + "md5_digest": "1658210588996c839146308a3e7c4ade", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1419750, + "upload_time": "2016-10-22T02:42:26", + "upload_time_iso_8601": "2016-10-22T02:42:26.710001Z", + "url": "https://files.pythonhosted.org/packages/e4/88/d52ef385e787906d40d13569eac379878d3fa2c9c37fa125c9328fd8b26f/celery-4.0.0rc6.tar.gz" + } + ], + "4.0.0rc7": [ + { + "comment_text": "", + "digests": { + "md5": "e00e5756704a487466753acb4172db20", + "sha256": "85794207656d4cabdf6204142438c91ce6f3a51144561a4b163e582ec096a845" + }, + "downloads": -1, + "filename": "celery-4.0.0rc7-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "e00e5756704a487466753acb4172db20", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 419550, + "upload_time": "2016-11-03T00:55:45", + "upload_time_iso_8601": "2016-11-03T00:55:45.685897Z", + "url": "https://files.pythonhosted.org/packages/1e/64/083e7d1a29a01044b5f2b8a8854bfaa1d80c8e4ed96a7774375098a74445/celery-4.0.0rc7-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "094446dc56da00114ee7892888fe4020", + "sha256": "5e5e8180a18baea747bfec842771a1249b678190eb80eb9362710e44b2f3fd66" + }, + "downloads": -1, + "filename": "celery-4.0.0rc7.tar.gz", + "has_sig": true, + "md5_digest": "094446dc56da00114ee7892888fe4020", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1431962, + "upload_time": "2016-11-03T00:55:39", + "upload_time_iso_8601": "2016-11-03T00:55:39.196050Z", + "url": "https://files.pythonhosted.org/packages/45/62/5db583643853696be9ef10a87bbec327f3f3e305929677a8b447b20f958e/celery-4.0.0rc7.tar.gz" + } + ], + "4.0.1": [ + { + "comment_text": "", + "digests": { + "md5": "9cb21647de9da1136a7aa38376ba6dd1", + "sha256": "a09f6d123794fc3a51dcd1545793333b2167889439012fa5ef82821b4af42163" + }, + "downloads": -1, + "filename": "celery-4.0.1-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "9cb21647de9da1136a7aa38376ba6dd1", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 396380, + "upload_time": "2016-12-09T01:36:00", + "upload_time_iso_8601": "2016-12-09T01:36:00.840154Z", + "url": "https://files.pythonhosted.org/packages/81/d5/5fb88ee70cf91d83659cfe88e997d2b5a665455b04b656840b4179c61900/celery-4.0.1-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "addf3afad2808cab1a4175f5dce9e221", + "sha256": "763b28532c8ee2fa8c86ff1d721bfbf858550e24366e40871e5ec4d06252cb46" + }, + "downloads": -1, + "filename": "celery-4.0.1.tar.gz", + "has_sig": true, + "md5_digest": "addf3afad2808cab1a4175f5dce9e221", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1336892, + "upload_time": "2016-12-09T01:35:56", + "upload_time_iso_8601": "2016-12-09T01:35:56.918591Z", + "url": "https://files.pythonhosted.org/packages/dd/fe/a44bd232539369977898b791f5f6f37be87f56872f9feb24b5c4e10a5213/celery-4.0.1.tar.gz" + } + ], + "4.0.2": [ + { + "comment_text": "", + "digests": { + "md5": "3ff97b53107b491baeb42f662be14a06", + "sha256": "0e5b7e0d7f03aa02061abfd27aa9da05b6740281ca1f5228a54fbf7fe74d8afa" + }, + "downloads": -1, + "filename": "celery-4.0.2-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "3ff97b53107b491baeb42f662be14a06", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 396437, + "upload_time": "2016-12-16T00:14:59", + "upload_time_iso_8601": "2016-12-16T00:14:59.677799Z", + "url": "https://files.pythonhosted.org/packages/11/46/3524d4730d3217960b5e32cb8b202420af8714e2b123b9f95882e1fb2067/celery-4.0.2-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "364dbf014ad57a6aa60d823670642e5d", + "sha256": "e3d5a6c56a73ff8f2ddd4d06dc37f4c2afe4bb4da7928b884d0725ea865ef54d" + }, + "downloads": -1, + "filename": "celery-4.0.2.tar.gz", + "has_sig": true, + "md5_digest": "364dbf014ad57a6aa60d823670642e5d", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1337804, + "upload_time": "2016-12-16T00:14:42", + "upload_time_iso_8601": "2016-12-16T00:14:42.864636Z", + "url": "https://files.pythonhosted.org/packages/b2/b7/888565f3e955473247aef86174db5121d16de6661b69bd8f3d10aff574f6/celery-4.0.2.tar.gz" + } + ], + "4.1.0": [ + { + "comment_text": "", + "digests": { + "md5": "647073f137121298d1916b09b9560b4c", + "sha256": "81a67f0d53a688ec2bc8557bd5d6d7218f925a6f2e6df80e01560de9e28997ec" + }, + "downloads": -1, + "filename": "celery-4.1.0-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "647073f137121298d1916b09b9560b4c", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": null, + "size": 400373, + "upload_time": "2017-07-24T17:23:13", + "upload_time_iso_8601": "2017-07-24T17:23:13.472944Z", + "url": "https://files.pythonhosted.org/packages/22/9b/88ef5cc7edf5d43215f383ae0a2b1cdeb33f5f07886386c7e4691b2eba0c/celery-4.1.0-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "db91e1d26936381127f01e150fe3054a", + "sha256": "77ff3730198d6a17b3c1f05579ebe570b579efb35f6d7e13dba3b1368d068b35" + }, + "downloads": -1, + "filename": "celery-4.1.0.tar.gz", + "has_sig": true, + "md5_digest": "db91e1d26936381127f01e150fe3054a", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1331689, + "upload_time": "2017-07-24T17:23:19", + "upload_time_iso_8601": "2017-07-24T17:23:19.732941Z", + "url": "https://files.pythonhosted.org/packages/07/65/88a2a45fc80f487872c93121a701a53bbbc3d3d832016876fac84fc8d46a/celery-4.1.0.tar.gz" + } + ], + "4.1.1": [ + { + "comment_text": "", + "digests": { + "md5": "544f0c7bcb465b3f94ddd649332730f9", + "sha256": "6fc4678d1692af97e137b2a9f1c04efd8e7e2fb7134c5c5ad60738cdd927762f" + }, + "downloads": -1, + "filename": "celery-4.1.1-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "544f0c7bcb465b3f94ddd649332730f9", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": null, + "size": 394706, + "upload_time": "2018-05-21T09:47:24", + "upload_time_iso_8601": "2018-05-21T09:47:24.506769Z", + "url": "https://files.pythonhosted.org/packages/99/fa/4049b26bfe71992ecf979acd39b87e55b493608613054089d975418015b7/celery-4.1.1-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "9f807beea25be96647d75bbcad9d4d5d", + "sha256": "d1f2a3359bdbdfb344edce98b8e891f5fe64f8a11c5a45538ec20ac237c971f5" + }, + "downloads": -1, + "filename": "celery-4.1.1.tar.gz", + "has_sig": true, + "md5_digest": "9f807beea25be96647d75bbcad9d4d5d", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 1332173, + "upload_time": "2018-05-21T09:47:30", + "upload_time_iso_8601": "2018-05-21T09:47:30.333491Z", + "url": "https://files.pythonhosted.org/packages/e9/cf/a4c0597effca20c57eb586324e41d1180bc8f13a933da41e0646cff69f02/celery-4.1.1.tar.gz" + } + ], + "4.2.0": [ + { + "comment_text": "", + "digests": { + "md5": "f44208cefca2c357e1539fd900523a2d", + "sha256": "2082cbd82effa8ac8a8a58977d70bb203a9f362817e3b66f4578117b9f93d8a9" + }, + "downloads": -1, + "filename": "celery-4.2.0-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "f44208cefca2c357e1539fd900523a2d", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 401245, + "upload_time": "2018-06-10T18:28:09", + "upload_time_iso_8601": "2018-06-10T18:28:09.571847Z", + "url": "https://files.pythonhosted.org/packages/ea/75/d7d1eaeb6c90c7442f7b96242a6d4ebcf1cf075f9c51957d061fb8264d24/celery-4.2.0-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "d38a462edbe08d68f9965e6948666a9e", + "sha256": "ff727c115533edbc7b81b2b4ba1ec88d1c2fc4836e1e2f4c3c33a76ff53e5d7f" + }, + "downloads": -1, + "filename": "celery-4.2.0.tar.gz", + "has_sig": true, + "md5_digest": "d38a462edbe08d68f9965e6948666a9e", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 1351778, + "upload_time": "2018-06-10T18:29:18", + "upload_time_iso_8601": "2018-06-10T18:29:18.646209Z", + "url": "https://files.pythonhosted.org/packages/78/e1/93388de1535bfd7eb65bddda361dcb482a84d373d7c81f8d8d2172caf664/celery-4.2.0.tar.gz" + } + ], + "4.2.0rc1": [ + { + "comment_text": "", + "digests": { + "md5": "f57dc80bf33a1150f6672cf9a73ecede", + "sha256": "1d721d00374b037ce2db791be43283638d4dd93ab9c306093475542a3f30bd28" + }, + "downloads": -1, + "filename": "celery-4.2.0rc1-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "f57dc80bf33a1150f6672cf9a73ecede", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 639349, + "upload_time": "2018-03-23T15:40:34", + "upload_time_iso_8601": "2018-03-23T15:40:34.703528Z", + "url": "https://files.pythonhosted.org/packages/7e/c3/4e032b12e2015b4dfa7c510cd2d3217e9b24d6f9c8842e14d7d747de8e63/celery-4.2.0rc1-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "fdceb00b60b8df5a43572e849f4e0a85", + "sha256": "ce8cf9010fa399eca159f46a5b6163574c414c30e2ebc8a0a2f805f81b879bcd" + }, + "downloads": -1, + "filename": "celery-4.2.0rc1.tar.gz", + "has_sig": true, + "md5_digest": "fdceb00b60b8df5a43572e849f4e0a85", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 1345375, + "upload_time": "2018-03-23T15:40:40", + "upload_time_iso_8601": "2018-03-23T15:40:40.576249Z", + "url": "https://files.pythonhosted.org/packages/53/1f/930018759182291c23b8c08e799d5e75466d532b68386a85c09ba6e12e6b/celery-4.2.0rc1.tar.gz" + } + ], + "4.2.0rc2": [ + { + "comment_text": "", + "digests": { + "md5": "d48583af98eecf9e760b52313512f453", + "sha256": "4f5f6e18f0055efc0c3deccb01fa67e458acb1e4e0be495cfa2e7e4ea5f62751" + }, + "downloads": -1, + "filename": "celery-4.2.0rc2-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "d48583af98eecf9e760b52313512f453", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 406512, + "upload_time": "2018-04-02T08:29:27", + "upload_time_iso_8601": "2018-04-02T08:29:27.174294Z", + "url": "https://files.pythonhosted.org/packages/46/ec/1b77aef19695154dba004aceb4d50b32f36f6cc2832557514fe1f8d08aee/celery-4.2.0rc2-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "d735da3d70808ca554ef5b8cf1f27e80", + "sha256": "c82f7531056b7193b8218c32a6cbdf9057782b45cd305ad98388b4b0aa2598d0" + }, + "downloads": -1, + "filename": "celery-4.2.0rc2.tar.gz", + "has_sig": true, + "md5_digest": "d735da3d70808ca554ef5b8cf1f27e80", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 1345823, + "upload_time": "2018-04-02T08:29:32", + "upload_time_iso_8601": "2018-04-02T08:29:32.984984Z", + "url": "https://files.pythonhosted.org/packages/83/86/fc97823f2d132c6428e70ab042dc54b88f147e017d5eed70e207979bb477/celery-4.2.0rc2.tar.gz" + } + ], + "4.2.0rc3": [ + { + "comment_text": "", + "digests": { + "md5": "cca7c246dbee5dc3038de6992694b9a8", + "sha256": "09c28887cf6136d3473410a724fd94f2d3107498fe536c9be95b5e0b48e549dd" + }, + "downloads": -1, + "filename": "celery-4.2.0rc3-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "cca7c246dbee5dc3038de6992694b9a8", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 406220, + "upload_time": "2018-04-29T06:29:31", + "upload_time_iso_8601": "2018-04-29T06:29:31.463396Z", + "url": "https://files.pythonhosted.org/packages/ec/4b/cbaab09d1601273ba750d224109eb2a661413922f6ef088b1248e5094ad8/celery-4.2.0rc3-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "dc503f414c51d2fc4c38cad9de9d695a", + "sha256": "a7a5adfcd5c9a1deec7772f06218b96440dd6ebc0abc8e586933813ece07f230" + }, + "downloads": -1, + "filename": "celery-4.2.0rc3.tar.gz", + "has_sig": true, + "md5_digest": "dc503f414c51d2fc4c38cad9de9d695a", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 1346934, + "upload_time": "2018-04-29T06:29:37", + "upload_time_iso_8601": "2018-04-29T06:29:37.976014Z", + "url": "https://files.pythonhosted.org/packages/4f/5d/13bde750045f4519f4dfc2a1fae7a714dcbc8ffa98c711ce14bc044452d5/celery-4.2.0rc3.tar.gz" + } + ], + "4.2.0rc4": [ + { + "comment_text": "", + "digests": { + "md5": "022728f7f9fb35e829e55fa06469b343", + "sha256": "22dc3b5a43f6d2ca127d976009357684a6e0671577987193695222936ac0a6dd" + }, + "downloads": -1, + "filename": "celery-4.2.0rc4-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "022728f7f9fb35e829e55fa06469b343", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 401047, + "upload_time": "2018-05-22T06:25:30", + "upload_time_iso_8601": "2018-05-22T06:25:30.933123Z", + "url": "https://files.pythonhosted.org/packages/e3/3b/411ae267bbb10a1ea8d7ab79ec6be0f2530a4a9ae977e35afa5879c76d89/celery-4.2.0rc4-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1e0dc70edc40ff7bff6f8f7c6cd3fbbc", + "sha256": "68291fb53ec47600fb7c0ec5def6d631fd0f0a0f37fb2c4a050e56e5794cc9e5" + }, + "downloads": -1, + "filename": "celery-4.2.0rc4.tar.gz", + "has_sig": true, + "md5_digest": "1e0dc70edc40ff7bff6f8f7c6cd3fbbc", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 1350101, + "upload_time": "2018-05-22T06:25:37", + "upload_time_iso_8601": "2018-05-22T06:25:37.461953Z", + "url": "https://files.pythonhosted.org/packages/b5/f7/f862b92e6fc7c3628712d69d8f5d41173db5bda27f0504b17444a79b98bc/celery-4.2.0rc4.tar.gz" + } + ], + "4.2.1": [ + { + "comment_text": "", + "digests": { + "md5": "f48d95dc2fb83be1342ae8497120a63f", + "sha256": "ad7a7411772b80a4d6c64f2f7f723200e39fb66cf614a7fdfab76d345acc7b13" + }, + "downloads": -1, + "filename": "celery-4.2.1-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "f48d95dc2fb83be1342ae8497120a63f", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 401504, + "upload_time": "2018-07-18T08:17:01", + "upload_time_iso_8601": "2018-07-18T08:17:01.168316Z", + "url": "https://files.pythonhosted.org/packages/e8/58/2a0b1067ab2c12131b5c089dfc579467c76402475c5231095e36a43b749c/celery-4.2.1-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "71397f019700edc97a41ebadf09daf42", + "sha256": "77dab4677e24dc654d42dfbdfed65fa760455b6bb563a0877ecc35f4cfcfc678" + }, + "downloads": -1, + "filename": "celery-4.2.1.tar.gz", + "has_sig": true, + "md5_digest": "71397f019700edc97a41ebadf09daf42", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 1364075, + "upload_time": "2018-07-18T08:17:24", + "upload_time_iso_8601": "2018-07-18T08:17:24.648573Z", + "url": "https://files.pythonhosted.org/packages/1e/6e/b30be7e43bab0311a695dd2576b3bf4528af4fd7c98f382e1b4029d5fc6a/celery-4.2.1.tar.gz" + } + ], + "4.2.2": [ + { + "comment_text": "", + "digests": { + "md5": "5e4095904097dbd19f28aaf564220b38", + "sha256": "373d6544c8d6ee66b9c1c9ba61ec4c74334c9a861306002662252bd5fd0ff6a1" + }, + "downloads": -1, + "filename": "celery-4.2.2-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "5e4095904097dbd19f28aaf564220b38", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 401395, + "upload_time": "2019-03-20T13:50:22", + "upload_time_iso_8601": "2019-03-20T13:50:22.098859Z", + "url": "https://files.pythonhosted.org/packages/24/e9/9741a5a8b83253e27293e77bd4319c84306019dfbfa4cc43fa250243c12f/celery-4.2.2-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "fd58baa026733777c0644b84710f5026", + "sha256": "b1b7da98be6b4082abfa6e18282ece450271f366bce81d0d521342a0db862506" + }, + "downloads": -1, + "filename": "celery-4.2.2.tar.gz", + "has_sig": true, + "md5_digest": "fd58baa026733777c0644b84710f5026", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 1356962, + "upload_time": "2019-03-20T13:50:30", + "upload_time_iso_8601": "2019-03-20T13:50:30.378776Z", + "url": "https://files.pythonhosted.org/packages/1b/45/080ca4860d32905fa0acffbb07b6a808382369bb2e53398060f1ffb02ef8/celery-4.2.2.tar.gz" + } + ], + "4.3.0": [ + { + "comment_text": "", + "digests": { + "md5": "f1a0221fdd2666837bd6b879f577e715", + "sha256": "528e56767ae7e43a16cfef24ee1062491f5754368d38fcfffa861cdb9ef219be" + }, + "downloads": -1, + "filename": "celery-4.3.0-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "f1a0221fdd2666837bd6b879f577e715", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 413645, + "upload_time": "2019-03-31T15:56:34", + "upload_time_iso_8601": "2019-03-31T15:56:34.897053Z", + "url": "https://files.pythonhosted.org/packages/5c/a1/a3dd9d8bfa09156ec2cba37f90accf35c0f4ecc3980d96cb4fb99e56504b/celery-4.3.0-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7015c93e6869276deedfd8638ca4a770", + "sha256": "4c4532aa683f170f40bd76f928b70bc06ff171a959e06e71bf35f2f9d6031ef9" + }, + "downloads": -1, + "filename": "celery-4.3.0.tar.gz", + "has_sig": true, + "md5_digest": "7015c93e6869276deedfd8638ca4a770", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 1398430, + "upload_time": "2019-03-31T15:56:39", + "upload_time_iso_8601": "2019-03-31T15:56:39.270570Z", + "url": "https://files.pythonhosted.org/packages/a2/4b/d020836f751617e907e84753a41c92231cd4b673ff991b8ee9da52361323/celery-4.3.0.tar.gz" + } + ], + "4.3.0rc1": [ + { + "comment_text": "", + "digests": { + "md5": "d9456f438fa08dbdec7027aa90901162", + "sha256": "62cdf98af78278202b8a3ba1b8215c87ab420eae7eebf0b7ba27b16ebc9f148e" + }, + "downloads": -1, + "filename": "celery-4.3.0rc1-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "d9456f438fa08dbdec7027aa90901162", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 410279, + "upload_time": "2019-02-20T15:07:45", + "upload_time_iso_8601": "2019-02-20T15:07:45.547729Z", + "url": "https://files.pythonhosted.org/packages/55/64/4930488574a9b65e717315837172e9e7ea472107a9ebe8a1423910413e1e/celery-4.3.0rc1-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "2da74cd735d4c24eea1fd859a25a7bd2", + "sha256": "ce1f8068f8330e9552def4161f34ee667a1e3f5f8874425ee5768d05e821afca" + }, + "downloads": -1, + "filename": "celery-4.3.0rc1.tar.gz", + "has_sig": true, + "md5_digest": "2da74cd735d4c24eea1fd859a25a7bd2", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 1386540, + "upload_time": "2019-02-20T15:07:53", + "upload_time_iso_8601": "2019-02-20T15:07:53.385385Z", + "url": "https://files.pythonhosted.org/packages/b4/a0/d3c8dc6e4f9e5b04c0153ec8fd5613b4c864d8def446e4d97964022d467e/celery-4.3.0rc1.tar.gz" + } + ], + "4.3.0rc2": [ + { + "comment_text": "", + "digests": { + "md5": "22a173dbd8c61bc5fced14ad06f48067", + "sha256": "44129fe6146a7ba96466d42e650f0444497fd9be542f8a9092716d2970804770" + }, + "downloads": -1, + "filename": "celery-4.3.0rc2-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "22a173dbd8c61bc5fced14ad06f48067", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 412403, + "upload_time": "2019-03-03T19:45:03", + "upload_time_iso_8601": "2019-03-03T19:45:03.765845Z", + "url": "https://files.pythonhosted.org/packages/2e/f7/50145a5ef22668535e2208b686d730d7423cc4cee7d7042dc4cfa57b6dca/celery-4.3.0rc2-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "bf52be3c1721bdd659f83f8c99899416", + "sha256": "fe05a3e2873d11990fe7c08319e8ca5bd2d0424b521f40f3d29b891134e5df00" + }, + "downloads": -1, + "filename": "celery-4.3.0rc2.tar.gz", + "has_sig": true, + "md5_digest": "bf52be3c1721bdd659f83f8c99899416", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 1390175, + "upload_time": "2019-03-03T19:45:23", + "upload_time_iso_8601": "2019-03-03T19:45:23.318033Z", + "url": "https://files.pythonhosted.org/packages/5a/01/3dbd8f110bc3f8cbb614612c36cc6c34b0177531d5f36413bbaf8c5d3009/celery-4.3.0rc2.tar.gz" + } + ], + "4.3.0rc3": [ + { + "comment_text": "", + "digests": { + "md5": "bf16cb18d93f6023bef9d1b8878831c0", + "sha256": "a394953a4574619efc6bd84015a01649cf12c8123b6003132cad07f36b79aca5" + }, + "downloads": -1, + "filename": "celery-4.3.0rc3-py2.py3-none-any.whl", + "has_sig": true, + "md5_digest": "bf16cb18d93f6023bef9d1b8878831c0", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 413167, + "upload_time": "2019-03-21T14:17:35", + "upload_time_iso_8601": "2019-03-21T14:17:35.307557Z", + "url": "https://files.pythonhosted.org/packages/73/e0/fd3714b5892311f1f802201ab287f47db10afdd7361b516a920fced18201/celery-4.3.0rc3-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "485ea6169e04a502ade70456f2cd04be", + "sha256": "8dcfaf39ba25a6830e4e029765a8872489eca7f0162d9bd12962c59da7bf5c9d" + }, + "downloads": -1, + "filename": "celery-4.3.0rc3.tar.gz", + "has_sig": true, + "md5_digest": "485ea6169e04a502ade70456f2cd04be", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", + "size": 1395547, + "upload_time": "2019-03-21T14:17:53", + "upload_time_iso_8601": "2019-03-21T14:17:53.979627Z", + "url": "https://files.pythonhosted.org/packages/6f/58/6db69cf4a5de75c69732499de8ef1ea337771152fd5904fbb3594a896781/celery-4.3.0rc3.tar.gz" + } + ], + "4.4.0": [ + { + "comment_text": "", + "digests": { + "md5": "f2d41b6be7bb0c26131bf55eac63fa0a", + "sha256": "7c544f37a84a5eadc44cab1aa8c9580dff94636bb81978cdf9bf8012d9ea7d8f" + }, + "downloads": -1, + "filename": "celery-4.4.0-py2.py3-none-any.whl", + "has_sig": false, + "md5_digest": "f2d41b6be7bb0c26131bf55eac63fa0a", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 421999, + "upload_time": "2019-12-16T03:47:33", + "upload_time_iso_8601": "2019-12-16T03:47:33.557633Z", + "url": "https://files.pythonhosted.org/packages/47/53/6e2ccc87b18ddc582d2de31b3ed9144c72a68062659e9e4a68e19312d254/celery-4.4.0-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "9c5d17291bf204662ecc972eec26789e", + "sha256": "d3363bb5df72d74420986a435449f3c3979285941dff57d5d97ecba352a0e3e2" + }, + "downloads": -1, + "filename": "celery-4.4.0.tar.gz", + "has_sig": false, + "md5_digest": "9c5d17291bf204662ecc972eec26789e", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 1415339, + "upload_time": "2019-12-16T03:47:52", + "upload_time_iso_8601": "2019-12-16T03:47:52.661342Z", + "url": "https://files.pythonhosted.org/packages/b5/50/929ce161882c2f35a91aac02f1c6e8556bbdc2a8b53320fc44fa0b9a0cd4/celery-4.4.0.tar.gz" + } + ], + "4.4.0rc1": [ + { + "comment_text": "", + "digests": { + "md5": "d12a9c682a93541224ca7329b486438c", + "sha256": "bc474e5dd9e2675e0a377aa577dd5efc9fc9e8b3932c9ab9809c53bab04b79b1" + }, + "downloads": -1, + "filename": "celery-4.4.0rc1-py2.py3-none-any.whl", + "has_sig": false, + "md5_digest": "d12a9c682a93541224ca7329b486438c", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 415594, + "upload_time": "2019-06-06T07:10:04", + "upload_time_iso_8601": "2019-06-06T07:10:04.678783Z", + "url": "https://files.pythonhosted.org/packages/55/fb/ed96664165c3e459e71cc04acc68f1cbd1fcb6ee1c712b0ff51c5f2b9491/celery-4.4.0rc1-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f5cf4f530dac79af5ac3b6ff6c29494c", + "sha256": "a43d00f85f949ea0fb046fdc3c20d56d30d9e21bc77844be29a8f29db3539db3" + }, + "downloads": -1, + "filename": "celery-4.4.0rc1.tar.gz", + "has_sig": false, + "md5_digest": "f5cf4f530dac79af5ac3b6ff6c29494c", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 1403063, + "upload_time": "2019-06-06T07:10:11", + "upload_time_iso_8601": "2019-06-06T07:10:11.778122Z", + "url": "https://files.pythonhosted.org/packages/e8/af/8802e51e362e7126f3962d26d2611c35d5474bb718762671e32b0b897fe8/celery-4.4.0rc1.tar.gz" + } + ], + "4.4.0rc2": [ + { + "comment_text": "", + "digests": { + "md5": "0fadf579e535317b5c56f3978aef7e7f", + "sha256": "42d77e2ad99b8cf3950ca8b872f7310fc9dfbeb3ba68ec10a25cd63c87043db1" + }, + "downloads": -1, + "filename": "celery-4.4.0rc2-py2.py3-none-any.whl", + "has_sig": false, + "md5_digest": "0fadf579e535317b5c56f3978aef7e7f", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 415758, + "upload_time": "2019-06-14T22:25:10", + "upload_time_iso_8601": "2019-06-14T22:25:10.321096Z", + "url": "https://files.pythonhosted.org/packages/bf/33/37694cf1ecd8f5a8e3f538e73db9d4c38f308ae51295fd4f6d0281a31bcb/celery-4.4.0rc2-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "982d708b676191b87fca449f95d1a856", + "sha256": "8f7f479b1cbfd5e10c184d744801695e7187901a0c99bedd50ae9b6a8cf351d1" + }, + "downloads": -1, + "filename": "celery-4.4.0rc2.tar.gz", + "has_sig": false, + "md5_digest": "982d708b676191b87fca449f95d1a856", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 1405214, + "upload_time": "2019-06-14T22:25:24", + "upload_time_iso_8601": "2019-06-14T22:25:24.310608Z", + "url": "https://files.pythonhosted.org/packages/71/3b/90beebd960427fd019fc35e77b88a218db8050731871a2995bf8d3138634/celery-4.4.0rc2.tar.gz" + } + ], + "4.4.0rc3": [ + { + "comment_text": "", + "digests": { + "md5": "a19809e45cfdb2403f532c76ea3d9859", + "sha256": "821d11967f0f3f8fe24bd61ecfc7b6acbb5a926b719f1e8c4d5ff7bc09e18d81" + }, + "downloads": -1, + "filename": "celery-4.4.0rc3-py2.py3-none-any.whl", + "has_sig": false, + "md5_digest": "a19809e45cfdb2403f532c76ea3d9859", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 417126, + "upload_time": "2019-08-14T17:05:04", + "upload_time_iso_8601": "2019-08-14T17:05:04.970304Z", + "url": "https://files.pythonhosted.org/packages/dd/70/173e8f817ec7623fa756c3afbd0e1ee784836028e5aa180ea558b09af712/celery-4.4.0rc3-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "777b00059ed9711801b991c68b32f823", + "sha256": "ae4541fb3af5182bd4af749fee9b89c4858f2792d34bb5d034967e662cf9b55c" + }, + "downloads": -1, + "filename": "celery-4.4.0rc3.tar.gz", + "has_sig": false, + "md5_digest": "777b00059ed9711801b991c68b32f823", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 1408274, + "upload_time": "2019-08-14T17:05:13", + "upload_time_iso_8601": "2019-08-14T17:05:13.988362Z", + "url": "https://files.pythonhosted.org/packages/38/b7/b5e563d1967bf079cfa63f8df3e7a004e81b663e42d034228654cf835200/celery-4.4.0rc3.tar.gz" + } + ], + "4.4.0rc4": [ + { + "comment_text": "", + "digests": { + "md5": "821b9519771b893eec0edd66d61b1b2e", + "sha256": "65f4d67fc1037edacecbf39fcf956da68b984cf2a6d89bd73a8a5a80e35e3dd7" + }, + "downloads": -1, + "filename": "celery-4.4.0rc4-py2.py3-none-any.whl", + "has_sig": false, + "md5_digest": "821b9519771b893eec0edd66d61b1b2e", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 419091, + "upload_time": "2019-11-10T18:51:25", + "upload_time_iso_8601": "2019-11-10T18:51:25.033234Z", + "url": "https://files.pythonhosted.org/packages/90/2d/d184fcb0fd85fd43ebca8a36e2d8a7080a1d5532c5dc0c21fdb73873f9d3/celery-4.4.0rc4-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "de9d5822589080dcbe2dab521afd136a", + "sha256": "8a59d80235b876881d9893751f2a87936165fc1347efee66095620b3cadf533b" + }, + "downloads": -1, + "filename": "celery-4.4.0rc4.tar.gz", + "has_sig": false, + "md5_digest": "de9d5822589080dcbe2dab521afd136a", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 1413803, + "upload_time": "2019-11-10T18:51:38", + "upload_time_iso_8601": "2019-11-10T18:51:38.511696Z", + "url": "https://files.pythonhosted.org/packages/3c/7b/3c7fa56ed29e6f27a8a14c6cf21b6a8af641cff3097adc7b138bbabe96a6/celery-4.4.0rc4.tar.gz" + } + ], + "4.4.0rc5": [ + { + "comment_text": "", + "digests": { + "md5": "b24bfad910065e44a27a157ba2ef38a8", + "sha256": "395599ad0728eeee4cb899c99568e5a8a885f54aee377c31b626b24bf3b35cd0" + }, + "downloads": -1, + "filename": "celery-4.4.0rc5-py2.py3-none-any.whl", + "has_sig": false, + "md5_digest": "b24bfad910065e44a27a157ba2ef38a8", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 421982, + "upload_time": "2019-12-07T15:07:19", + "upload_time_iso_8601": "2019-12-07T15:07:19.596419Z", + "url": "https://files.pythonhosted.org/packages/9e/81/ed54e8c9b7892f3700caa7c1e116925a4066061a2b576945d41e77267857/celery-4.4.0rc5-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "3cd1289b2905b22d995f3b373df44fe8", + "sha256": "2fa97a53855014148f7d41455e3e0869ab45fb6f777df6c6b1701f03c55c573a" + }, + "downloads": -1, + "filename": "celery-4.4.0rc5.tar.gz", + "has_sig": false, + "md5_digest": "3cd1289b2905b22d995f3b373df44fe8", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 1412452, + "upload_time": "2019-12-07T15:07:38", + "upload_time_iso_8601": "2019-12-07T15:07:38.591951Z", + "url": "https://files.pythonhosted.org/packages/99/72/127bd339548455b31ff5a7c744ef960479c0303c3b59fc5a5688a4ad9385/celery-4.4.0rc5.tar.gz" + } + ] + }, + "urls": [ + { + "comment_text": "", + "digests": { + "md5": "f2d41b6be7bb0c26131bf55eac63fa0a", + "sha256": "7c544f37a84a5eadc44cab1aa8c9580dff94636bb81978cdf9bf8012d9ea7d8f" + }, + "downloads": -1, + "filename": "celery-4.4.0-py2.py3-none-any.whl", + "has_sig": false, + "md5_digest": "f2d41b6be7bb0c26131bf55eac63fa0a", + "packagetype": "bdist_wheel", + "python_version": "py2.py3", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 421999, + "upload_time": "2019-12-16T03:47:33", + "upload_time_iso_8601": "2019-12-16T03:47:33.557633Z", + "url": "https://files.pythonhosted.org/packages/47/53/6e2ccc87b18ddc582d2de31b3ed9144c72a68062659e9e4a68e19312d254/celery-4.4.0-py2.py3-none-any.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "9c5d17291bf204662ecc972eec26789e", + "sha256": "d3363bb5df72d74420986a435449f3c3979285941dff57d5d97ecba352a0e3e2" + }, + "downloads": -1, + "filename": "celery-4.4.0.tar.gz", + "has_sig": false, + "md5_digest": "9c5d17291bf204662ecc972eec26789e", + "packagetype": "sdist", + "python_version": "source", + "requires_python": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*,", + "size": 1415339, + "upload_time": "2019-12-16T03:47:52", + "upload_time_iso_8601": "2019-12-16T03:47:52.661342Z", + "url": "https://files.pythonhosted.org/packages/b5/50/929ce161882c2f35a91aac02f1c6e8556bbdc2a8b53320fc44fa0b9a0cd4/celery-4.4.0.tar.gz" + } + ] +} diff --git a/tests/fixtures/llvmlite.json b/tests/fixtures/llvmlite.json new file mode 100644 index 00000000..572a27e3 --- /dev/null +++ b/tests/fixtures/llvmlite.json @@ -0,0 +1,5681 @@ +{ + "info": { + "author": "Continuum Analytics, Inc.", + "author_email": "numba-users@continuum.io", + "bugtrack_url": null, + "classifiers": [ + "Development Status :: 4 - Beta", + "Intended Audience :: Developers", + "Operating System :: OS Independent", + "Programming Language :: Python", + "Programming Language :: Python :: 2.7", + "Programming Language :: Python :: 3.4", + "Programming Language :: Python :: 3.5", + "Topic :: Software Development :: Code Generators", + "Topic :: Software Development :: Compilers" + ], + "description": "========\nllvmlite\n========\n.. image:: https://travis-ci.org/numba/llvmlite.svg?branch=master\n :target: https://travis-ci.org/numba/llvmlite\n :alt: Travis CI\n.. image:: https://codeclimate.com/github/numba/llvmlite/badges/gpa.svg\n :target: https://codeclimate.com/github/numba/llvmlite\n :alt: Code Climate\n.. image:: https://coveralls.io/repos/github/numba/llvmlite/badge.svg\n :target: https://coveralls.io/github/numba/llvmlite\n :alt: Coveralls.io\n.. image:: https://readthedocs.org/projects/llvmlite/badge/\n :target: https://llvmlite.readthedocs.io\n :alt: Readthedocs.io\n\nA lightweight LLVM python binding for writing JIT compilers\n\nThe old llvmpy_ binding exposes a lot of LLVM APIs but the mapping of\nC++-style memory management to Python is error prone. Numba_ and many JIT\ncompilers do not need a full LLVM API. Only the IR builder, optimizer,\nand JIT compiler APIs are necessary.\n\n.. _llvmpy: https://github.com/llvmpy/llvmpy\n\nllvmlite is a project originally tailored for Numba_'s needs, using the\nfollowing approach:\n\n* A small C wrapper around the parts of the LLVM C++ API we need that are\n not already exposed by the LLVM C API.\n* A ctypes Python wrapper around the C API.\n* A pure Python implementation of the subset of the LLVM IR builder that we\n need for Numba.\n\n\nKey Benefits\n============\n\n* The IR builder is pure Python code and decoupled from LLVM's\n frequently-changing C++ APIs.\n* Materializing a LLVM module calls LLVM's IR parser which provides\n better error messages than step-by-step IR building through the C++\n API (no more segfaults or process aborts).\n* Most of llvmlite uses the LLVM C API which is small but very stable\n (low maintenance when changing LLVM version).\n* The binding is not a Python C-extension, but a plain DLL accessed using\n ctypes (no need to wrestle with Python's compiler requirements and C++ 11\n compatibility).\n* The Python binding layer has sane memory management.\n* llvmlite is quite faster than llvmpy's thanks to a much simpler architeture\n (the Numba_ test suite is twice faster than it was).\n\nllvmpy Compatibility Layer\n--------------------------\n\nThe ``llvmlite.llvmpy`` namespace provides a minimal llvmpy compatibility\nlayer.\n\n\nCompatibility\n=============\n\nllvmlite works with Python 2.7 and Python 3.4 or greater.\n\nAs of version 0.29.0, llvmlite requires LLVM 7.0.x or later\n\nHistorical compatibility table:\n\n================= ========================\nllvmlite versions compatible LLVM versions\n================= ========================\n0.29.0 - ... 7.0.x, 7.1.x, 8.0.x\n0.27.0 - 0.28.0 7.0.x\n0.23.0 - 0.26.0 6.0.x\n0.21.0 - 0.22.0 5.0.x\n0.17.0 - 0.20.0 4.0.x\n0.16.0 - 0.17.0 3.9.x\n0.13.0 - 0.15.0 3.8.x\n0.9.0 - 0.12.1 3.7.x\n0.6.0 - 0.8.0 3.6.x\n0.1.0 - 0.5.1 3.5.x\n================= ========================\n\nDocumentation\n=============\n\nYou'll find the documentation at http://llvmlite.pydata.org\n\n\nPre-built binaries\n==================\n\nWe recommend you use the binaries provided by the Numba_ team for\nthe Conda_ package manager. You can find them in Numba's `anaconda.org\nchannel `_. For example::\n\n $ conda install --channel=numba llvmlite\n\n(or, simply, the official llvmlite package provided in the Anaconda_\ndistribution)\n\n.. _Numba: http://numba.pydata.org/\n.. _Conda: http://conda.pydata.org/\n.. _Anaconda: http://docs.continuum.io/anaconda/index.html\n\n\nOther build methods\n===================\n\nIf you don't want to use our pre-built packages, you can compile\nand install llvmlite yourself. The documentation will teach you how:\nhttp://llvmlite.pydata.org/en/latest/install/index.html\n\n\n", + "description_content_type": "", + "docs_url": null, + "download_url": "https://github.com/numba/llvmlite", + "downloads": { + "last_day": -1, + "last_month": -1, + "last_week": -1 + }, + "home_page": "http://llvmlite.pydata.org", + "keywords": "", + "license": "BSD", + "maintainer": "", + "maintainer_email": "", + "name": "llvmlite", + "package_url": "https://pypi.org/project/llvmlite/", + "platform": "", + "project_url": "https://pypi.org/project/llvmlite/", + "project_urls": { + "Download": "https://github.com/numba/llvmlite", + "Homepage": "http://llvmlite.pydata.org" + }, + "release_url": "https://pypi.org/project/llvmlite/0.30.0/", + "requires_dist": null, + "requires_python": "", + "summary": "lightweight wrapper around basic LLVM functionality", + "version": "0.30.0" + }, + "last_serial": 5956473, + "releases": { + "0.1": [], + "0.10.0": [ + { + "comment_text": "", + "digests": { + "md5": "e79f844ca79413485c17f5286aa8df79", + "sha256": "b6b55e19ae2be38770299e9c73e6ae07d770e4f95313ddc8389ba45693b5f4aa" + }, + "downloads": -1, + "filename": "llvmlite-0.10.0.tar.gz", + "has_sig": false, + "md5_digest": "e79f844ca79413485c17f5286aa8df79", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 92000, + "upload_time": "2016-03-31T16:38:27", + "upload_time_iso_8601": "2016-03-31T16:38:27.250416Z", + "url": "https://files.pythonhosted.org/packages/ee/fa/0c37901ccd44f937cb00cad9faef8c232edda3b552e65f5af69ec464a5ba/llvmlite-0.10.0.tar.gz" + } + ], + "0.11.0": [ + { + "comment_text": "", + "digests": { + "md5": "6cec423ad4f7555123764109c979f678", + "sha256": "93cfee5bb9e4d16e42d8986b480191a4c1f149a5818c654d58ae142449f382bd" + }, + "downloads": -1, + "filename": "llvmlite-0.11.0.tar.gz", + "has_sig": false, + "md5_digest": "6cec423ad4f7555123764109c979f678", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 87648, + "upload_time": "2016-05-24T15:59:34", + "upload_time_iso_8601": "2016-05-24T15:59:34.279292Z", + "url": "https://files.pythonhosted.org/packages/3c/bc/3548a91224b06c3fc29715d42483a14bfb67427d7e6d7873ce46338b5916/llvmlite-0.11.0.tar.gz" + } + ], + "0.12.0": [ + { + "comment_text": "", + "digests": { + "md5": "d8dd859cfbe408ce172a6fbfb3626d0b", + "sha256": "d8c77a6c596a5ad40a0d793d6b492c88cfb6925b94723bef7b318a5f0a2a23d6" + }, + "downloads": -1, + "filename": "llvmlite-0.12.0.1.tar.gz", + "has_sig": false, + "md5_digest": "d8dd859cfbe408ce172a6fbfb3626d0b", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 94674, + "upload_time": "2016-07-06T16:17:31", + "upload_time_iso_8601": "2016-07-06T16:17:31.192113Z", + "url": "https://files.pythonhosted.org/packages/d2/5b/cf095b445fc991effc648008bb32c96e2a7bfb6e14232ad1ff85f533130e/llvmlite-0.12.0.1.tar.gz" + } + ], + "0.12.1": [ + { + "comment_text": "", + "digests": { + "md5": "24c99ffeba849553060d7cac26400bd7", + "sha256": "3ce71beebd4cbc7a49abe4eadfc99725477fd43caeb7405650ebb746c7a1d0df" + }, + "downloads": -1, + "filename": "llvmlite-0.12.1.tar.gz", + "has_sig": false, + "md5_digest": "24c99ffeba849553060d7cac26400bd7", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 88271, + "upload_time": "2016-07-08T15:58:17", + "upload_time_iso_8601": "2016-07-08T15:58:17.372696Z", + "url": "https://files.pythonhosted.org/packages/c6/79/b0bdbadaef701dd3b38b2e100147312fe95a85e1b4f19adb9d686c225a7c/llvmlite-0.12.1.tar.gz" + } + ], + "0.13.0": [ + { + "comment_text": "", + "digests": { + "md5": "bfe797849aa8ad6cab5eafe0099c3c27", + "sha256": "f852be3391acb2e77ef484c5d0ff90e7cf2821dcf9575e358a1f08c274c582eb" + }, + "downloads": -1, + "filename": "llvmlite-0.13.0.tar.gz", + "has_sig": false, + "md5_digest": "bfe797849aa8ad6cab5eafe0099c3c27", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 92200, + "upload_time": "2016-08-24T14:55:58", + "upload_time_iso_8601": "2016-08-24T14:55:58.170597Z", + "url": "https://files.pythonhosted.org/packages/41/d5/0d0a042f3c323c6ca2e91366d9a0c6bf2d2b3c14146c4af3be3941ab05ae/llvmlite-0.13.0.tar.gz" + } + ], + "0.14.0": [ + { + "comment_text": "", + "digests": { + "md5": "c61c1f64177986c3c28132325d66fe91", + "sha256": "e8059073f377bee98c7bea6902851fa6decfe24746d8bc5b2811c8aa76d56ff9" + }, + "downloads": -1, + "filename": "llvmlite-0.14.0.tar.gz", + "has_sig": false, + "md5_digest": "c61c1f64177986c3c28132325d66fe91", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 93709, + "upload_time": "2016-10-18T14:24:22", + "upload_time_iso_8601": "2016-10-18T14:24:22.860266Z", + "url": "https://files.pythonhosted.org/packages/78/e5/f3393f26b324e6960bcf47201082d605ad9c46c27478278a359e95bb01c4/llvmlite-0.14.0.tar.gz" + } + ], + "0.15.0": [ + { + "comment_text": "", + "digests": { + "md5": "8bba236f243aa640cc14cd5e4c356e80", + "sha256": "c855835537eda61f3a0d19aedc44f006d5084a2d322aee8ffa87aa06bb800dc4" + }, + "downloads": -1, + "filename": "llvmlite-0.15.0.tar.gz", + "has_sig": false, + "md5_digest": "8bba236f243aa640cc14cd5e4c356e80", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 95009, + "upload_time": "2016-12-22T00:11:04", + "upload_time_iso_8601": "2016-12-22T00:11:04.765544Z", + "url": "https://files.pythonhosted.org/packages/5a/61/bee4cfb45fe57007ad907c818c7be1a976a1de3df1e51c0c4bd9d139cfa6/llvmlite-0.15.0.tar.gz" + } + ], + "0.16.0": [ + { + "comment_text": "", + "digests": { + "md5": "ec0bd7b3758bf2ebb081c61400a5be81", + "sha256": "ef3bae32482f91742d91571b5225a6943804291eb9405b98090a7b50942ec5e9" + }, + "downloads": -1, + "filename": "llvmlite-0.16.0.tar.gz", + "has_sig": false, + "md5_digest": "ec0bd7b3758bf2ebb081c61400a5be81", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 95284, + "upload_time": "2017-02-17T17:07:39", + "upload_time_iso_8601": "2017-02-17T17:07:39.889681Z", + "url": "https://files.pythonhosted.org/packages/23/c7/56d7c18564783f33206b3cb6ce861a8d681e8be1a124c5651145ce5aad0f/llvmlite-0.16.0.tar.gz" + } + ], + "0.17.0": [ + { + "comment_text": "python2.7 linux64 wheel", + "digests": { + "md5": "b44651abb491e8e14a2a0c7f48a2dd0f", + "sha256": "9f2d710781c0e45e51d25b6d09efb21b6f7a852b839f76789aa57da8b8a70c1a" + }, + "downloads": -1, + "filename": "llvmlite-0.17.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "b44651abb491e8e14a2a0c7f48a2dd0f", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 89308, + "upload_time": "2017-04-10T13:45:08", + "upload_time_iso_8601": "2017-04-10T13:45:08.920742Z", + "url": "https://files.pythonhosted.org/packages/b7/dc/25ce886357eabc1ba549191ae6e5ff7d8534fc45ce7565b389b642f19b4a/llvmlite-0.17.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "python3.5 linux64 wheel", + "digests": { + "md5": "21cfb37eaa696971bfe5b28fe1adf1d4", + "sha256": "658fd609a1a21d7347cfdf10b6bf2d964c9423711df7eb1658106c0ed1d2c1eb" + }, + "downloads": -1, + "filename": "llvmlite-0.17.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "21cfb37eaa696971bfe5b28fe1adf1d4", + "packagetype": "bdist_wheel", + "python_version": "3.5", + "requires_python": null, + "size": 89518, + "upload_time": "2017-04-10T13:45:57", + "upload_time_iso_8601": "2017-04-10T13:45:57.079856Z", + "url": "https://files.pythonhosted.org/packages/af/9f/6b84c7c9c86dc04fc09e89d0fab65aa326612eeeb31dba2d7cbfdfae28b7/llvmlite-0.17.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "python3.6 linux64 wheel", + "digests": { + "md5": "ea5043e0d316b264c76e2f5c8977afbf", + "sha256": "d0dcfc16d8afba4235913e6943287c3e5d538f114224b171547577a764d07220" + }, + "downloads": -1, + "filename": "llvmlite-0.17.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "ea5043e0d316b264c76e2f5c8977afbf", + "packagetype": "bdist_wheel", + "python_version": "3.6", + "requires_python": null, + "size": 89511, + "upload_time": "2017-04-10T13:46:20", + "upload_time_iso_8601": "2017-04-10T13:46:20.289807Z", + "url": "https://files.pythonhosted.org/packages/e3/45/c35a910dcb6c8e094f3327c875164f740ad85f677bae27144fc7e32255f0/llvmlite-0.17.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "78c0ac3312fdd1370714b59a750481ce", + "sha256": "e0ac2375360755f638f034ac246c9a3b2501e9da9eaca399860a850e016419be" + }, + "downloads": -1, + "filename": "llvmlite-0.17.0.tar.gz", + "has_sig": false, + "md5_digest": "78c0ac3312fdd1370714b59a750481ce", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 95919, + "upload_time": "2017-04-10T13:41:38", + "upload_time_iso_8601": "2017-04-10T13:41:38.722004Z", + "url": "https://files.pythonhosted.org/packages/d8/df/95334ed840f953b9a3d353d9df828d74754c3480fd1b1df5d0d7cc402d7d/llvmlite-0.17.0.tar.gz" + } + ], + "0.17.1": [ + { + "comment_text": "", + "digests": { + "md5": "a065a2797e2b07001c6bf551cb6d5b4a", + "sha256": "15b588b655dd2a664f56d6b1dcf535026025a6bf2d01598e3d59d91f67221a8d" + }, + "downloads": -1, + "filename": "llvmlite-0.17.1-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "a065a2797e2b07001c6bf551cb6d5b4a", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 13328230, + "upload_time": "2017-04-12T18:36:35", + "upload_time_iso_8601": "2017-04-12T18:36:35.509092Z", + "url": "https://files.pythonhosted.org/packages/06/af/f8df1bdde4ada963639de347de177cad28bcbb15f1073d3b48b31ab953c8/llvmlite-0.17.1-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "48bdc9471616347e2630e5704d508456", + "sha256": "00a5a104d121832788356914d024d0b212331a94c9aaf876f92e86f612238b90" + }, + "downloads": -1, + "filename": "llvmlite-0.17.1-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "48bdc9471616347e2630e5704d508456", + "packagetype": "bdist_wheel", + "python_version": "3.5", + "requires_python": null, + "size": 13328391, + "upload_time": "2017-04-12T18:36:57", + "upload_time_iso_8601": "2017-04-12T18:36:57.011990Z", + "url": "https://files.pythonhosted.org/packages/3a/73/cf8ea4c8b9b9373b575c594fbc809da785e9b927cc22ea27a671e4001e90/llvmlite-0.17.1-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1462e0e6eb910c0b400c5c3e4e07c6c7", + "sha256": "0a14846940ed2429e9d94b3276baff7558df11abbdbea072a36cda30b00f9a2c" + }, + "downloads": -1, + "filename": "llvmlite-0.17.1-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "1462e0e6eb910c0b400c5c3e4e07c6c7", + "packagetype": "bdist_wheel", + "python_version": "3.6", + "requires_python": null, + "size": 13328412, + "upload_time": "2017-04-12T18:37:20", + "upload_time_iso_8601": "2017-04-12T18:37:20.431798Z", + "url": "https://files.pythonhosted.org/packages/d8/dc/1959cc83a915e7c09ad89ad9328111918ba63b169de21af0337a62097f43/llvmlite-0.17.1-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "8cf201c4b7471008e2b6efc02eb3fae8", + "sha256": "9f5d98615ce1852c0f79e52d122ba38adee89752482db9bcbe51c8cd5030d140" + }, + "downloads": -1, + "filename": "llvmlite-0.17.1.tar.gz", + "has_sig": false, + "md5_digest": "8cf201c4b7471008e2b6efc02eb3fae8", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 96072, + "upload_time": "2017-04-12T18:34:39", + "upload_time_iso_8601": "2017-04-12T18:34:39.260996Z", + "url": "https://files.pythonhosted.org/packages/79/bf/09738d0d76279207ef2460678515c9b6bf1494159f29eb547d7af2d057d7/llvmlite-0.17.1.tar.gz" + } + ], + "0.18.0": [ + { + "comment_text": "", + "digests": { + "md5": "f0b1dda794f9be7a0cf6e09c03ac8b01", + "sha256": "3eb8e78830eb71196143b8bd1d5293df9811f07c334a6b5c7d6a189241971c6f" + }, + "downloads": -1, + "filename": "llvmlite-0.18.0-cp27-cp27m-macosx_10_7_x86_64.whl", + "has_sig": false, + "md5_digest": "f0b1dda794f9be7a0cf6e09c03ac8b01", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 10961707, + "upload_time": "2017-05-04T22:31:47", + "upload_time_iso_8601": "2017-05-04T22:31:47.335454Z", + "url": "https://files.pythonhosted.org/packages/22/be/900eaa9c824302d13cabdfae7b4b0ecc93dffe47dbe3635eae006afc539c/llvmlite-0.18.0-cp27-cp27m-macosx_10_7_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "8785f4f705328688bbce1916890e02ca", + "sha256": "79db62b54ade1dfd248029d7514977d73ca8390bcaf8c568a3e3a7bf6167152d" + }, + "downloads": -1, + "filename": "llvmlite-0.18.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "8785f4f705328688bbce1916890e02ca", + "packagetype": "bdist_wheel", + "python_version": "2.7", + "requires_python": null, + "size": 13328312, + "upload_time": "2017-05-04T22:34:00", + "upload_time_iso_8601": "2017-05-04T22:34:00.417141Z", + "url": "https://files.pythonhosted.org/packages/f7/b7/5b279faa67de45f153a0000249f83a0aa8f665220c779e20826e09f05d4b/llvmlite-0.18.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "cbd847c7e3f197f1eb351865eab75f1e", + "sha256": "8bdbe81094882378a80c58427ec9aaffe98ac2d84daea1d3958bda2589e6783d" + }, + "downloads": -1, + "filename": "llvmlite-0.18.0-cp35-cp35m-macosx_10_7_x86_64.whl", + "has_sig": false, + "md5_digest": "cbd847c7e3f197f1eb351865eab75f1e", + "packagetype": "bdist_wheel", + "python_version": "3.5", + "requires_python": null, + "size": 10961754, + "upload_time": "2017-05-04T22:35:37", + "upload_time_iso_8601": "2017-05-04T22:35:37.140431Z", + "url": "https://files.pythonhosted.org/packages/5f/e7/740f429583d584f0d0231801064264dff752feb2bfa95ffa68e6e5d657ce/llvmlite-0.18.0-cp35-cp35m-macosx_10_7_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "2adc8315fd6907f7ec47cf8752b5b93a", + "sha256": "f47eb587e41db82a7b246dd9f11218ac475291da3c510289f3ecc0b438640990" + }, + "downloads": -1, + "filename": "llvmlite-0.18.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "2adc8315fd6907f7ec47cf8752b5b93a", + "packagetype": "bdist_wheel", + "python_version": "3.5", + "requires_python": null, + "size": 13328515, + "upload_time": "2017-05-04T22:37:25", + "upload_time_iso_8601": "2017-05-04T22:37:25.698745Z", + "url": "https://files.pythonhosted.org/packages/4b/cb/46d99812dda2ea70f9b44ff596f8b9796767317345d0c17d2da480c1152c/llvmlite-0.18.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "919d6b3c97bf1d810a3e374ee82bced4", + "sha256": "2cbb0ce2e9a7600b59044040e4792bb4bd16b5e24b06d3b01d4f5e9f0a5aef5d" + }, + "downloads": -1, + "filename": "llvmlite-0.18.0-cp36-cp36m-macosx_10_7_x86_64.whl", + "has_sig": false, + "md5_digest": "919d6b3c97bf1d810a3e374ee82bced4", + "packagetype": "bdist_wheel", + "python_version": "3.6", + "requires_python": null, + "size": 10961766, + "upload_time": "2017-05-04T22:39:01", + "upload_time_iso_8601": "2017-05-04T22:39:01.198461Z", + "url": "https://files.pythonhosted.org/packages/f9/16/03aaa435ece3f2e57ef9b5113a90dd11d6791de7e7491a1b93a38b6c3e01/llvmlite-0.18.0-cp36-cp36m-macosx_10_7_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "9caf2824fca263531740b79554396f3e", + "sha256": "99bd486f934d71fba8655533ff05ffed5c9ecde660e1914d1acce97f83bcb28c" + }, + "downloads": -1, + "filename": "llvmlite-0.18.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "9caf2824fca263531740b79554396f3e", + "packagetype": "bdist_wheel", + "python_version": "3.6", + "requires_python": null, + "size": 13328496, + "upload_time": "2017-05-04T22:40:51", + "upload_time_iso_8601": "2017-05-04T22:40:51.921771Z", + "url": "https://files.pythonhosted.org/packages/f4/ae/39122aa349c6000ab46f8337b78c81dbc63abb21de115b0ab80d52b839da/llvmlite-0.18.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "aa1898a8f4033edd0b23747d801b8022", + "sha256": "25a38af925f0523b834b92216d7f7cc997624942d5958287350c254f5e730404" + }, + "downloads": -1, + "filename": "llvmlite-0.18.0.tar.gz", + "has_sig": false, + "md5_digest": "aa1898a8f4033edd0b23747d801b8022", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 96184, + "upload_time": "2017-05-04T22:27:27", + "upload_time_iso_8601": "2017-05-04T22:27:27.172998Z", + "url": "https://files.pythonhosted.org/packages/78/3f/89b2b1d071c330911b3fcbb83fd42431b4b37f8ff705f8a3957459550a0c/llvmlite-0.18.0.tar.gz" + } + ], + "0.19.0": [ + { + "comment_text": "", + "digests": { + "md5": "17c63caa06c894b742b8ba93ee5f089d", + "sha256": "abd67dd12e0e9a5493389a4f809510bd52cc1c97014c85c120bab18ba3ceaf12" + }, + "downloads": -1, + "filename": "llvmlite-0.19.0-cp27-cp27m-macosx_10_7_x86_64.whl", + "has_sig": false, + "md5_digest": "17c63caa06c894b742b8ba93ee5f089d", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 10971216, + "upload_time": "2017-07-07T18:25:51", + "upload_time_iso_8601": "2017-07-07T18:25:51.782294Z", + "url": "https://files.pythonhosted.org/packages/eb/20/af162419b68132e089b6284b2d6ca176cbfc5c026275f3f8343aab0a556a/llvmlite-0.19.0-cp27-cp27m-macosx_10_7_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7d8bbef769f81837ff5ef3fdbf11cd5b", + "sha256": "eb2463841dabbd863ab2bb71dfb72635db907d090b4ccef03bb316807f5bc2bd" + }, + "downloads": -1, + "filename": "llvmlite-0.19.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "7d8bbef769f81837ff5ef3fdbf11cd5b", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 13328274, + "upload_time": "2017-07-07T18:23:52", + "upload_time_iso_8601": "2017-07-07T18:23:52.927551Z", + "url": "https://files.pythonhosted.org/packages/eb/bf/d143ce57b39ea76c9d1c0ede5675b6a4e358ee7b906b140f1523e23928fe/llvmlite-0.19.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "947c30271a07fd5656afc27ec4745057", + "sha256": "40cbac1fea1a819f0b722d1ef5db99669aafafaf9b53d612d054a26c41b06b68" + }, + "downloads": -1, + "filename": "llvmlite-0.19.0-cp35-cp35m-macosx_10_7_x86_64.whl", + "has_sig": false, + "md5_digest": "947c30271a07fd5656afc27ec4745057", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 10971278, + "upload_time": "2017-07-07T18:26:07", + "upload_time_iso_8601": "2017-07-07T18:26:07.368025Z", + "url": "https://files.pythonhosted.org/packages/e0/88/b95e6c0e8bcf62b8e56f29edce579fd7c75e80cec978a0ac4de29516d9f4/llvmlite-0.19.0-cp35-cp35m-macosx_10_7_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7ddf40f40167b7edfe12b415e78a6811", + "sha256": "d9733b3301ec4ee891458d3df7cf5f4b7410a7cc15a35a5a7cf229a2295b9930" + }, + "downloads": -1, + "filename": "llvmlite-0.19.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "7ddf40f40167b7edfe12b415e78a6811", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 13328491, + "upload_time": "2017-07-07T18:24:36", + "upload_time_iso_8601": "2017-07-07T18:24:36.001395Z", + "url": "https://files.pythonhosted.org/packages/5b/20/7f6ea49fc066b19e700c5781d1c39dd04172b785057971826259d05be6b5/llvmlite-0.19.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "8d7de13c1610be7a7707efaa8d9534c1", + "sha256": "bb3e61fc9932634e5dacd8781afda4d9438dad8f8008d0b07f5f9eeb60998e38" + }, + "downloads": -1, + "filename": "llvmlite-0.19.0-cp36-cp36m-macosx_10_7_x86_64.whl", + "has_sig": false, + "md5_digest": "8d7de13c1610be7a7707efaa8d9534c1", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 10971273, + "upload_time": "2017-07-07T18:26:19", + "upload_time_iso_8601": "2017-07-07T18:26:19.695717Z", + "url": "https://files.pythonhosted.org/packages/79/05/971ba1e6798482119c904d3d925c96a9618478ddeadf4d0f8cab5bd9e3f5/llvmlite-0.19.0-cp36-cp36m-macosx_10_7_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "27114302fb3f54e11e2696b431fff589", + "sha256": "ca155cda54be07b3348e65106d8ffc44187e956feac4f5c5974b6f1a48b05da9" + }, + "downloads": -1, + "filename": "llvmlite-0.19.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "27114302fb3f54e11e2696b431fff589", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 13328483, + "upload_time": "2017-07-07T18:24:44", + "upload_time_iso_8601": "2017-07-07T18:24:44.423227Z", + "url": "https://files.pythonhosted.org/packages/a5/dd/6b2d3124055bc24af8248f9f1645f1ab763c35dd63d67f156ac144ce7d16/llvmlite-0.19.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "853d78227bd410df6dff9cdd1d255f4a", + "sha256": "fbaeb3d584e0f6bac82a33776e9b5f0b5b4a3415a03edeff5d66f6176f0edbe2" + }, + "downloads": -1, + "filename": "llvmlite-0.19.0.tar.gz", + "has_sig": false, + "md5_digest": "853d78227bd410df6dff9cdd1d255f4a", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 97109, + "upload_time": "2017-07-07T16:26:11", + "upload_time_iso_8601": "2017-07-07T16:26:11.702227Z", + "url": "https://files.pythonhosted.org/packages/05/25/b93d2eb59e79c813f03245d733f30104ebb6ce5fcac5ad9589e0c61a983d/llvmlite-0.19.0.tar.gz" + } + ], + "0.2.0": [ + { + "comment_text": "", + "digests": { + "md5": "2b42716b0fdce6c69e546e2539c2e36c", + "sha256": "23ca4e3cd66d858a73e484accb5d5abccc9501e0a37ba8888dd34794fb831c18" + }, + "downloads": -1, + "filename": "llvmlite-0.2.0.tar.gz", + "has_sig": false, + "md5_digest": "2b42716b0fdce6c69e546e2539c2e36c", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 57894, + "upload_time": "2014-12-17T21:36:45", + "upload_time_iso_8601": "2014-12-17T21:36:45.479189Z", + "url": "https://files.pythonhosted.org/packages/b5/fe/023d482d853cafe97f81129783f26c14de678a316cbf4a61db54320e6f09/llvmlite-0.2.0.tar.gz" + } + ], + "0.2.1": [ + { + "comment_text": "", + "digests": { + "md5": "9de985ccbc54d992b0f3e0b6a0f776a5", + "sha256": "48c9217db60d496ffef9d15bcb493b84757fc08b95b0332ca418a21344fd3f6b" + }, + "downloads": -1, + "filename": "llvmlite-0.2.1.tar.gz", + "has_sig": false, + "md5_digest": "9de985ccbc54d992b0f3e0b6a0f776a5", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 67340, + "upload_time": "2014-12-19T20:32:23", + "upload_time_iso_8601": "2014-12-19T20:32:23.839875Z", + "url": "https://files.pythonhosted.org/packages/8c/d8/fead83f1f5783f4eff773fb75c43355131e8a703018865ccac16d46dca03/llvmlite-0.2.1.tar.gz" + } + ], + "0.2.2": [ + { + "comment_text": "", + "digests": { + "md5": "86fc6349adf0a46a0e008632808bf5ca", + "sha256": "5771189d07da7774446e1ac6c586d31ea4293ef1c2bfb9dbe0c570bcf971b4a1" + }, + "downloads": -1, + "filename": "llvmlite-0.2.2.tar.gz", + "has_sig": false, + "md5_digest": "86fc6349adf0a46a0e008632808bf5ca", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 75171, + "upload_time": "2015-01-29T17:27:28", + "upload_time_iso_8601": "2015-01-29T17:27:28.775952Z", + "url": "https://files.pythonhosted.org/packages/b6/f5/814a0497f18d8341fbd208fff6da189efffe06dcddaa61a64d93242107f6/llvmlite-0.2.2.tar.gz" + } + ], + "0.20.0": [ + { + "comment_text": "", + "digests": { + "md5": "a22dedadbe1eee0061f08346d6b6949b", + "sha256": "fe7624fc15ddc672db1854f7bb2e6d468f36298f9490e25fc808c43a1dc33ddb" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp27-cp27m-macosx_10_7_x86_64.whl", + "has_sig": false, + "md5_digest": "a22dedadbe1eee0061f08346d6b6949b", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 10970258, + "upload_time": "2017-09-08T19:08:46", + "upload_time_iso_8601": "2017-09-08T19:08:46.745980Z", + "url": "https://files.pythonhosted.org/packages/8a/3e/68db5037e54880413702a41839fc3c9b54e422b5256a3c7936c4ea83956e/llvmlite-0.20.0-cp27-cp27m-macosx_10_7_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "ba0bd76c2b523f7223dab5a25839a562", + "sha256": "cd13f0bcf48493c8d0e5e7e2c83baab99af009ce05b8531807f9204bef9578e6" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "ba0bd76c2b523f7223dab5a25839a562", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 13472978, + "upload_time": "2017-09-08T19:39:15", + "upload_time_iso_8601": "2017-09-08T19:39:15.371978Z", + "url": "https://files.pythonhosted.org/packages/b6/cc/0d59aa50942ebf5d5ccf6a9fad99510892b19f3eba8059a12442b1021a3a/llvmlite-0.20.0-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "a3c631445ade30f852bc31d690a9ca2c", + "sha256": "7193f9f14057b941be8e90fe0a13ae3fe0fa8dda9215d0599c60767ccab67a05" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "a3c631445ade30f852bc31d690a9ca2c", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 13321823, + "upload_time": "2017-09-08T19:13:23", + "upload_time_iso_8601": "2017-09-08T19:13:23.805523Z", + "url": "https://files.pythonhosted.org/packages/f8/91/e9423747529af1c0b2b34647e8149247650a9a11988242df4f044d9d0d0e/llvmlite-0.20.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "5ee24dae36f12d41e63b1f76deb8dbef", + "sha256": "b69a9c6bacbcc5f06ed5bb0462d11b579b20babf205d1617baa13b5c5e8b9c6b" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp27-cp27m-win32.whl", + "has_sig": false, + "md5_digest": "5ee24dae36f12d41e63b1f76deb8dbef", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 6996703, + "upload_time": "2017-09-08T19:09:03", + "upload_time_iso_8601": "2017-09-08T19:09:03.632066Z", + "url": "https://files.pythonhosted.org/packages/ab/51/c748a8d5a71d3e8a448340315d2e0d7bcb5e1d8fbf10181486431be64d47/llvmlite-0.20.0-cp27-cp27m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "e7167b1f48c135e27149c4be96634dad", + "sha256": "a8fc67d8080f4e169614c65bdcacb63c744b8677c487b17a9d9397f08626835f" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp27-cp27m-win_amd64.whl", + "has_sig": false, + "md5_digest": "e7167b1f48c135e27149c4be96634dad", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 9056717, + "upload_time": "2017-09-08T19:09:20", + "upload_time_iso_8601": "2017-09-08T19:09:20.450847Z", + "url": "https://files.pythonhosted.org/packages/49/a5/667be0024c2118eae22da4f8d199ba2a83d03b627fd7be9a49838acfbd74/llvmlite-0.20.0-cp27-cp27m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c952d82ef97dc303b0908323e8aa4be6", + "sha256": "25809b24b944c55763dbc82a4bc07523714b46f64de30d90472b18a17df28d71" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp35-cp35m-macosx_10_7_x86_64.whl", + "has_sig": false, + "md5_digest": "c952d82ef97dc303b0908323e8aa4be6", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 10970207, + "upload_time": "2017-09-08T19:13:32", + "upload_time_iso_8601": "2017-09-08T19:13:32.866503Z", + "url": "https://files.pythonhosted.org/packages/48/de/8a0bc3388e73176afef9883eed08c2995b1f85fa278b65eae9a258039cf2/llvmlite-0.20.0-cp35-cp35m-macosx_10_7_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c6ec44f4def0e6b9f5fa404b98e24c61", + "sha256": "9e131bbfbd27a6725358fa364e19240ac42a2b3bdabf2e337eb2cca32681e7f7" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "c6ec44f4def0e6b9f5fa404b98e24c61", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 13472941, + "upload_time": "2017-09-08T19:39:24", + "upload_time_iso_8601": "2017-09-08T19:39:24.439081Z", + "url": "https://files.pythonhosted.org/packages/aa/48/c74f71de864779d776a7e4384c5effe70ca484db434debd3d74216683385/llvmlite-0.20.0-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "5ff58da807f32cd4c9d7c93b5180f866", + "sha256": "1a634bfdbae8d9280b1b3ca1854c2dcaff1c0b5974583a7c45a732a7f5a4d539" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "5ff58da807f32cd4c9d7c93b5180f866", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 13321769, + "upload_time": "2017-09-08T19:13:39", + "upload_time_iso_8601": "2017-09-08T19:13:39.562622Z", + "url": "https://files.pythonhosted.org/packages/2f/14/60dd0b30ac2c17ae606ac2d4334a894fe04989f29175622adb7242237cbd/llvmlite-0.20.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "17ddd70f5f55063a5f861577d3f4d3fd", + "sha256": "9c3d14498d90201ffe1fc1a93bae10ac92ca04c6211a2f56267347da716008b0" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp35-cp35m-win32.whl", + "has_sig": false, + "md5_digest": "17ddd70f5f55063a5f861577d3f4d3fd", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 6996646, + "upload_time": "2017-09-08T19:13:51", + "upload_time_iso_8601": "2017-09-08T19:13:51.178945Z", + "url": "https://files.pythonhosted.org/packages/15/a2/0b4f8d8956a1b4f4d535aa78dc67e61b91ba8546420ed24be30fe119ca0d/llvmlite-0.20.0-cp35-cp35m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "b0e1ade3fa427ebeadc183d22e36bb62", + "sha256": "b2c22ed1eac0b97440ba9bf19cbaf2da86d820784ae38776894a1e4ff0222035" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp35-cp35m-win_amd64.whl", + "has_sig": false, + "md5_digest": "b0e1ade3fa427ebeadc183d22e36bb62", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 9056658, + "upload_time": "2017-09-08T19:14:03", + "upload_time_iso_8601": "2017-09-08T19:14:03.256478Z", + "url": "https://files.pythonhosted.org/packages/c6/55/9efa7e0358aef7949c3ae72540507731b0c81e2b657a2a9e5f09542356e4/llvmlite-0.20.0-cp35-cp35m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "d5d8fd65f3450906cb5a8cc84034b54c", + "sha256": "ac923083ead8f08a7b61b5a9a731d9add588338a5def122c629993ce8e6ed865" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp36-cp36m-macosx_10_7_x86_64.whl", + "has_sig": false, + "md5_digest": "d5d8fd65f3450906cb5a8cc84034b54c", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 10970211, + "upload_time": "2017-09-08T19:14:12", + "upload_time_iso_8601": "2017-09-08T19:14:12.003721Z", + "url": "https://files.pythonhosted.org/packages/ad/2a/5bebb551b22adc1631e28478f39013f4cf5075f42de0daa463a09ffd5d4c/llvmlite-0.20.0-cp36-cp36m-macosx_10_7_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "fa9e93ce67f2c7c6227df4303dce9199", + "sha256": "0c6bbee8917ee31037d2116b1cb966ffd852ab50f4fdfd7b19173ff745005391" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "fa9e93ce67f2c7c6227df4303dce9199", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 13472906, + "upload_time": "2017-09-08T19:39:34", + "upload_time_iso_8601": "2017-09-08T19:39:34.914263Z", + "url": "https://files.pythonhosted.org/packages/fc/09/69ecef9f00530d999568dd2bdebf486015d3f8b952af0fd5342c32a3d7d7/llvmlite-0.20.0-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "a859cc143ea722c131ffbe7c443d9f2d", + "sha256": "2ac9dd383a3e068e88ca1382b2536d27ec9c07d810324f2523447437448b7467" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "a859cc143ea722c131ffbe7c443d9f2d", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 13321759, + "upload_time": "2017-09-08T19:14:20", + "upload_time_iso_8601": "2017-09-08T19:14:20.756498Z", + "url": "https://files.pythonhosted.org/packages/0c/d1/62204ba18647c091fde8c9af99d7aac3de6f7d776d5282e0da8a118b5e51/llvmlite-0.20.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "d9c416af21bfc8e22ca9b7d5dd6aed89", + "sha256": "2250296958987e85bfa8cc987b8a504ca7bf43a44b674eda7c2829181ae6cab9" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp36-cp36m-win32.whl", + "has_sig": false, + "md5_digest": "d9c416af21bfc8e22ca9b7d5dd6aed89", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 6996646, + "upload_time": "2017-09-08T19:14:40", + "upload_time_iso_8601": "2017-09-08T19:14:40.806919Z", + "url": "https://files.pythonhosted.org/packages/66/f2/c5b1a39c02eb480710b2a109ab3d4ca1f6d0fc38d56b67ea6b90a439d661/llvmlite-0.20.0-cp36-cp36m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7880a186a851073c96e508362b519fb9", + "sha256": "1674353d3a3b5bfe130b3c03e122ac79fc7727af2005067b991446b8ecefee2d" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0-cp36-cp36m-win_amd64.whl", + "has_sig": false, + "md5_digest": "7880a186a851073c96e508362b519fb9", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 9056661, + "upload_time": "2017-09-08T19:14:53", + "upload_time_iso_8601": "2017-09-08T19:14:53.772801Z", + "url": "https://files.pythonhosted.org/packages/c5/64/178e147930392f153d4e52a6c41c7823fc7e7f2b567c8676bbeb350503a0/llvmlite-0.20.0-cp36-cp36m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f2aa60d0981842b7930ba001b03679ab", + "sha256": "b2f174848df16bb9195a07fec102110a06d018da736bd9b3570a54d44c797c29" + }, + "downloads": -1, + "filename": "llvmlite-0.20.0.tar.gz", + "has_sig": false, + "md5_digest": "f2aa60d0981842b7930ba001b03679ab", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 96753, + "upload_time": "2017-09-08T18:50:43", + "upload_time_iso_8601": "2017-09-08T18:50:43.304194Z", + "url": "https://files.pythonhosted.org/packages/9d/c7/6e8d2403d73f93715988ce069cf141ec167d9d73588b649eb7341d8d3b2f/llvmlite-0.20.0.tar.gz" + } + ], + "0.21.0": [ + { + "comment_text": "", + "digests": { + "md5": "584933cfcb038a6a130c246c00bfb555", + "sha256": "efcaed21e81ad623db00deeafccd82056943aec77e4ec175e042427bc8056565" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp27-cp27m-macosx_10_6_x86_64.whl", + "has_sig": false, + "md5_digest": "584933cfcb038a6a130c246c00bfb555", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 11713859, + "upload_time": "2017-12-08T20:10:28", + "upload_time_iso_8601": "2017-12-08T20:10:28.740257Z", + "url": "https://files.pythonhosted.org/packages/b2/69/e6bc9c1317b23e419e1126fe79d8cfd1a587125860d5bf1d0c258f42a989/llvmlite-0.21.0-cp27-cp27m-macosx_10_6_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f1cd824d63f07127b6c297790390886b", + "sha256": "484840a53413ad6e94bbf0ce918c1ae107483597906d63caadc4f73bf2b88bdb" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "f1cd824d63f07127b6c297790390886b", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 15053943, + "upload_time": "2017-12-08T20:10:50", + "upload_time_iso_8601": "2017-12-08T20:10:50.020569Z", + "url": "https://files.pythonhosted.org/packages/98/88/5a3d6c1c76ce3c181e277447f05b2a4ca1e5d22f15aced9ed67b4a60420c/llvmlite-0.21.0-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "790ebfe76227243eae5af9d8ca261969", + "sha256": "ab52059c6284ad87cc296cc8bc14b771eb100b3b105f3f2039473dad083e52d7" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "790ebfe76227243eae5af9d8ca261969", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 14825400, + "upload_time": "2017-12-08T20:11:01", + "upload_time_iso_8601": "2017-12-08T20:11:01.606366Z", + "url": "https://files.pythonhosted.org/packages/df/3c/20ed592e15b4b4fda9a8d2216c148cfce9bc17bb00cf25efb376b8e838ee/llvmlite-0.21.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "de383a1f77c2af989314f92132bdc593", + "sha256": "629ec6a01216d40492744be5fe3b5eab53f30ffbb129f5e7ae7786c03725f42d" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp27-cp27m-win32.whl", + "has_sig": false, + "md5_digest": "de383a1f77c2af989314f92132bdc593", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 7635590, + "upload_time": "2017-12-08T20:10:34", + "upload_time_iso_8601": "2017-12-08T20:10:34.613363Z", + "url": "https://files.pythonhosted.org/packages/08/06/84056e275481d7b109e8162979c1de1125a94cd72e7698c2add0c32acbd1/llvmlite-0.21.0-cp27-cp27m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "52b1acf40c19a26944ec818b49ec3b4a", + "sha256": "b840248e3b61bdf78a9c2a6f8ec6c0f14cbb2a4dccd377d8d84669fc63483838" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp27-cp27m-win_amd64.whl", + "has_sig": false, + "md5_digest": "52b1acf40c19a26944ec818b49ec3b4a", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 9819598, + "upload_time": "2017-12-08T20:10:40", + "upload_time_iso_8601": "2017-12-08T20:10:40.609481Z", + "url": "https://files.pythonhosted.org/packages/f2/03/792f501e303e83dd1a4b8cc49e1dc7988eb84a822d1e31f0d3aace53fc7a/llvmlite-0.21.0-cp27-cp27m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "24bd4ec1c8040cc5701ef833a30623c9", + "sha256": "626cb7938f1ca42b972a217d434a454d70eeaf20c50246bff71ff233d4bf25dd" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp35-cp35m-macosx_10_6_x86_64.whl", + "has_sig": false, + "md5_digest": "24bd4ec1c8040cc5701ef833a30623c9", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 11713816, + "upload_time": "2017-12-08T20:11:10", + "upload_time_iso_8601": "2017-12-08T20:11:10.146555Z", + "url": "https://files.pythonhosted.org/packages/c2/01/faf92b70c19f8021a64471d46d113eba4e4d0d97c959945bde233aa76ca1/llvmlite-0.21.0-cp35-cp35m-macosx_10_6_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "2c05e97a41abdbe72241c5f1b613cd97", + "sha256": "10bbecfe0c90aea5d8a4f6e0f500c69b88a3f9d4afa0a2c88f6dc39eb21851d9" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "2c05e97a41abdbe72241c5f1b613cd97", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 15054103, + "upload_time": "2017-12-08T20:11:18", + "upload_time_iso_8601": "2017-12-08T20:11:18.010057Z", + "url": "https://files.pythonhosted.org/packages/46/5a/59098d6bf22e5a1617e3e98c611d7645ce6e80b831d2f6e61aa729f1af47/llvmlite-0.21.0-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "be2e6afba82d4fc30485fe78daad5d22", + "sha256": "ee910716163644b89bf4566602a1ee62f7d000246a068396213df15c981a20ef" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "be2e6afba82d4fc30485fe78daad5d22", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 14825276, + "upload_time": "2017-12-08T20:11:25", + "upload_time_iso_8601": "2017-12-08T20:11:25.832115Z", + "url": "https://files.pythonhosted.org/packages/f4/9e/fb3e784134aac20ecc4ffdfbad203d9adadc99e92a2348b77379e3a36698/llvmlite-0.21.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "74efbeb31679d833508188a323645a98", + "sha256": "9985363c62939bfc649c28d8e090300c2b810910e0142b341ad289b29e345315" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp35-cp35m-win32.whl", + "has_sig": false, + "md5_digest": "74efbeb31679d833508188a323645a98", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 7635534, + "upload_time": "2017-12-08T20:11:34", + "upload_time_iso_8601": "2017-12-08T20:11:34.745483Z", + "url": "https://files.pythonhosted.org/packages/5e/4d/79adf8d26d390d04f187e5c80dd737415027f5ca279a3d06db1626cb7181/llvmlite-0.21.0-cp35-cp35m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c6d8fab869f09add0de6f68479102c36", + "sha256": "5157de392c57c927ab18c8f51fba7e32cb72e733d37d2ca28823d35b08a5be9b" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp35-cp35m-win_amd64.whl", + "has_sig": false, + "md5_digest": "c6d8fab869f09add0de6f68479102c36", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 9819544, + "upload_time": "2017-12-08T20:11:39", + "upload_time_iso_8601": "2017-12-08T20:11:39.609543Z", + "url": "https://files.pythonhosted.org/packages/1c/68/a930027ae777414e62f10361c0a5d16749c25aac0c5681eeff053280681b/llvmlite-0.21.0-cp35-cp35m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "b34c797e63982ec11f577ae17b034587", + "sha256": "5705550e82bd6bbc49db298f280b12a6e38fe38dd79bbeb9adf8cc80d1d7019d" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp36-cp36m-macosx_10_7_x86_64.whl", + "has_sig": false, + "md5_digest": "b34c797e63982ec11f577ae17b034587", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 11713820, + "upload_time": "2017-12-08T20:11:46", + "upload_time_iso_8601": "2017-12-08T20:11:46.956533Z", + "url": "https://files.pythonhosted.org/packages/a8/eb/dcb499f1b854559f1363502964062622654f0a0891cd535940d26d76c6fa/llvmlite-0.21.0-cp36-cp36m-macosx_10_7_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7d43fa826ff701f8c01de1ec187925cc", + "sha256": "50cb6042c62c948dd962a9a8970479f2aefe43d720b5a2e547df3e25b81b4de4" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "7d43fa826ff701f8c01de1ec187925cc", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 15063827, + "upload_time": "2017-12-08T20:11:58", + "upload_time_iso_8601": "2017-12-08T20:11:58.032136Z", + "url": "https://files.pythonhosted.org/packages/d1/d4/526b203d57d742c14ab9e6924bef3fa50d54e496b4a7a31ffb60eed7189f/llvmlite-0.21.0-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "6ecb05ac7c05f9ba101e6a6d0a1848da", + "sha256": "f579619ff3041641fd848b5ce5e7f28f550d6ffd01946853caaee9c388bcfa12" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "6ecb05ac7c05f9ba101e6a6d0a1848da", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 14825176, + "upload_time": "2017-12-08T20:12:08", + "upload_time_iso_8601": "2017-12-08T20:12:08.535244Z", + "url": "https://files.pythonhosted.org/packages/16/be/81017c43f2db7aea842ab10ebb55cc83645f712ce3039f77fe4112687277/llvmlite-0.21.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "e4f7be6ca9d3d43a658831293f714fa1", + "sha256": "3738b152dacc203c5808eee3bce149d225ad5bd96e7e58b0092829678f977a01" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp36-cp36m-win32.whl", + "has_sig": false, + "md5_digest": "e4f7be6ca9d3d43a658831293f714fa1", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 7635534, + "upload_time": "2017-12-08T20:12:21", + "upload_time_iso_8601": "2017-12-08T20:12:21.037988Z", + "url": "https://files.pythonhosted.org/packages/10/e8/78190ae01ae1dc8a5e31af0f80d1b3f33e40fde532f5c05349aa869019b9/llvmlite-0.21.0-cp36-cp36m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "6b50b1ade424ec2c10e07f928d91bde4", + "sha256": "6f4ff177081bc8c8e29a6cca1c35acdc5fc0af9cc62e3e566434f77b9b285de0" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0-cp36-cp36m-win_amd64.whl", + "has_sig": false, + "md5_digest": "6b50b1ade424ec2c10e07f928d91bde4", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 9819542, + "upload_time": "2017-12-08T20:12:27", + "upload_time_iso_8601": "2017-12-08T20:12:27.675506Z", + "url": "https://files.pythonhosted.org/packages/22/b4/74aba1e54f9ab320520334f97ce72cc56021cc24b2882f3f8981cdeb9fd0/llvmlite-0.21.0-cp36-cp36m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "092319b8c153d31839450857ad6f7203", + "sha256": "3a5dd0695fdfb9fd47464cd71791b84935bf9642e11f4811d57aa1f2da8cdaa8" + }, + "downloads": -1, + "filename": "llvmlite-0.21.0.tar.gz", + "has_sig": false, + "md5_digest": "092319b8c153d31839450857ad6f7203", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 96462, + "upload_time": "2017-12-08T16:20:55", + "upload_time_iso_8601": "2017-12-08T16:20:55.382675Z", + "url": "https://files.pythonhosted.org/packages/16/75/4380e640cf11b9964ba1d459c5048b34dd8d0f252fc49279b76241d6f83c/llvmlite-0.21.0.tar.gz" + } + ], + "0.22.0": [ + { + "comment_text": "", + "digests": { + "md5": "4f4b435a2cc06524a1a240aeb81673a1", + "sha256": "a6791fb91de4debdfbd9f2d7edf6bc00fc893b3831d16c792e3861e542106a3b" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp27-cp27m-macosx_10_6_x86_64.whl", + "has_sig": false, + "md5_digest": "4f4b435a2cc06524a1a240aeb81673a1", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 11710699, + "upload_time": "2018-02-19T20:16:13", + "upload_time_iso_8601": "2018-02-19T20:16:13.644748Z", + "url": "https://files.pythonhosted.org/packages/34/59/a66f3836ceae3793f9fec3707a5af02c4c8fb4ce0e00c64a42efbddf8023/llvmlite-0.22.0-cp27-cp27m-macosx_10_6_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "802a3833da7a7f1f70fd4d8037accc83", + "sha256": "f334131c7d64d914e89c6c001d728aee0b8002114e091cce689a3d842cdadc84" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "802a3833da7a7f1f70fd4d8037accc83", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 15054939, + "upload_time": "2018-02-19T20:16:31", + "upload_time_iso_8601": "2018-02-19T20:16:31.448392Z", + "url": "https://files.pythonhosted.org/packages/4e/2b/ef06034a5492a898e1bcb465a6141df5fa3b2d19c351a061e794f5652292/llvmlite-0.22.0-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "d6b015c71c096b50aa79aa1a01061c7c", + "sha256": "f48f0aace03fe601fdbbd3be938234bfe10e6ae0bc95ff4f0e5aa039c9393769" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "d6b015c71c096b50aa79aa1a01061c7c", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 14826618, + "upload_time": "2018-02-19T20:16:48", + "upload_time_iso_8601": "2018-02-19T20:16:48.024875Z", + "url": "https://files.pythonhosted.org/packages/31/10/aaa46737c73fa2a90d814ae2e2b826336db7153aacbf8bf014d161081ae1/llvmlite-0.22.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "073a0b953e3d8b66d047531fabd928b0", + "sha256": "9a86d5abbd1be93db2669560ec3e1ea2d5bcd3f99fbd6f9bb4247a296a225d99" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp27-cp27m-win32.whl", + "has_sig": false, + "md5_digest": "073a0b953e3d8b66d047531fabd928b0", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 7635944, + "upload_time": "2018-02-19T20:16:19", + "upload_time_iso_8601": "2018-02-19T20:16:19.906197Z", + "url": "https://files.pythonhosted.org/packages/a5/e4/8efe5190fdeaf8b352164d779c1d4d005179106dc192655d4c386aa837b3/llvmlite-0.22.0-cp27-cp27m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "aad7e5f25dc8dd6d7f5e6be4c38c15a1", + "sha256": "29f4b64e3f6ed19dd07b92c255f6ed11850fae9b2903c2a5a764800e60facbac" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp27-cp27m-win_amd64.whl", + "has_sig": false, + "md5_digest": "aad7e5f25dc8dd6d7f5e6be4c38c15a1", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 9821685, + "upload_time": "2018-02-19T20:16:24", + "upload_time_iso_8601": "2018-02-19T20:16:24.913609Z", + "url": "https://files.pythonhosted.org/packages/51/99/e8d4c24575322b1dc68ab3dac8f6417a375f8790a9cfc9c8f56aec767028/llvmlite-0.22.0-cp27-cp27m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "05a64cea057d74e27bc24154e037508d", + "sha256": "d88709ef64df2afc9574908fdb4761436dbb727a173b340e953341e1e2d89ea2" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp35-cp35m-macosx_10_6_x86_64.whl", + "has_sig": false, + "md5_digest": "05a64cea057d74e27bc24154e037508d", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 11710662, + "upload_time": "2018-02-19T20:17:06", + "upload_time_iso_8601": "2018-02-19T20:17:06.491409Z", + "url": "https://files.pythonhosted.org/packages/7f/3b/56aaf692b8849d915c78061eaedc65b4b20a463e63009d414c0d6448cbca/llvmlite-0.22.0-cp35-cp35m-macosx_10_6_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "089c57e054a2afd8c6460363903a1ab0", + "sha256": "c7c85b817fa4dfc0a03c146b6dc295bca981ed5453e978a8300bcd1b3d939975" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "089c57e054a2afd8c6460363903a1ab0", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 15055026, + "upload_time": "2018-02-19T20:17:12", + "upload_time_iso_8601": "2018-02-19T20:17:12.927891Z", + "url": "https://files.pythonhosted.org/packages/67/f5/18019cfb066320ba7c1bb6b86f82dd6d71b50f11b9caee6aa8be556e1bd9/llvmlite-0.22.0-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "a2828597af88f65fc44e9d04709c3b4c", + "sha256": "69e59d59fe0cff932587a2a11aab6074ef2303cd05a3f0c46603a4c5bf0579c6" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "a2828597af88f65fc44e9d04709c3b4c", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 14826592, + "upload_time": "2018-02-19T20:17:19", + "upload_time_iso_8601": "2018-02-19T20:17:19.910280Z", + "url": "https://files.pythonhosted.org/packages/fd/fc/9d0ed74779250aead2ada7e8ed8f53d2a500bf726ab29beff9cdfaeffb96/llvmlite-0.22.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f64f766899f7bed968ee763ec10e3d9b", + "sha256": "ced7ac7423e8ed7a5aacf943fde3d7743b2e8bfb887d72cfc00cb83e783ceedc" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp35-cp35m-win32.whl", + "has_sig": false, + "md5_digest": "f64f766899f7bed968ee763ec10e3d9b", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 7635892, + "upload_time": "2018-02-19T20:17:26", + "upload_time_iso_8601": "2018-02-19T20:17:26.319507Z", + "url": "https://files.pythonhosted.org/packages/79/2a/1f5f0017b7c04b5fd2a58b0021219bb8adbd4a8e313534d61bcc94a21e53/llvmlite-0.22.0-cp35-cp35m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "9d0d61f6123aba6a438e593472d5d538", + "sha256": "b844fc91031b9035e55725d4c4eb83f9a093ca89fbf4b30061e4dd848e60aefa" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp35-cp35m-win_amd64.whl", + "has_sig": false, + "md5_digest": "9d0d61f6123aba6a438e593472d5d538", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 9821634, + "upload_time": "2018-02-19T20:17:31", + "upload_time_iso_8601": "2018-02-19T20:17:31.308722Z", + "url": "https://files.pythonhosted.org/packages/07/61/33dd1dd6dad05fd9b761fb37e3ae7e6c30e1e579ba9688756ed9496625bf/llvmlite-0.22.0-cp35-cp35m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "537accffb1bf73207d8428fbc92c12c2", + "sha256": "8e348213ff749a3bd28bcd30b2b234d702630f302a8db96b8780e26570678295" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp36-cp36m-macosx_10_7_x86_64.whl", + "has_sig": false, + "md5_digest": "537accffb1bf73207d8428fbc92c12c2", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 11710661, + "upload_time": "2018-02-19T20:17:37", + "upload_time_iso_8601": "2018-02-19T20:17:37.189900Z", + "url": "https://files.pythonhosted.org/packages/43/47/e4da9368244bc288dd7f9063c31f3c0cc2dec4ab973089871abaeb5c7551/llvmlite-0.22.0-cp36-cp36m-macosx_10_7_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "e5feff331ea600d9259dec019a082ee6", + "sha256": "908c59438312564f58113b4d8d20b83f8a36004e03d6c475dc4d94fffac1c31e" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "e5feff331ea600d9259dec019a082ee6", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 15054977, + "upload_time": "2018-02-19T20:17:45", + "upload_time_iso_8601": "2018-02-19T20:17:45.100780Z", + "url": "https://files.pythonhosted.org/packages/52/db/2a63e076a6c79c874b0dd107dd38e4eb9df905b047f243361eead7f3942b/llvmlite-0.22.0-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1cfd8a310fc0d9e6c09d5214d9deb4c3", + "sha256": "3a13e4e4547bca1ed4847eb969ea625c70cffd2f1c1854c4f344cc1d93563184" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "1cfd8a310fc0d9e6c09d5214d9deb4c3", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 14826552, + "upload_time": "2018-02-19T20:17:52", + "upload_time_iso_8601": "2018-02-19T20:17:52.559162Z", + "url": "https://files.pythonhosted.org/packages/bc/43/fca77fe3e59d1e70975a0871e217c6919f5451178a5ad68b31f3d3ed2a88/llvmlite-0.22.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "5778511611128f5b3a57f0a49082ee19", + "sha256": "458d1caa6816f4a6edf6d73d3a8255d73de732c40ed5fbbc73ec575eda3631d6" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp36-cp36m-win32.whl", + "has_sig": false, + "md5_digest": "5778511611128f5b3a57f0a49082ee19", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 7635891, + "upload_time": "2018-02-19T20:17:58", + "upload_time_iso_8601": "2018-02-19T20:17:58.401552Z", + "url": "https://files.pythonhosted.org/packages/7f/b7/ca42a37cb59d1d7ae38bcfa76d6f38951398648d089e690129f78aa08834/llvmlite-0.22.0-cp36-cp36m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "bafc30e6e24921225655e232f13cab71", + "sha256": "2b2ff81e134c0d230be140c513e55a8a153b0bd5599952300c54e9e3a303efbb" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0-cp36-cp36m-win_amd64.whl", + "has_sig": false, + "md5_digest": "bafc30e6e24921225655e232f13cab71", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 9821630, + "upload_time": "2018-02-19T20:18:02", + "upload_time_iso_8601": "2018-02-19T20:18:02.985151Z", + "url": "https://files.pythonhosted.org/packages/3a/6e/78b553c177ce51386378120e56c47cd61efdafdb04df5c6336f99ef807a0/llvmlite-0.22.0-cp36-cp36m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "0504406f29ba8795c87a13fc8683f333", + "sha256": "a0a875f3d502f41f4a24444aa98fbf076a6bf36e2a0b3b4481b22e1c4a3acdc2" + }, + "downloads": -1, + "filename": "llvmlite-0.22.0.tar.gz", + "has_sig": false, + "md5_digest": "0504406f29ba8795c87a13fc8683f333", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 98338, + "upload_time": "2018-02-19T20:15:35", + "upload_time_iso_8601": "2018-02-19T20:15:35.162530Z", + "url": "https://files.pythonhosted.org/packages/b4/f4/ddc252b83257bbf3922e47c5042a2e28e68bd36146a932adda3010c48377/llvmlite-0.22.0.tar.gz" + } + ], + "0.23.0": [ + { + "comment_text": "", + "digests": { + "md5": "8d3418dca7f9aa690163c3fa2bff870c", + "sha256": "be7963a19e57623c65237338079eb24286d9fa58c403247f9814a208c4483611" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp27-cp27m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "8d3418dca7f9aa690163c3fa2bff870c", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 12486062, + "upload_time": "2018-04-25T15:33:19", + "upload_time_iso_8601": "2018-04-25T15:33:19.677349Z", + "url": "https://files.pythonhosted.org/packages/d3/6a/91b8bd3b8502e2b667a13824f7403eb4fe0e7e00e8abf8d4ecc485231e37/llvmlite-0.23.0-cp27-cp27m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "91ba41f6d0650c8d5d6ecf4450f7655a", + "sha256": "0cd8025e7921e670ef37e4645363929338e9bfd9363eeb95851f82e7f6ae43e9" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "91ba41f6d0650c8d5d6ecf4450f7655a", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 15921630, + "upload_time": "2018-04-25T15:33:30", + "upload_time_iso_8601": "2018-04-25T15:33:30.317948Z", + "url": "https://files.pythonhosted.org/packages/dd/3e/756d5e9e1366522d174cb48197372cbe276a46b49e7e30cfedb6532e5236/llvmlite-0.23.0-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c4f8d39ed1b276e86af0b6797243f546", + "sha256": "539097dbffa96dc6780afb30b8bcc301ee4556aad10ec717ccdce0214cfefc29" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "c4f8d39ed1b276e86af0b6797243f546", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 15821412, + "upload_time": "2018-04-25T15:33:34", + "upload_time_iso_8601": "2018-04-25T15:33:34.417773Z", + "url": "https://files.pythonhosted.org/packages/3f/02/3386da1794568637db5ab725847588f6ccfdebe1b338424b27168ba8a18c/llvmlite-0.23.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "80988ac895b21ed7f89ed1ec0290e75c", + "sha256": "1cdfc8bb965de6ebb4e6d2ec8e76eaf0fe31e20db17fc0a256edebcac39cec89" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp27-cp27m-win32.whl", + "has_sig": false, + "md5_digest": "80988ac895b21ed7f89ed1ec0290e75c", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 8254727, + "upload_time": "2018-04-25T15:33:23", + "upload_time_iso_8601": "2018-04-25T15:33:23.471693Z", + "url": "https://files.pythonhosted.org/packages/89/4d/8528a89cb19de5d6050a6e1076c35206209cfc004f476d7cee60ee01d5f3/llvmlite-0.23.0-cp27-cp27m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "5a32d5110f0e0c4384ab41a757b8a299", + "sha256": "7848868759b6fc77a5ce67e3d2a462e83871f7ef80d0734e6e094f7f94f5172e" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp27-cp27m-win_amd64.whl", + "has_sig": false, + "md5_digest": "5a32d5110f0e0c4384ab41a757b8a299", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 10596617, + "upload_time": "2018-04-25T15:33:26", + "upload_time_iso_8601": "2018-04-25T15:33:26.244874Z", + "url": "https://files.pythonhosted.org/packages/34/01/7919313d80db47db66b26cb386a336f597c053adf3a8a1e17ebeab9663aa/llvmlite-0.23.0-cp27-cp27m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "cfc7ee6e33db7fcac85d10fdb658eebf", + "sha256": "6d4584dba808b6cfa0517f4167b56c1505b0715c2139c47201ab6e08ab48ac35" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp35-cp35m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "cfc7ee6e33db7fcac85d10fdb658eebf", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 12486000, + "upload_time": "2018-04-25T15:33:40", + "upload_time_iso_8601": "2018-04-25T15:33:40.584506Z", + "url": "https://files.pythonhosted.org/packages/cd/80/9f6594d6241a1a0ffb907de557f3b1614e72a93ad70db71e647f033f20ea/llvmlite-0.23.0-cp35-cp35m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "e1d230817eeefa74e43a73cd47656273", + "sha256": "be973eb55e87c779a3abb2eca42a8a034347f9df7d7966991ea2768c0477d540" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "e1d230817eeefa74e43a73cd47656273", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 15921588, + "upload_time": "2018-04-25T15:33:45", + "upload_time_iso_8601": "2018-04-25T15:33:45.488504Z", + "url": "https://files.pythonhosted.org/packages/5d/35/3546be9ea8ef03b18b840c14d4b41314840407f0a403863e5156e1d8ad70/llvmlite-0.23.0-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "947dbde1ff31cdfc7326dc733fbe2afd", + "sha256": "ee49079e14742423703e3eaeae4f89187ef436dd6111d82030d8897c50281330" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "947dbde1ff31cdfc7326dc733fbe2afd", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 15821399, + "upload_time": "2018-04-25T15:33:49", + "upload_time_iso_8601": "2018-04-25T15:33:49.951752Z", + "url": "https://files.pythonhosted.org/packages/b3/3c/2f51604acb87fbfdbe98b2607b2417aabd8ccf2e474bf3744c028621e7b8/llvmlite-0.23.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "8e8336db84be76f66920b9a469500398", + "sha256": "3d274b6d3bb17a9df37131121eb117d690f23574e93aef33a2a5f7b277d76175" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp35-cp35m-win32.whl", + "has_sig": false, + "md5_digest": "8e8336db84be76f66920b9a469500398", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 8254673, + "upload_time": "2018-04-25T15:33:53", + "upload_time_iso_8601": "2018-04-25T15:33:53.777289Z", + "url": "https://files.pythonhosted.org/packages/ee/89/15685489229961ff2643c7007c27c7b0499fed31f8c7c5bd40da3025c2ab/llvmlite-0.23.0-cp35-cp35m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7d7b0df124568d277a6ddff064f878ef", + "sha256": "223024b97c74c4878bc61818172c1d0dd950a8cad156da1147ab17770e78e4fb" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp35-cp35m-win_amd64.whl", + "has_sig": false, + "md5_digest": "7d7b0df124568d277a6ddff064f878ef", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 10596563, + "upload_time": "2018-04-25T15:33:56", + "upload_time_iso_8601": "2018-04-25T15:33:56.932535Z", + "url": "https://files.pythonhosted.org/packages/3d/c6/15ef324b00071d2a4e7fb8518763fa867657c4d0d0dc623367d83dd25b0e/llvmlite-0.23.0-cp35-cp35m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c6e73a331088caf1d1635b747b4d954c", + "sha256": "5649fe44492df3c3fdc4c65f9cba3e6638df19519da45dec5c4b2dfca891a7e4" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp36-cp36m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "c6e73a331088caf1d1635b747b4d954c", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 12486000, + "upload_time": "2018-04-25T15:34:00", + "upload_time_iso_8601": "2018-04-25T15:34:00.798450Z", + "url": "https://files.pythonhosted.org/packages/8f/17/8c44a774530b04ba43c21db25e81c37047a4ad31de8b33396963cc373cda/llvmlite-0.23.0-cp36-cp36m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c063eadfd551a583a082c922f5422ec8", + "sha256": "94d8b513dd3c667169403b331cbd6d25580ff28bfbe60735f3094238a44f939a" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "c063eadfd551a583a082c922f5422ec8", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 15921590, + "upload_time": "2018-04-25T15:34:05", + "upload_time_iso_8601": "2018-04-25T15:34:05.413975Z", + "url": "https://files.pythonhosted.org/packages/93/e2/ce64a0d41dbaceae2a1850df7d30345057780e8739cc74f4546755da486d/llvmlite-0.23.0-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "219e054a0b001f552fc62a459da0fa04", + "sha256": "bb13c1e4666c76b38a044b745995957b8ba965a3333ce4086ff1090f6662d16f" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "219e054a0b001f552fc62a459da0fa04", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 15821398, + "upload_time": "2018-04-25T15:34:12", + "upload_time_iso_8601": "2018-04-25T15:34:12.761563Z", + "url": "https://files.pythonhosted.org/packages/4c/71/9ac956af0bc8e6624db7ff1653426a4d3f2fcb72bc6707f022158e62b64f/llvmlite-0.23.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "ac809951f66457e51dc3d09f426b1a38", + "sha256": "04933689de8a867df4ecfb892417fae14f183973707e086b340f7e306d379557" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp36-cp36m-win32.whl", + "has_sig": false, + "md5_digest": "ac809951f66457e51dc3d09f426b1a38", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 8254669, + "upload_time": "2018-04-25T15:34:16", + "upload_time_iso_8601": "2018-04-25T15:34:16.438141Z", + "url": "https://files.pythonhosted.org/packages/35/5d/3bf73268e0d80e5f0acb79576d91c520d0e1062d445265479ca977b89896/llvmlite-0.23.0-cp36-cp36m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "b330b72c0c7f18a653b226298b3a2c37", + "sha256": "01da159ba1a6a0da6462c4091fac3315c58900b05d1f3bd6d910451f7465ae04" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0-cp36-cp36m-win_amd64.whl", + "has_sig": false, + "md5_digest": "b330b72c0c7f18a653b226298b3a2c37", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 10596560, + "upload_time": "2018-04-25T15:34:21", + "upload_time_iso_8601": "2018-04-25T15:34:21.583793Z", + "url": "https://files.pythonhosted.org/packages/aa/ea/55e4d9bf95157a0814296b29151d45370927f6ac661f81656a937b20c4b8/llvmlite-0.23.0-cp36-cp36m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "6fc856576a11dbeef71de862f7c419de", + "sha256": "bc8b1b46274d05b578fe9e980a6d98fa71c8727f6f9ed31d4d8468dce7aa5762" + }, + "downloads": -1, + "filename": "llvmlite-0.23.0.tar.gz", + "has_sig": false, + "md5_digest": "6fc856576a11dbeef71de862f7c419de", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 98850, + "upload_time": "2018-04-25T02:34:09", + "upload_time_iso_8601": "2018-04-25T02:34:09.890957Z", + "url": "https://files.pythonhosted.org/packages/c6/0f/d33ec3d030d4de01ba251c7dcf1051cb9f558221d64421439a61b0d81020/llvmlite-0.23.0.tar.gz" + } + ], + "0.23.2": [ + { + "comment_text": "", + "digests": { + "md5": "270f492c5b942aebf123f42b609bc6a0", + "sha256": "cfbc15c487ebea93ed72018435aac074383c5f7025cc7663da1fc15d0e323bf9" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp27-cp27m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "270f492c5b942aebf123f42b609bc6a0", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 12486237, + "upload_time": "2018-06-01T20:03:26", + "upload_time_iso_8601": "2018-06-01T20:03:26.937272Z", + "url": "https://files.pythonhosted.org/packages/d5/c3/f640d8ff8e285725776a97fe17f9d7caaf55cf40863550169741f32dd297/llvmlite-0.23.2-cp27-cp27m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "612e9e6b785739882fc2fc5045b4cd6d", + "sha256": "11dd5ef3e377d3ef38a482a92f245867bfb963fcc1290b0b07609fcad0a6b4ab" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "612e9e6b785739882fc2fc5045b4cd6d", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 15921770, + "upload_time": "2018-06-01T20:03:40", + "upload_time_iso_8601": "2018-06-01T20:03:40.269637Z", + "url": "https://files.pythonhosted.org/packages/55/60/b54b2af4832df4c45cc2a781e94dd1f70d96b02c20ff8fcaaa67dff0d269/llvmlite-0.23.2-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "8baf27ad78b2e893e2ce4b81535232fa", + "sha256": "9a601fbe6bd05b3d8c7919342071ee1c3aea270b05a19b80de7be73181e67401" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "8baf27ad78b2e893e2ce4b81535232fa", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 15821332, + "upload_time": "2018-06-01T20:03:45", + "upload_time_iso_8601": "2018-06-01T20:03:45.758421Z", + "url": "https://files.pythonhosted.org/packages/61/53/64df44dd638d4424d83079365f94592dfacc83149ff2b386bc72f9fa84f1/llvmlite-0.23.2-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "de25fe32a51282c42e90756df7d27c4e", + "sha256": "c73515eb1fc5950c75247a497f479eca0c53308e111d914c37650ae83e467abe" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp27-cp27m-win32.whl", + "has_sig": false, + "md5_digest": "de25fe32a51282c42e90756df7d27c4e", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 8253677, + "upload_time": "2018-06-01T20:03:31", + "upload_time_iso_8601": "2018-06-01T20:03:31.520420Z", + "url": "https://files.pythonhosted.org/packages/aa/72/bc2e54177d6b58ddad958a6176887e4dffe956fdd05241f8bfe442fafde8/llvmlite-0.23.2-cp27-cp27m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "8d71444d8d39d589fb111f3eebc17aa8", + "sha256": "de73b827a9889471c1ff2395933ed38a4e1926df8536a175ec83d8e6375cf20d" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp27-cp27m-win_amd64.whl", + "has_sig": false, + "md5_digest": "8d71444d8d39d589fb111f3eebc17aa8", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 10596327, + "upload_time": "2018-06-01T20:03:35", + "upload_time_iso_8601": "2018-06-01T20:03:35.450030Z", + "url": "https://files.pythonhosted.org/packages/8f/93/0d155ac97f7b5c3d261f249aae79b6314bb59dafa4758b2beaae4fd50b5b/llvmlite-0.23.2-cp27-cp27m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "5bf03eaa4764b6188ae5501185d6163a", + "sha256": "483be15369105ee8592022c5de78ad1c682d715075d1b8b7ad5c70282e79cc5d" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp35-cp35m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "5bf03eaa4764b6188ae5501185d6163a", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 12486196, + "upload_time": "2018-06-01T20:03:52", + "upload_time_iso_8601": "2018-06-01T20:03:52.802625Z", + "url": "https://files.pythonhosted.org/packages/fc/a5/4bd8436c7e7d258f49a8b0042ec02d53bd6becac3e61421a35d0f874ce26/llvmlite-0.23.2-cp35-cp35m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "231a41de32b46ecd329deccf817d8120", + "sha256": "d4c63c4d82516b2f67b026d6b9691947dc76d531f81d70e7a8b9617ad5d477b5" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "231a41de32b46ecd329deccf817d8120", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 15921765, + "upload_time": "2018-06-01T20:04:00", + "upload_time_iso_8601": "2018-06-01T20:04:00.831255Z", + "url": "https://files.pythonhosted.org/packages/bd/97/7cecfc16e535aaf63f0632b7d8ffc381bd6bbd0641a1da60b31f41fabba3/llvmlite-0.23.2-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f4aef470256d4ca142de8815dddef573", + "sha256": "b939b2a37089f92f6ac71dcffc6cf1cd116581a35274bb47523a830dd518d3bf" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "f4aef470256d4ca142de8815dddef573", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 15821335, + "upload_time": "2018-06-01T20:04:05", + "upload_time_iso_8601": "2018-06-01T20:04:05.889393Z", + "url": "https://files.pythonhosted.org/packages/16/8b/7bb059aa26c6144a40faf5a3e84bf3bc766856ba83c79828866437073077/llvmlite-0.23.2-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "bc441ef8e64266effce4606b6dc7aea1", + "sha256": "da0dd46a96f7b0c4b440b7d06960ff8cd196d91e6487385ad41f522d44dc7a73" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp35-cp35m-win32.whl", + "has_sig": false, + "md5_digest": "bc441ef8e64266effce4606b6dc7aea1", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 8253619, + "upload_time": "2018-06-01T20:04:10", + "upload_time_iso_8601": "2018-06-01T20:04:10.349714Z", + "url": "https://files.pythonhosted.org/packages/ab/28/93d30dbc8b0a396580d6a29bcfabef3b6c42f0b3e29f1ab59fc0b2e1e9a2/llvmlite-0.23.2-cp35-cp35m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "b31bc815e98aaf389392dfd639d91996", + "sha256": "6f45baffe41d85a29025908cd130b1138b948bec13c3b7f224d59fc9a60f8253" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp35-cp35m-win_amd64.whl", + "has_sig": false, + "md5_digest": "b31bc815e98aaf389392dfd639d91996", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 10596273, + "upload_time": "2018-06-01T20:04:14", + "upload_time_iso_8601": "2018-06-01T20:04:14.578227Z", + "url": "https://files.pythonhosted.org/packages/45/26/3188e8a446f95509c57eb942e716faf79952f40e66511b390a9d0e9b3288/llvmlite-0.23.2-cp35-cp35m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "ebe8e7caa314b0aa8380cbe83dd92766", + "sha256": "e488a350b9c988cd369c633a489055a30a555c44008be7b9e518f62239b3d64c" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp36-cp36m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "ebe8e7caa314b0aa8380cbe83dd92766", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 12486195, + "upload_time": "2018-06-01T20:04:18", + "upload_time_iso_8601": "2018-06-01T20:04:18.936786Z", + "url": "https://files.pythonhosted.org/packages/c5/90/0a0e93abc2b431fd15fa9b3d38b9b0ec070650f3cab8bbc85e867e01c328/llvmlite-0.23.2-cp36-cp36m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "9cc21a3c503dcb49f5e26c9e914e0837", + "sha256": "c5c403094493cb74f957b33b264d84dd1cfe69d60d07bbf96e1bd74631fa0596" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "9cc21a3c503dcb49f5e26c9e914e0837", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 15921768, + "upload_time": "2018-06-01T20:04:24", + "upload_time_iso_8601": "2018-06-01T20:04:24.567614Z", + "url": "https://files.pythonhosted.org/packages/c1/6f/4849a4c5e2163df19b3e87c0180653a2038c1b2667b1f80dfe511c3be065/llvmlite-0.23.2-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7bceda60c7e41b6a1b2905b27cddfbee", + "sha256": "265687c51d56f3b997f55fc4ec7196049b0ae5ff0f8bc9c838f132d89708faa6" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "7bceda60c7e41b6a1b2905b27cddfbee", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 15821303, + "upload_time": "2018-06-01T20:04:29", + "upload_time_iso_8601": "2018-06-01T20:04:29.467683Z", + "url": "https://files.pythonhosted.org/packages/21/c7/eb581bbbdf731f24a72eba505cf42668231c595ba61997a6fa186b7f0413/llvmlite-0.23.2-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "92cfaab4b17ed2414a7235760ba6460c", + "sha256": "16e20da2ab35f27b1f0969454f69586818531e2d669569f3d364ee13823e34a2" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp36-cp36m-win32.whl", + "has_sig": false, + "md5_digest": "92cfaab4b17ed2414a7235760ba6460c", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 8253616, + "upload_time": "2018-06-01T20:04:33", + "upload_time_iso_8601": "2018-06-01T20:04:33.055124Z", + "url": "https://files.pythonhosted.org/packages/15/fe/4956bf036d7e7637df53cb6dc0b62d62a1ca7c74842434e0055f2ab137e8/llvmlite-0.23.2-cp36-cp36m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "538f54a4a52cf26e3f11ecf922952770", + "sha256": "f547b562092b32d94afcd4e4f0af3e1f6f1fd785eb3b858da3b8eef792f1993a" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2-cp36-cp36m-win_amd64.whl", + "has_sig": false, + "md5_digest": "538f54a4a52cf26e3f11ecf922952770", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 10596271, + "upload_time": "2018-06-01T20:04:37", + "upload_time_iso_8601": "2018-06-01T20:04:37.557288Z", + "url": "https://files.pythonhosted.org/packages/b1/e7/1df07eb3500f91e4e4b57b5abb0555623265e82d963c17db6addfe7fed58/llvmlite-0.23.2-cp36-cp36m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c51220fc41cd30f534bb8fa3714549ed", + "sha256": "1e63f317b8fb3679d3a397920b1e8bade2d5f471f6c60c7e9bf97746f616f79e" + }, + "downloads": -1, + "filename": "llvmlite-0.23.2.tar.gz", + "has_sig": false, + "md5_digest": "c51220fc41cd30f534bb8fa3714549ed", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 99370, + "upload_time": "2018-06-01T20:10:21", + "upload_time_iso_8601": "2018-06-01T20:10:21.556285Z", + "url": "https://files.pythonhosted.org/packages/be/d3/005c0fe065b39141dd40d5af30d25e99fa37f84022a2c45deb2da98783d7/llvmlite-0.23.2.tar.gz" + } + ], + "0.24.0": [ + { + "comment_text": "", + "digests": { + "md5": "1149007c7d8bb755c578228e5b179366", + "sha256": "c7f74d94349ba852704a3eba695e0086c000ae7e713fb81065eb555471d4b67c" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp27-cp27m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "1149007c7d8bb755c578228e5b179366", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 12490521, + "upload_time": "2018-07-10T14:51:21", + "upload_time_iso_8601": "2018-07-10T14:51:21.145676Z", + "url": "https://files.pythonhosted.org/packages/70/d3/6f294bebec2c6b6821d9daf6c45f01b42fa4b33f1d5ccf1014b478664a21/llvmlite-0.24.0-cp27-cp27m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "ae7d305d36d315a927dc04bd327bb62a", + "sha256": "31000d019db84976a3cd9649102ef2b4713c3c65c2f83fb7e981b196f62761e8" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "ae7d305d36d315a927dc04bd327bb62a", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 16078191, + "upload_time": "2018-07-10T14:51:35", + "upload_time_iso_8601": "2018-07-10T14:51:35.082430Z", + "url": "https://files.pythonhosted.org/packages/cb/61/c96873fe9fedeb96d656d9c47a72402d9f1269a7e0b3befc96d2e1a2e2c3/llvmlite-0.24.0-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "dcc50c7ea18daba76856f3de1a795be2", + "sha256": "3e6ba641abb4af80bb5d4a072a3510dc953218ecb5218eae9c994996c5f9c6e8" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "dcc50c7ea18daba76856f3de1a795be2", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 15842762, + "upload_time": "2018-07-10T14:51:40", + "upload_time_iso_8601": "2018-07-10T14:51:40.650341Z", + "url": "https://files.pythonhosted.org/packages/60/87/029b28ad25e097c525e4546530cb0212ecb7405cc024d0614af3a193ca7c/llvmlite-0.24.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "ebde129eda1607a791c6b991ca645832", + "sha256": "23d31542ec7b442439e4df428fa0c12d12bec3e8ac5b3bad49f54b0d6f344c25" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp27-cp27m-win32.whl", + "has_sig": false, + "md5_digest": "ebde129eda1607a791c6b991ca645832", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 8255376, + "upload_time": "2018-07-10T14:51:25", + "upload_time_iso_8601": "2018-07-10T14:51:25.492378Z", + "url": "https://files.pythonhosted.org/packages/37/f6/577f412e6c8eebdef7db9e1c57d6619804aac1f5bf87198a4113d2e885b8/llvmlite-0.24.0-cp27-cp27m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "338a9387515ec6ed0a6017daff6610ba", + "sha256": "59372eb3b710e3c05936e42b8bb1d0ef3481da26e097d0a6c6a049733f3c8a99" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp27-cp27m-win_amd64.whl", + "has_sig": false, + "md5_digest": "338a9387515ec6ed0a6017daff6610ba", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 10594475, + "upload_time": "2018-07-10T14:51:29", + "upload_time_iso_8601": "2018-07-10T14:51:29.566964Z", + "url": "https://files.pythonhosted.org/packages/f0/96/14495fa2d61a9f64b192b0f064914b8ed135bc3d5075d9068fa3a87411dc/llvmlite-0.24.0-cp27-cp27m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "d1a5edc5152ffdb03d0ddab854df160a", + "sha256": "7da3e0c5d09aad2ccec32e256b37ea2d5ce557a9b98c4ec00ad80f1770db7659" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp35-cp35m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "d1a5edc5152ffdb03d0ddab854df160a", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 12490559, + "upload_time": "2018-07-10T14:51:45", + "upload_time_iso_8601": "2018-07-10T14:51:45.828433Z", + "url": "https://files.pythonhosted.org/packages/35/47/53e4e4663f53737dca6d3ec541746207233a45ab9a66070dd68e8736e019/llvmlite-0.24.0-cp35-cp35m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "296e7d85aecfd32ba4a5475c069259f8", + "sha256": "ea1f94a13f6e9e6c3c6adb2edfd1158d47e85b938632e23808c9f8d35b962c8c" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "296e7d85aecfd32ba4a5475c069259f8", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 16078159, + "upload_time": "2018-07-10T14:51:50", + "upload_time_iso_8601": "2018-07-10T14:51:50.533467Z", + "url": "https://files.pythonhosted.org/packages/cf/ef/4c32e5f0491d88da1a4a599d70d1af4119d84f3492692451a286833d1d20/llvmlite-0.24.0-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "aa35eec2bd412377fb0e33830f4617cf", + "sha256": "d277d24e881d557b7b720abd76cbfec10787e447653069ac9202ff1ecf68c9bb" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "aa35eec2bd412377fb0e33830f4617cf", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 15842701, + "upload_time": "2018-07-10T14:51:54", + "upload_time_iso_8601": "2018-07-10T14:51:54.674598Z", + "url": "https://files.pythonhosted.org/packages/92/fd/181b9ecf9591ded90bb3022027de76fd5abea0505d4003b5c22bfb8e388c/llvmlite-0.24.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "d04b83b14bcfd5284fdc64cbe47ae329", + "sha256": "8817e023b86d840550669e35213917431ee8f16066a82ce59ad9c7f116375127" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp35-cp35m-win32.whl", + "has_sig": false, + "md5_digest": "d04b83b14bcfd5284fdc64cbe47ae329", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 8255295, + "upload_time": "2018-07-10T14:51:58", + "upload_time_iso_8601": "2018-07-10T14:51:58.343228Z", + "url": "https://files.pythonhosted.org/packages/c3/9f/0e958d5d61c22d11cbcd897ad60aa3de8d7cd49ca54ca086ad750e95325d/llvmlite-0.24.0-cp35-cp35m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "fc74bc7acca2146c128cfa7059c904f5", + "sha256": "d5f24ae1210575d832fabab04b198d11a1cff45781f5fd87301216551f43ce01" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp35-cp35m-win_amd64.whl", + "has_sig": false, + "md5_digest": "fc74bc7acca2146c128cfa7059c904f5", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 10594396, + "upload_time": "2018-07-10T14:52:01", + "upload_time_iso_8601": "2018-07-10T14:52:01.990789Z", + "url": "https://files.pythonhosted.org/packages/0b/7b/0ed27a8429d674ec82631f71d3896f23dd0caa87d5313bcb4535c58d7ab1/llvmlite-0.24.0-cp35-cp35m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "fbc92948d629f586cc0429c961be3dd6", + "sha256": "39264af5113cf55f6fb4981dfd672a99a599d59ed38b682a95e4e8be1f256f25" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp36-cp36m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "fbc92948d629f586cc0429c961be3dd6", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 12490570, + "upload_time": "2018-07-10T14:52:07", + "upload_time_iso_8601": "2018-07-10T14:52:07.098001Z", + "url": "https://files.pythonhosted.org/packages/e7/ee/9e827a16b0f168b4e2da3efc8e3798fc3e4139f3196dafdf127b052c683d/llvmlite-0.24.0-cp36-cp36m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7f01f1e9554fdc97d8a7e6000377f21b", + "sha256": "0c48be698f4303d8ff7966e41270cd392c2ef1e681ef69fb3f3fb03750285704" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "7f01f1e9554fdc97d8a7e6000377f21b", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 16078167, + "upload_time": "2018-07-10T14:52:12", + "upload_time_iso_8601": "2018-07-10T14:52:12.108306Z", + "url": "https://files.pythonhosted.org/packages/20/8b/377671d67465b6f1b11ee452baced12dae95e2f69bcb0a31048493b5c6eb/llvmlite-0.24.0-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "272ebbb8467acee609f61431e1a7d3ed", + "sha256": "951acf91f4f263cf528b6c438ac2d9d127b171dea01cc2973866b8b61426fa2e" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "272ebbb8467acee609f61431e1a7d3ed", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 15842684, + "upload_time": "2018-07-10T14:52:16", + "upload_time_iso_8601": "2018-07-10T14:52:16.991367Z", + "url": "https://files.pythonhosted.org/packages/be/05/c1b933d6b3dd6a234b681605e4154c44d21ee22cbef315c4eb9d64e6ab6a/llvmlite-0.24.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "9b35e5894fea20931b73d20e6b7d7c7b", + "sha256": "1dc531d45a5e3938d8b7cccf48379a392b6c5353fa26e3f994805ede83e00d87" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp36-cp36m-win32.whl", + "has_sig": false, + "md5_digest": "9b35e5894fea20931b73d20e6b7d7c7b", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 8255293, + "upload_time": "2018-07-10T14:52:20", + "upload_time_iso_8601": "2018-07-10T14:52:20.815794Z", + "url": "https://files.pythonhosted.org/packages/fe/d2/154c3e03809c5ac5d3c4442bf5759c12fd3fbadd109ed6a954cb4146988e/llvmlite-0.24.0-cp36-cp36m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "07076254f1d305c605f0476f95b6c1e5", + "sha256": "95fe4be10bf2a95622cbd98d80b92e3fc2e2504ea877dca83e54594c2b33a0ab" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp36-cp36m-win_amd64.whl", + "has_sig": false, + "md5_digest": "07076254f1d305c605f0476f95b6c1e5", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 10594398, + "upload_time": "2018-07-10T14:52:24", + "upload_time_iso_8601": "2018-07-10T14:52:24.582539Z", + "url": "https://files.pythonhosted.org/packages/b5/ab/e2e937e62c8be492ed1f30c5a80837b68a5d938bb88a39310d496d3cf6c7/llvmlite-0.24.0-cp36-cp36m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "3ee9ac078b6e9a0342de8e19a612e460", + "sha256": "809de4c7b46036c4da4c859b41b8986955d1a81d382efbfd6058a140165df4eb" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp37-cp37m-macosx_10_7_x86_64.whl", + "has_sig": false, + "md5_digest": "3ee9ac078b6e9a0342de8e19a612e460", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 12775086, + "upload_time": "2018-07-16T17:05:33", + "upload_time_iso_8601": "2018-07-16T17:05:33.023392Z", + "url": "https://files.pythonhosted.org/packages/6d/75/ba64821b218af30ed2b09b1705fe87c98fc6fb84380f5317de1d60001d00/llvmlite-0.24.0-cp37-cp37m-macosx_10_7_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "d3bf4e13dd4ceb8e7c263a98178e7ec7", + "sha256": "375579c3af61cface2e3ffa4ee30daed67e290efad5d8beeff3c717413382f50" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp37-cp37m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "d3bf4e13dd4ceb8e7c263a98178e7ec7", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 16078063, + "upload_time": "2018-07-16T17:05:38", + "upload_time_iso_8601": "2018-07-16T17:05:38.036655Z", + "url": "https://files.pythonhosted.org/packages/cb/44/5817610f0769398d32756860f89f8995d80bf0148cebfe731e8ce889004f/llvmlite-0.24.0-cp37-cp37m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f438a3cbc86b8ce05605af71910d58e6", + "sha256": "0358ffed8754b706584adb7c2f8669160e631192bbd379753c39439a5fb7fc36" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp37-cp37m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "f438a3cbc86b8ce05605af71910d58e6", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 15842902, + "upload_time": "2018-07-16T17:05:43", + "upload_time_iso_8601": "2018-07-16T17:05:43.604861Z", + "url": "https://files.pythonhosted.org/packages/a6/75/8460903124de229eeb0e313863ee669202d1f5df2d176526f8caf436f740/llvmlite-0.24.0-cp37-cp37m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c789a64c0a457842169087cffe2d1270", + "sha256": "27fb7f2335bc9f32be68f3f2b77ebb62f40764234df02e9a4fe0e725cf3ef3b1" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp37-cp37m-win32.whl", + "has_sig": false, + "md5_digest": "c789a64c0a457842169087cffe2d1270", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 8255297, + "upload_time": "2018-07-16T17:05:47", + "upload_time_iso_8601": "2018-07-16T17:05:47.893600Z", + "url": "https://files.pythonhosted.org/packages/90/cf/972f445268903b0e8d1208189769d6fa6c7b811af7456bff94f5ed9db98e/llvmlite-0.24.0-cp37-cp37m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "43ea342689067ae83f70b593a57504ad", + "sha256": "acf2c6f7728ce67002da91f8b56580b21799d235aef6643724ec22a9cb3d03f8" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0-cp37-cp37m-win_amd64.whl", + "has_sig": false, + "md5_digest": "43ea342689067ae83f70b593a57504ad", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 10594398, + "upload_time": "2018-07-16T17:05:51", + "upload_time_iso_8601": "2018-07-16T17:05:51.663124Z", + "url": "https://files.pythonhosted.org/packages/ce/d5/9958e4e1bb98536f8b311616666c61bb652d9e405d0281e54a2303f2dc05/llvmlite-0.24.0-cp37-cp37m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "d00d7f80fbf907a4b3bb5fdcc5a65362", + "sha256": "320de4c4a1c105b91629305be069d217f3a9d7fbe32cb22bcfb016361895fc07" + }, + "downloads": -1, + "filename": "llvmlite-0.24.0.tar.gz", + "has_sig": false, + "md5_digest": "d00d7f80fbf907a4b3bb5fdcc5a65362", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 100833, + "upload_time": "2018-07-10T14:51:02", + "upload_time_iso_8601": "2018-07-10T14:51:02.350788Z", + "url": "https://files.pythonhosted.org/packages/cb/ce/fbdc55bc81b86c55577aa035c8b441ede790c5ede6df2df45855a4176cfd/llvmlite-0.24.0.tar.gz" + } + ], + "0.25.0": [ + { + "comment_text": "", + "digests": { + "md5": "06ecc2a6378ac548455ddd115e8a41f3", + "sha256": "0ea68d4ab6a1fa73d919b17ab2f4909f4aa9a6730ba32a91c61db8c08626f408" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp27-cp27m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "06ecc2a6378ac548455ddd115e8a41f3", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 12491624, + "upload_time": "2018-09-21T19:29:26", + "upload_time_iso_8601": "2018-09-21T19:29:26.746694Z", + "url": "https://files.pythonhosted.org/packages/c9/fe/d892851e35fb4b93e4082ff0f9b226c6dcce4c0520cae5b8d914c8ae2f49/llvmlite-0.25.0-cp27-cp27m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "28324cfc43e4cb1f8140d6bcf96f9567", + "sha256": "f35c1b9d3efdcf54a1b0599c72995e66e1e4033bf08d13ab450011f0f3ca78a2" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "28324cfc43e4cb1f8140d6bcf96f9567", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 16339660, + "upload_time": "2018-09-21T19:29:38", + "upload_time_iso_8601": "2018-09-21T19:29:38.505698Z", + "url": "https://files.pythonhosted.org/packages/08/b2/8375fd1f49a084fb1b3f448fe8924baa6e8ae0fd5bc64428980a580863ec/llvmlite-0.25.0-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "57aaa45ed549fce885eecd7177e2bb70", + "sha256": "f54bbd9e73fabd13b208b71a14a8e4d83400fc59cc5eb3bceeff1a7352a23f2f" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "57aaa45ed549fce885eecd7177e2bb70", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 16099165, + "upload_time": "2018-09-21T19:29:43", + "upload_time_iso_8601": "2018-09-21T19:29:43.452875Z", + "url": "https://files.pythonhosted.org/packages/03/cd/a29f3a1964c3a4198c44390516ac6e29115911104219ba7a8c7e924e818e/llvmlite-0.25.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "79b3fb6d2164b5c7d6e309c232b7c09e", + "sha256": "d8702b8825349b090f51c358cd1e5f9631865bdab4e9e13bfce1ac7c82e44cfe" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp27-cp27m-win32.whl", + "has_sig": false, + "md5_digest": "79b3fb6d2164b5c7d6e309c232b7c09e", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 8258039, + "upload_time": "2018-09-21T19:29:30", + "upload_time_iso_8601": "2018-09-21T19:29:30.574431Z", + "url": "https://files.pythonhosted.org/packages/dc/2a/cd302bb76432ac947d2949ef566a5d3201fd7cbf4447a649b4389486d775/llvmlite-0.25.0-cp27-cp27m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "6a8885d9f4e5e54853148cf9a7d1a17d", + "sha256": "9b1c41413bf5d709c8bd3621e075e19dd9170cb08cbf95319d6cbd28ca2d84ed" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp27-cp27m-win_amd64.whl", + "has_sig": false, + "md5_digest": "6a8885d9f4e5e54853148cf9a7d1a17d", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 10598453, + "upload_time": "2018-09-21T19:29:33", + "upload_time_iso_8601": "2018-09-21T19:29:33.976650Z", + "url": "https://files.pythonhosted.org/packages/3f/d6/4d8c24211a71bd4b302d5835c3503661db33070500b4f0705900302fb7f8/llvmlite-0.25.0-cp27-cp27m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "14bc22daa3b2bce11554660144911327", + "sha256": "3a0e5a5c9aa56ca506b576ef6ca6e6c37306a483baf951034dc357cb34beb7c7" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp35-cp35m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "14bc22daa3b2bce11554660144911327", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 12491582, + "upload_time": "2018-09-21T19:29:47", + "upload_time_iso_8601": "2018-09-21T19:29:47.885652Z", + "url": "https://files.pythonhosted.org/packages/ab/b0/3cddb34355711f8009b174f627a5096f1ab4e99624c67687468921dff5fa/llvmlite-0.25.0-cp35-cp35m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f7dd6717b9a54fdba204712db58ae4bc", + "sha256": "e866935bc1236478fe09c741313b1ed322ab34343ef226aa34f75ce80e5188ef" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "f7dd6717b9a54fdba204712db58ae4bc", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 16339632, + "upload_time": "2018-09-21T19:29:52", + "upload_time_iso_8601": "2018-09-21T19:29:52.736737Z", + "url": "https://files.pythonhosted.org/packages/a1/cd/d374ca5abffd9fd704612a4542e9812a1430e9dab621a7b024e95a1667fe/llvmlite-0.25.0-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "a160e08b30e1efd99d67e3ba7bc1453d", + "sha256": "c7f6e7078b1830c8fb15f340af4da5692d53a6590eff03c0afa7e69857ac37c0" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "a160e08b30e1efd99d67e3ba7bc1453d", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 16099099, + "upload_time": "2018-09-21T19:29:57", + "upload_time_iso_8601": "2018-09-21T19:29:57.346151Z", + "url": "https://files.pythonhosted.org/packages/c5/e6/9e0384bd16bacb94db48c65f995317715539befb9dbf409832573cb732dd/llvmlite-0.25.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "0ae147c646c561255eeb02f2b4b7d0cf", + "sha256": "696ce74ac7060eba4f8b3cb6122bb8aff5d30a6ddc872b519dcb3ed201c42af2" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp35-cp35m-win32.whl", + "has_sig": false, + "md5_digest": "0ae147c646c561255eeb02f2b4b7d0cf", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 8257955, + "upload_time": "2018-09-21T19:30:00", + "upload_time_iso_8601": "2018-09-21T19:30:00.714761Z", + "url": "https://files.pythonhosted.org/packages/72/37/cf6e179b34ddc0e2c195af228eb194f233f2b17c8950c4e6dd38f0762934/llvmlite-0.25.0-cp35-cp35m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c17e8182c9ecce7e2996d06b92ffdf3f", + "sha256": "2bb68dbe572b021b238677729ed77dc2bda396acf6ede00373bb24124e282383" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp35-cp35m-win_amd64.whl", + "has_sig": false, + "md5_digest": "c17e8182c9ecce7e2996d06b92ffdf3f", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 10598376, + "upload_time": "2018-09-21T19:30:04", + "upload_time_iso_8601": "2018-09-21T19:30:04.426389Z", + "url": "https://files.pythonhosted.org/packages/4a/12/ee5ed479d8e847734ee7fabda5c5c7c5a59b674e76af044af9d97521fc0c/llvmlite-0.25.0-cp35-cp35m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "cf94ba86dfa58ac1a27203d2bea6a2a5", + "sha256": "152e1ac25c57d3d686128a8ee899762be95d2bb1418d7b776c55b83c9591cc44" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp36-cp36m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "cf94ba86dfa58ac1a27203d2bea6a2a5", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 12491582, + "upload_time": "2018-09-21T19:30:08", + "upload_time_iso_8601": "2018-09-21T19:30:08.843781Z", + "url": "https://files.pythonhosted.org/packages/ab/76/4c0556b7be358beafd21992f430c0a36de591f875cbb100a3eb223375474/llvmlite-0.25.0-cp36-cp36m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "3bac846469d22798d61d407bb1f687d0", + "sha256": "276f6585a7a962d86f0751cc3016afa45c0ba86190e1ebd7b43071507ff18967" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "3bac846469d22798d61d407bb1f687d0", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 16339621, + "upload_time": "2018-09-21T19:30:13", + "upload_time_iso_8601": "2018-09-21T19:30:13.745817Z", + "url": "https://files.pythonhosted.org/packages/90/68/3a7b52827e749b7b2dcfe73ecb51261cd7d2b91873b54478b719a7be28b9/llvmlite-0.25.0-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "491821f6784db79532a4720ac54883e9", + "sha256": "950f44f2b33f04c91417b9846271decc66adfaa16849ca3522a4c51e0037a022" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "491821f6784db79532a4720ac54883e9", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 16099096, + "upload_time": "2018-09-21T19:30:18", + "upload_time_iso_8601": "2018-09-21T19:30:18.515561Z", + "url": "https://files.pythonhosted.org/packages/34/fb/f9c2e9e0ef2b54c52f0b727cf6af75b68c3d7ddb6d88c8d557b1b16bc1ab/llvmlite-0.25.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1fe9518cdf9ed3b5c115be89461f75f8", + "sha256": "7a249ec0a3731e789fdffe9772f2ae62303b47554b7e5109360d7fa77be0cb76" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp36-cp36m-win32.whl", + "has_sig": false, + "md5_digest": "1fe9518cdf9ed3b5c115be89461f75f8", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 8257961, + "upload_time": "2018-09-21T19:30:22", + "upload_time_iso_8601": "2018-09-21T19:30:22.584515Z", + "url": "https://files.pythonhosted.org/packages/30/dc/eac7d7f113e8cb2e8d36ce9a77a39ac24b46b4d0d523737b72837f3152e1/llvmlite-0.25.0-cp36-cp36m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7979cc46614a192965ef1c9a7999bb1a", + "sha256": "b445c88e9677e427cc6dc49aa621691f04dbee1c888040413fba26711d0edc68" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp36-cp36m-win_amd64.whl", + "has_sig": false, + "md5_digest": "7979cc46614a192965ef1c9a7999bb1a", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 10598375, + "upload_time": "2018-09-21T19:30:26", + "upload_time_iso_8601": "2018-09-21T19:30:26.513781Z", + "url": "https://files.pythonhosted.org/packages/04/fb/eabd824250e618c9ad478342304596af510ab5f8e68932c02b13ced45e04/llvmlite-0.25.0-cp36-cp36m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "2acc0415869fe02c3e002f71d4776586", + "sha256": "05b817a961fa0aacfccc5ecaa2e6fbc826c8988759a6d25243916e74c2082d3e" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp37-cp37m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "2acc0415869fe02c3e002f71d4776586", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 12491582, + "upload_time": "2018-09-21T19:30:31", + "upload_time_iso_8601": "2018-09-21T19:30:31.069887Z", + "url": "https://files.pythonhosted.org/packages/0e/89/4ea09305315dda941118f037fbe719ac0078044c414bb147e98466db9958/llvmlite-0.25.0-cp37-cp37m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "4aeb94eec3f58d580bb5bfff6311954c", + "sha256": "b36854919a9b13408d7523e4327a04afc62ce880564466f9f79f506d560b70ff" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp37-cp37m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "4aeb94eec3f58d580bb5bfff6311954c", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 16339613, + "upload_time": "2018-09-21T19:30:35", + "upload_time_iso_8601": "2018-09-21T19:30:35.542077Z", + "url": "https://files.pythonhosted.org/packages/09/3a/bb995ef06735d190b7d8182dc5647f0475fb41b9e5e807313f61162e8f48/llvmlite-0.25.0-cp37-cp37m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "e74c6340bc7520ee0c16737dcb7c1185", + "sha256": "c27fedc3cd6869c222a36cd7b1db8906bb209a8b7b1cd6e84174e8e53e51c23d" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp37-cp37m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "e74c6340bc7520ee0c16737dcb7c1185", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 16099106, + "upload_time": "2018-09-21T19:30:40", + "upload_time_iso_8601": "2018-09-21T19:30:40.124960Z", + "url": "https://files.pythonhosted.org/packages/5b/66/3c1ddc89e87f50b4f379443ac352321f11b735becba2ba1a9e1bfd5c43e5/llvmlite-0.25.0-cp37-cp37m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "07686832e3f31b9d843c09b0c1a0dc5e", + "sha256": "964d76903e8298ae3446319d12183dcf64722bdc9deb66159fa97ef68986594b" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp37-cp37m-win32.whl", + "has_sig": false, + "md5_digest": "07686832e3f31b9d843c09b0c1a0dc5e", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 8257957, + "upload_time": "2018-09-21T19:30:43", + "upload_time_iso_8601": "2018-09-21T19:30:43.571220Z", + "url": "https://files.pythonhosted.org/packages/47/2c/31c4fb1f14b024f1419a0db26f9a929102e4e92d1265a20ed840df5eb368/llvmlite-0.25.0-cp37-cp37m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "003e4915eb3a1f2b3f50c70fd7ff8991", + "sha256": "b19f69376799848e411fad5c079dedc6ac4aedb032f922b80dcf3ec368a59dc3" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0-cp37-cp37m-win_amd64.whl", + "has_sig": false, + "md5_digest": "003e4915eb3a1f2b3f50c70fd7ff8991", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 10598374, + "upload_time": "2018-09-21T19:30:46", + "upload_time_iso_8601": "2018-09-21T19:30:46.820861Z", + "url": "https://files.pythonhosted.org/packages/cd/7a/c1b5bccc1f4d6c51dd6cf62d1cfccdebe82a41aa4fca5837902f465f548a/llvmlite-0.25.0-cp37-cp37m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1e3d823b5774807272deaf95b85df5a9", + "sha256": "fd64def9a51dd7dc61913a7a08eeba5b9785522740bec5a7c5995b2a90525025" + }, + "downloads": -1, + "filename": "llvmlite-0.25.0.tar.gz", + "has_sig": false, + "md5_digest": "1e3d823b5774807272deaf95b85df5a9", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 102079, + "upload_time": "2018-09-21T19:32:46", + "upload_time_iso_8601": "2018-09-21T19:32:46.617861Z", + "url": "https://files.pythonhosted.org/packages/5e/6c/4711620ae28b8aaa8d731e519ead648359d71c1de0c709e408671236b23a/llvmlite-0.25.0.tar.gz" + } + ], + "0.26.0": [ + { + "comment_text": "", + "digests": { + "md5": "c6c2de8dde63ea87f6fdb126f27af692", + "sha256": "cab1f4e4e84c22968eb959a24708a2dd29c25cb10a696eabda21cea8d84ca146" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp27-cp27m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "c6c2de8dde63ea87f6fdb126f27af692", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 12493557, + "upload_time": "2018-11-28T14:59:25", + "upload_time_iso_8601": "2018-11-28T14:59:25.266554Z", + "url": "https://files.pythonhosted.org/packages/c6/09/17535cad8112cbb06dbe3429914e729a958490b848acd7b5850394db8e1e/llvmlite-0.26.0-cp27-cp27m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "35f00d882a622b4f3f30047614d7dd5f", + "sha256": "02ef5d4070693f9bd5cc849ba281fffeecd74a0e774e685741992a2e184e28bd" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "35f00d882a622b4f3f30047614d7dd5f", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 16346339, + "upload_time": "2018-11-28T14:59:36", + "upload_time_iso_8601": "2018-11-28T14:59:36.027111Z", + "url": "https://files.pythonhosted.org/packages/4a/08/67a67a2ae8560489b32a9bde2f7cf62a8434bd8c24a576b7d99417d9c995/llvmlite-0.26.0-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "082c6ac03afb56c482645a9c86d0de34", + "sha256": "c2a96175f0e0fe385a79b103073017cff046357eccde1849885a4d5871839965" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "082c6ac03afb56c482645a9c86d0de34", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 16106249, + "upload_time": "2018-11-28T14:59:40", + "upload_time_iso_8601": "2018-11-28T14:59:40.440880Z", + "url": "https://files.pythonhosted.org/packages/3b/37/b1e09e5b16161ec27a5df3f87c7435bb046feefe6355696f6af3aea9e4ef/llvmlite-0.26.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "707dd686aabf857fa22e86d276d4a25a", + "sha256": "6bec9380dec3f56ab7f0b8ea2ccd09ce051e4d378489e95cd09778f1809adcfd" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp27-cp27m-win32.whl", + "has_sig": false, + "md5_digest": "707dd686aabf857fa22e86d276d4a25a", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 8258311, + "upload_time": "2018-11-28T14:59:28", + "upload_time_iso_8601": "2018-11-28T14:59:28.746161Z", + "url": "https://files.pythonhosted.org/packages/63/63/fad394c27d0db1d3c8e31783570f09961244a3d185bb47c56eceb019acaa/llvmlite-0.26.0-cp27-cp27m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "3bbac2e6918418715a1b40a69a0ffb16", + "sha256": "2438499c6a4c120b8562dc2a0376055ff6f3685cb0ea24a6e01e0991483ba974" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp27-cp27m-win_amd64.whl", + "has_sig": false, + "md5_digest": "3bbac2e6918418715a1b40a69a0ffb16", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 10600016, + "upload_time": "2018-11-28T14:59:31", + "upload_time_iso_8601": "2018-11-28T14:59:31.993547Z", + "url": "https://files.pythonhosted.org/packages/55/27/16175d784fedfa6b50f9e1f6ec957f6074b8fefa0ea5961f9d512f6f71bc/llvmlite-0.26.0-cp27-cp27m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "4971be3564799b5bf30e04ed0d739f6a", + "sha256": "1db76486373ed11df98f8641bcd95fe78e80aaef2e351013032bf33828067d11" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp35-cp35m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "4971be3564799b5bf30e04ed0d739f6a", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 12493517, + "upload_time": "2018-11-28T14:59:45", + "upload_time_iso_8601": "2018-11-28T14:59:45.081321Z", + "url": "https://files.pythonhosted.org/packages/33/a5/b8d25cbdfd94b5647f6107bb39802ce67afc098cc9cd9935f40415ff4def/llvmlite-0.26.0-cp35-cp35m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "bbfefc6f28910b2d0df533cb71cdaffa", + "sha256": "ad3b9d4e127d5b5f6993788732e9a4a6aa7a5451106c35eab61d7f3a63974c3d" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "bbfefc6f28910b2d0df533cb71cdaffa", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 16346282, + "upload_time": "2018-11-28T14:59:49", + "upload_time_iso_8601": "2018-11-28T14:59:49.315713Z", + "url": "https://files.pythonhosted.org/packages/50/24/749d11762a4e247d21e6bba0eecd1c0e2520a33359f3ed72fe4fdfddafe0/llvmlite-0.26.0-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "de1021bddcd46eee8b869920be5b4f29", + "sha256": "a4eff8ed50de51d88dd745bae24a74415915f128a250c01a22f12e6ff9e44be9" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "de1021bddcd46eee8b869920be5b4f29", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 16106184, + "upload_time": "2018-11-28T14:59:53", + "upload_time_iso_8601": "2018-11-28T14:59:53.952405Z", + "url": "https://files.pythonhosted.org/packages/f9/ad/17deffd4c88b1c50d57b97547e33ef652f27a561347b8441f01901a3014e/llvmlite-0.26.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7462224a578423bad8e450fadc206ee7", + "sha256": "8cc0278bef8ef70b487452ee8d15adf18412997018bf807370f128535fde80c0" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp35-cp35m-win32.whl", + "has_sig": false, + "md5_digest": "7462224a578423bad8e450fadc206ee7", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 8258235, + "upload_time": "2018-11-28T14:59:58", + "upload_time_iso_8601": "2018-11-28T14:59:58.959318Z", + "url": "https://files.pythonhosted.org/packages/c3/d4/803a6b5dd99ec22a5ce142dc99bf173cacf69ad6af0b84ea31387bd33c28/llvmlite-0.26.0-cp35-cp35m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1b2b0db17bb80c6c69b6e518dbdbd84e", + "sha256": "f1d1112f5fe9f5f3e03d74adf16ac436d7988af048949e27f9e10d3ea79e2596" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp35-cp35m-win_amd64.whl", + "has_sig": false, + "md5_digest": "1b2b0db17bb80c6c69b6e518dbdbd84e", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 10599940, + "upload_time": "2018-11-28T15:00:02", + "upload_time_iso_8601": "2018-11-28T15:00:02.930529Z", + "url": "https://files.pythonhosted.org/packages/df/e4/b976c30350e8e78ee52049c9a0990b2a47d77b8e6adb0b895ee29b6356fb/llvmlite-0.26.0-cp35-cp35m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "146cf125642c8d9de24acb5caec6fac3", + "sha256": "7861e89052f91d670050692e87459840179629978e3189aa2b6fb8685eace98c" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp36-cp36m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "146cf125642c8d9de24acb5caec6fac3", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 12493510, + "upload_time": "2018-11-28T15:00:06", + "upload_time_iso_8601": "2018-11-28T15:00:06.683540Z", + "url": "https://files.pythonhosted.org/packages/d7/05/be0997c6307063d3c8c788391a00b20a56a1b35c6859443383e12c85b061/llvmlite-0.26.0-cp36-cp36m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "e011cc563ecb0f125cdf2c432a4c7a68", + "sha256": "3554a558e5977bdbbc172c13b4055f24cb985f85557205fb44e231e96eeaddeb" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "e011cc563ecb0f125cdf2c432a4c7a68", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 16346283, + "upload_time": "2018-11-28T15:00:10", + "upload_time_iso_8601": "2018-11-28T15:00:10.921877Z", + "url": "https://files.pythonhosted.org/packages/f1/2e/d47a981c03e26789edd7a120d15163e7c55ca15cba701166a1a73dbe473b/llvmlite-0.26.0-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "54aca5f9f319710b56fc7563ee5bbf06", + "sha256": "24e7ba80a4dc4aa89d6f0062928d1b3dd4c6c3ff137d76909f57b89972b673ca" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "54aca5f9f319710b56fc7563ee5bbf06", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 16106209, + "upload_time": "2018-11-28T15:00:15", + "upload_time_iso_8601": "2018-11-28T15:00:15.233887Z", + "url": "https://files.pythonhosted.org/packages/a2/60/d22966c97a47687ac1cc57c2e756380897c264f1ce40780105d7dbcd9564/llvmlite-0.26.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "48d0b4adfd1a31fcc3e034541d6528e3", + "sha256": "4648e1511a2095ea0b1f43f624348f1fcc73d33581d3f7fdbfea6ead2ca05dba" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp36-cp36m-win32.whl", + "has_sig": false, + "md5_digest": "48d0b4adfd1a31fcc3e034541d6528e3", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 8258235, + "upload_time": "2018-11-28T15:00:18", + "upload_time_iso_8601": "2018-11-28T15:00:18.918778Z", + "url": "https://files.pythonhosted.org/packages/26/2c/fa68ad6c9ed3b40c4fa0ad3461f811028810f25349f2f79a079b3ec47c9e/llvmlite-0.26.0-cp36-cp36m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "2a262680172460239274f3648449445a", + "sha256": "1d28e0f10ac4222bd79a83914d2efc03e8d8d79b1c7246c83f30f66465c8963c" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp36-cp36m-win_amd64.whl", + "has_sig": false, + "md5_digest": "2a262680172460239274f3648449445a", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 10599939, + "upload_time": "2018-11-28T15:00:22", + "upload_time_iso_8601": "2018-11-28T15:00:22.521179Z", + "url": "https://files.pythonhosted.org/packages/5d/e4/ef71389eb6eb8da3a16f129f69237a68f76e1b725e40435cfdab42b6c7c3/llvmlite-0.26.0-cp36-cp36m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "bc18c6801a67d043728c696dd051bc77", + "sha256": "84e72bda0d397263ffdb1982a2b764c3f479e1302aa59f92fb636f2215d1fee0" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp37-cp37m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "bc18c6801a67d043728c696dd051bc77", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 12493515, + "upload_time": "2018-11-28T15:00:27", + "upload_time_iso_8601": "2018-11-28T15:00:27.192548Z", + "url": "https://files.pythonhosted.org/packages/84/9f/bce6b3ac48a53f2453fd56279e0db5965cc8d0a1bcc7de6a984ebd9ce2a5/llvmlite-0.26.0-cp37-cp37m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "adbdc57e3578cd3177e199d66b6870fe", + "sha256": "75b15a7568dcec83136f5ac80adff9e9c450f554995a3c43e7e1c4c766ad4c76" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp37-cp37m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "adbdc57e3578cd3177e199d66b6870fe", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 16346267, + "upload_time": "2018-11-28T15:00:31", + "upload_time_iso_8601": "2018-11-28T15:00:31.679083Z", + "url": "https://files.pythonhosted.org/packages/9a/36/8d647622548ea6208fdfe1e1491c6da6b5ecb268a20d5f6d878da30d9f0c/llvmlite-0.26.0-cp37-cp37m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "faf58969a5b4fcfc6a55d748dbde0568", + "sha256": "d209142c89fc83fc79674454ad5b861d5d62af6670d0694384502f7151b3ae8f" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp37-cp37m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "faf58969a5b4fcfc6a55d748dbde0568", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 16106214, + "upload_time": "2018-11-28T15:00:36", + "upload_time_iso_8601": "2018-11-28T15:00:36.142775Z", + "url": "https://files.pythonhosted.org/packages/b9/9f/f8756879c99434b6f716987e9073c4a0ed1d50d79c0c95155630e99fea2f/llvmlite-0.26.0-cp37-cp37m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "b16adad552b75f13bf82591e194dda1d", + "sha256": "cd0d530c72d423176f6ea4a2d7b098252bb4547ed2c7e09686ff3283878dbd0a" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp37-cp37m-win32.whl", + "has_sig": false, + "md5_digest": "b16adad552b75f13bf82591e194dda1d", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 8258235, + "upload_time": "2018-11-28T15:00:39", + "upload_time_iso_8601": "2018-11-28T15:00:39.627509Z", + "url": "https://files.pythonhosted.org/packages/90/11/3a786ffee141f9ae1f9d2c48cc9b3e6d681fd82af92124f2d9d68592978a/llvmlite-0.26.0-cp37-cp37m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c46965934170a506ba22696febff6d3d", + "sha256": "0468ebf4b4161c076e8fce07a313405034bd11abc7133947b647fd0a8059efa6" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0-cp37-cp37m-win_amd64.whl", + "has_sig": false, + "md5_digest": "c46965934170a506ba22696febff6d3d", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 10599937, + "upload_time": "2018-11-28T15:00:42", + "upload_time_iso_8601": "2018-11-28T15:00:42.949207Z", + "url": "https://files.pythonhosted.org/packages/91/cd/d5a605854e0325cd5e597f18a2f367e7e752751d1df2352619dad2f909c9/llvmlite-0.26.0-cp37-cp37m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "3f48aa764e3458c08b6237bc939ecdcd", + "sha256": "13e84fe6ebb0667233074b429fd44955f309dead3161ec89d9169145dbad2ebf" + }, + "downloads": -1, + "filename": "llvmlite-0.26.0.tar.gz", + "has_sig": false, + "md5_digest": "3f48aa764e3458c08b6237bc939ecdcd", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 103402, + "upload_time": "2018-11-28T14:59:13", + "upload_time_iso_8601": "2018-11-28T14:59:13.206665Z", + "url": "https://files.pythonhosted.org/packages/99/0e/78da3ea5777d61f0f61c38550d0d257f0ad24a7954ffbdaea991a161ad68/llvmlite-0.26.0.tar.gz" + } + ], + "0.27.0": [ + { + "comment_text": "", + "digests": { + "md5": "e133cc0fb17fb435e45299d622088760", + "sha256": "d85b50eb86b16f0f2232277edae3d520e22bc15f141c0cab41aede24a5ab63f7" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp27-cp27m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "e133cc0fb17fb435e45299d622088760", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 13151995, + "upload_time": "2018-12-31T19:21:53", + "upload_time_iso_8601": "2018-12-31T19:21:53.102104Z", + "url": "https://files.pythonhosted.org/packages/48/a6/3fd3f0dfc3462830ce2d5dcc2fcff020603417d5429902f04a31c5bc5c57/llvmlite-0.27.0-cp27-cp27m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "536aaa717eafcd9a01dfeac2f3d5dfa1", + "sha256": "cdc0c7441a46e49c0e68ec9ca247d2f140863bc63f5992900137ce1aca5a63e1" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "536aaa717eafcd9a01dfeac2f3d5dfa1", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 17189923, + "upload_time": "2018-12-31T19:22:14", + "upload_time_iso_8601": "2018-12-31T19:22:14.501566Z", + "url": "https://files.pythonhosted.org/packages/fc/f8/7dbaac13363ba11bf08827db14b22c78ccbebd7d6b2f47fc3fb68ace5506/llvmlite-0.27.0-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1c560e6444262155c1ceeed6dfa7ba26", + "sha256": "fad96e1c91c82f0541a636b2918379009a79ea549218c32591222b1719e75aaf" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "1c560e6444262155c1ceeed6dfa7ba26", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 16836412, + "upload_time": "2018-12-31T19:22:21", + "upload_time_iso_8601": "2018-12-31T19:22:21.388147Z", + "url": "https://files.pythonhosted.org/packages/68/e7/70878c7021b72aaa57f258f8abe4c0e1d3f29d0f3cda956ceff162c6cff5/llvmlite-0.27.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "a07c9e353649942a3b015ec0d3d6b9eb", + "sha256": "fcef99dd51219f6732b792f9fec0f99cea2241dc36ba56d33f7e1500e2c893f4" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp27-cp27m-win32.whl", + "has_sig": false, + "md5_digest": "a07c9e353649942a3b015ec0d3d6b9eb", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 8702485, + "upload_time": "2018-12-31T19:21:59", + "upload_time_iso_8601": "2018-12-31T19:21:59.129725Z", + "url": "https://files.pythonhosted.org/packages/5d/5a/d698b3ea220bd3d7570acafb2267bd36d8989e915e1a15080ce0f66976fe/llvmlite-0.27.0-cp27-cp27m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "89d143ab321afd765526877e34e965ef", + "sha256": "7d6c818d63ea291e3004c16ffddf252fd316d1593f1f37f49234ab7a5f228117" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp27-cp27m-win_amd64.whl", + "has_sig": false, + "md5_digest": "89d143ab321afd765526877e34e965ef", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 11284117, + "upload_time": "2018-12-31T19:22:05", + "upload_time_iso_8601": "2018-12-31T19:22:05.121430Z", + "url": "https://files.pythonhosted.org/packages/cb/a2/ac9186b8a835b31b914e5055b11b8c8c2f761b9278026e9319255fd4a2e0/llvmlite-0.27.0-cp27-cp27m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "ea6e96f75401589129fc3c5896480ab2", + "sha256": "8b18e9d8ef2ba0213e45ded927e81ff9a7776f15f7075e4084d76cfd55d60dea" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp35-cp35m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "ea6e96f75401589129fc3c5896480ab2", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 13151953, + "upload_time": "2018-12-31T19:22:26", + "upload_time_iso_8601": "2018-12-31T19:22:26.571648Z", + "url": "https://files.pythonhosted.org/packages/3d/3a/c86c350076bd693cf30878e8625b340f8f36b93fb32ca1d900db7612bae7/llvmlite-0.27.0-cp35-cp35m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "4ec078219e86068021bab9350d6a9f94", + "sha256": "fe5b97ace13056ac1640204eaf1585ab35b14975b4257395433aed50f16cfd9f" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "4ec078219e86068021bab9350d6a9f94", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 17189913, + "upload_time": "2018-12-31T19:22:32", + "upload_time_iso_8601": "2018-12-31T19:22:32.892821Z", + "url": "https://files.pythonhosted.org/packages/c3/48/478443940d91dcd6b9de499031e16d30f8999adb5c1643bd1b7ea9a8359b/llvmlite-0.27.0-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7738c37b470ec3a1b685533207466952", + "sha256": "d07b0caa5c79b36de6d28dadd0364434e360e2e97cc02d6ad0ca60e54b8f89f0" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "7738c37b470ec3a1b685533207466952", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 16836400, + "upload_time": "2018-12-31T19:22:38", + "upload_time_iso_8601": "2018-12-31T19:22:38.556255Z", + "url": "https://files.pythonhosted.org/packages/76/56/6808629ea05c592639abb04b4a8489d90badfd1c2bf2d618b188ba7d4721/llvmlite-0.27.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f507545fc5d9d3a76fb43f39991b4b17", + "sha256": "0dcdabadd686b650072090fc5fe925dfcfaf1d451c801b38fc6beefc7ec0761c" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp35-cp35m-win32.whl", + "has_sig": false, + "md5_digest": "f507545fc5d9d3a76fb43f39991b4b17", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 8702401, + "upload_time": "2018-12-31T19:22:43", + "upload_time_iso_8601": "2018-12-31T19:22:43.167499Z", + "url": "https://files.pythonhosted.org/packages/71/07/4d3a64be164cef67a46e7609ffb5ed0782d78ea25b9f29b04bc919a848f0/llvmlite-0.27.0-cp35-cp35m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f00b728537e2da6f5ddd9c331fc29897", + "sha256": "5d79c2f118834b72f8d0dd918be311ecd8cac4dee69a07316e214cadea9d2fc6" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp35-cp35m-win_amd64.whl", + "has_sig": false, + "md5_digest": "f00b728537e2da6f5ddd9c331fc29897", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 11284039, + "upload_time": "2018-12-31T19:22:50", + "upload_time_iso_8601": "2018-12-31T19:22:50.226806Z", + "url": "https://files.pythonhosted.org/packages/12/d8/37067c3d74bf8591bcbf39c7d75e1095e010641506593a7f39062f93e667/llvmlite-0.27.0-cp35-cp35m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "0af94184ff6a35c63d79bb4abb7c4617", + "sha256": "3ff0024df6816404824a2a7f45b3849b8868005522571c4615f02c0e26336e20" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp36-cp36m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "0af94184ff6a35c63d79bb4abb7c4617", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 13151949, + "upload_time": "2018-12-31T19:22:56", + "upload_time_iso_8601": "2018-12-31T19:22:56.956245Z", + "url": "https://files.pythonhosted.org/packages/dd/90/db6bbb7ef346d29b03cf6021b8fae31cc657c84b71f2d36d06fbfd8564f5/llvmlite-0.27.0-cp36-cp36m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "3c0e8be87b962e6f8c94436fec8b92c4", + "sha256": "a56788241d45913059ea954b3a442d56cc2511906d150aaf15c21e84494a1ae0" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "3c0e8be87b962e6f8c94436fec8b92c4", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 17189883, + "upload_time": "2018-12-31T19:23:05", + "upload_time_iso_8601": "2018-12-31T19:23:05.380010Z", + "url": "https://files.pythonhosted.org/packages/e3/81/e0dfa2c78c6fc894e9dc1c4a68766de31c9b36b57950ac9f8d4ad729d139/llvmlite-0.27.0-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "5bd564c52f98039d2104e2cf079837c5", + "sha256": "32615100c7c9f3101d2608fab5c85afa559406f44bede135d450d3b79f28cf0e" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "5bd564c52f98039d2104e2cf079837c5", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 16836396, + "upload_time": "2018-12-31T19:23:12", + "upload_time_iso_8601": "2018-12-31T19:23:12.594156Z", + "url": "https://files.pythonhosted.org/packages/17/2f/e7f053e8f2616eae980a9a5d352f6cfeff2abb5f88cc0530b23c61713afa/llvmlite-0.27.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "e870e4d592efa116bf3ac52bd21e1683", + "sha256": "822eedc77c90a95f375a8ad61757bf341be81a499003433615f73319ec7b8f6e" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp36-cp36m-win32.whl", + "has_sig": false, + "md5_digest": "e870e4d592efa116bf3ac52bd21e1683", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 8702403, + "upload_time": "2018-12-31T19:23:18", + "upload_time_iso_8601": "2018-12-31T19:23:18.918353Z", + "url": "https://files.pythonhosted.org/packages/32/07/80be2d78f530102d03b9d260b62bed6c93e342d854ba692169f9f52900ad/llvmlite-0.27.0-cp36-cp36m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "e6b6617471c55ec5b4ab32ef4786351f", + "sha256": "a1ec464c712182b57eb4181ba921b01f53dba0b5e64c95888c64c28ab9079c71" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp36-cp36m-win_amd64.whl", + "has_sig": false, + "md5_digest": "e6b6617471c55ec5b4ab32ef4786351f", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 11284036, + "upload_time": "2018-12-31T19:23:25", + "upload_time_iso_8601": "2018-12-31T19:23:25.359293Z", + "url": "https://files.pythonhosted.org/packages/e5/2b/bdab28c186d56521c15f34a6dbc973e139aa1e3b2ca9d1cc13f954c65f2a/llvmlite-0.27.0-cp36-cp36m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f7600a8960357e6c4c3d22008a621c19", + "sha256": "0db9440d163cd63eb6d94213e33e7134bd015c3d4fb2ba92b70d42527ea8f30b" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp37-cp37m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "f7600a8960357e6c4c3d22008a621c19", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 13151952, + "upload_time": "2018-12-31T19:23:32", + "upload_time_iso_8601": "2018-12-31T19:23:32.273801Z", + "url": "https://files.pythonhosted.org/packages/94/7c/ee89ab62f4b34b8ec08b18d0e98990199877717d16510e0e33d860d9c288/llvmlite-0.27.0-cp37-cp37m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "14ad593432535db51f267909236a673f", + "sha256": "96ebb264f386b087b2f860b83937828bccf3689b6e09a76f62de8a5b181d4e15" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp37-cp37m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "14ad593432535db51f267909236a673f", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 17189885, + "upload_time": "2018-12-31T19:23:40", + "upload_time_iso_8601": "2018-12-31T19:23:40.510487Z", + "url": "https://files.pythonhosted.org/packages/76/2d/e52d7174046e82598ac64e456ad449922445b49b629ba46a8d17f1f9562a/llvmlite-0.27.0-cp37-cp37m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "0ed23f661b8748f029bec2f937cb6262", + "sha256": "47bf2d974ef95aa36d3c06b9676fca576ce1b0ec6d772c38fc73ffc3155249d8" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp37-cp37m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "0ed23f661b8748f029bec2f937cb6262", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 16836408, + "upload_time": "2018-12-31T19:23:48", + "upload_time_iso_8601": "2018-12-31T19:23:48.629503Z", + "url": "https://files.pythonhosted.org/packages/f6/74/1476fdaaf752b9940244f8964386712c80037ea1ac7acfd65425bdd55b3a/llvmlite-0.27.0-cp37-cp37m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "8525f70e59fefa2e8371dbb608d86830", + "sha256": "5ff86f4b61af73ef1a23748f3c730dd8307487ca4acd6c1e0509164c77a42095" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp37-cp37m-win32.whl", + "has_sig": false, + "md5_digest": "8525f70e59fefa2e8371dbb608d86830", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 8702398, + "upload_time": "2018-12-31T19:23:53", + "upload_time_iso_8601": "2018-12-31T19:23:53.693504Z", + "url": "https://files.pythonhosted.org/packages/bd/0d/a70deb902a60003bdd957eec81d84dc7186088c6c784495b6a18e85ebb19/llvmlite-0.27.0-cp37-cp37m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1cff57042117b120c6fbc245e6af5fed", + "sha256": "a5e45723b42a2318be243399816a6f3d1848474579a01124b07661280c131e9f" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0-cp37-cp37m-win_amd64.whl", + "has_sig": false, + "md5_digest": "1cff57042117b120c6fbc245e6af5fed", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 11284037, + "upload_time": "2018-12-31T19:23:59", + "upload_time_iso_8601": "2018-12-31T19:23:59.436532Z", + "url": "https://files.pythonhosted.org/packages/38/dd/87a814ac5e0e5ded754c8c063afbc3bf19091b71220272bb3f1901d9501d/llvmlite-0.27.0-cp37-cp37m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "746884a73ae8a83df279e5511efce524", + "sha256": "43aafc62a415d293fa2629b7fb2b114167b877dd1a4b00e9942c5b232a529bc9" + }, + "downloads": -1, + "filename": "llvmlite-0.27.0.tar.gz", + "has_sig": false, + "md5_digest": "746884a73ae8a83df279e5511efce524", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 103752, + "upload_time": "2018-12-31T19:24:58", + "upload_time_iso_8601": "2018-12-31T19:24:58.916060Z", + "url": "https://files.pythonhosted.org/packages/d3/59/8f0c20cd6197b3e535b6eb6513b2f1264c77fd343347e520dd4eab425962/llvmlite-0.27.0.tar.gz" + } + ], + "0.27.1": [ + { + "comment_text": "", + "digests": { + "md5": "30034edeb1810e70fd985d8efe4fe922", + "sha256": "7d05fca7ba5f5bf6d0ccefc99a10c54e0d5cc80d7b8003496372abc0f65be468" + }, + "downloads": -1, + "filename": "llvmlite-0.27.1-cp27-cp27m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "30034edeb1810e70fd985d8efe4fe922", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 13153263, + "upload_time": "2019-02-01T22:50:23", + "upload_time_iso_8601": "2019-02-01T22:50:23.353740Z", + "url": "https://files.pythonhosted.org/packages/00/61/dfdc2bbe1a76678fd7f2cb045cb6aa25457e56a7ae42fe43ae6f7313036b/llvmlite-0.27.1-cp27-cp27m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "5cd067a91ef0dcaacc20f3bf9141d1c0", + "sha256": "727dad5c43c6dfda2781b47ad2f1af3e25a24c4265645d733b70aac01526d8c7" + }, + "downloads": -1, + "filename": "llvmlite-0.27.1-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "5cd067a91ef0dcaacc20f3bf9141d1c0", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 17452058, + "upload_time": "2019-02-12T19:17:30", + "upload_time_iso_8601": "2019-02-12T19:17:30.589537Z", + "url": "https://files.pythonhosted.org/packages/42/fd/ba323e1888d3713b6877037e4608240f9ac4ee242b53446233f7a8402e93/llvmlite-0.27.1-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f7971d4ebb648393774e6fda9c6b9577", + "sha256": "cd72c789d38e6cef8145a97a65e1f6eeecb4aab4c85a886015b630c8f7e7543d" + }, + "downloads": -1, + "filename": "llvmlite-0.27.1-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "f7971d4ebb648393774e6fda9c6b9577", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 17093288, + "upload_time": "2019-02-12T19:17:42", + "upload_time_iso_8601": "2019-02-12T19:17:42.866086Z", + "url": "https://files.pythonhosted.org/packages/6e/6b/10e1c00bb2afb15797b90f6e91427b97e5d4312b29a787756650305207a3/llvmlite-0.27.1-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7bee906c42674f10f9d9a3818d277432", + "sha256": "4cbe079cb1eeaf4c90e1b75b2ef314ebb0ea5b4c420298e96065eafa3a0d0b0e" + }, + "downloads": -1, + "filename": "llvmlite-0.27.1-cp36-cp36m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "7bee906c42674f10f9d9a3818d277432", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 13153237, + "upload_time": "2019-02-01T22:50:27", + "upload_time_iso_8601": "2019-02-01T22:50:27.153914Z", + "url": "https://files.pythonhosted.org/packages/dd/ad/fec27334d072762ca0af8350f5bd2d44aa7c5934f310f2c8368e2b6a7114/llvmlite-0.27.1-cp36-cp36m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "2569d459be57ea87802710e6151a569d", + "sha256": "a211eea04c5bd1c6d81a3a3b902686c379cdfc2d690b36c2ff42e8254755a0db" + }, + "downloads": -1, + "filename": "llvmlite-0.27.1-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "2569d459be57ea87802710e6151a569d", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 17451998, + "upload_time": "2019-02-12T19:17:53", + "upload_time_iso_8601": "2019-02-12T19:17:53.773412Z", + "url": "https://files.pythonhosted.org/packages/ed/cc/8de877e07abad8176fea513ac74270b506e8d6303978d9ab53e4a5f71720/llvmlite-0.27.1-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "b7c448872fee9ea2c7646238b0afc424", + "sha256": "137817894dfc702c3f6fa17eef75a1fb004ce9a31b689671084c36ddba59920b" + }, + "downloads": -1, + "filename": "llvmlite-0.27.1-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "b7c448872fee9ea2c7646238b0afc424", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 17093215, + "upload_time": "2019-02-12T19:18:04", + "upload_time_iso_8601": "2019-02-12T19:18:04.354001Z", + "url": "https://files.pythonhosted.org/packages/71/f5/ed9af288084b4f0cc2e4db0c3be57ba0442ed837135a9c2607c3a1309790/llvmlite-0.27.1-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "18690c352c1ff8db4c803233292ac1d4", + "sha256": "ceed23df15ec814f9bd4ddbd8a8f9d7acb986fb571f7f034ec1f7f6cbed16cde" + }, + "downloads": -1, + "filename": "llvmlite-0.27.1-cp37-cp37m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "18690c352c1ff8db4c803233292ac1d4", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 13153243, + "upload_time": "2019-02-01T22:50:30", + "upload_time_iso_8601": "2019-02-01T22:50:30.984089Z", + "url": "https://files.pythonhosted.org/packages/91/c8/54b0c8e3975654e328ebbd92fabba422536e05be353da50f30b04fff60ba/llvmlite-0.27.1-cp37-cp37m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "580ee3a0156a9b435ca751c60c5925da", + "sha256": "e6194d74bdac3fd1454384f4922abb3c1afe209e15c607ed84b8bc60c35a7a4a" + }, + "downloads": -1, + "filename": "llvmlite-0.27.1-cp37-cp37m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "580ee3a0156a9b435ca751c60c5925da", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 17452019, + "upload_time": "2019-02-12T19:18:16", + "upload_time_iso_8601": "2019-02-12T19:18:16.594374Z", + "url": "https://files.pythonhosted.org/packages/7c/af/f6e70508c36f9988286bf92d898d523633e3efa39531e1b84b760248cd50/llvmlite-0.27.1-cp37-cp37m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "2e97e834be59119094baae63df7f9a21", + "sha256": "b5bab3a2fc754c6b8d8a550061299a8bc119dc0febf713a2f1f38fe50d670115" + }, + "downloads": -1, + "filename": "llvmlite-0.27.1-cp37-cp37m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "2e97e834be59119094baae63df7f9a21", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 17093201, + "upload_time": "2019-02-12T19:18:28", + "upload_time_iso_8601": "2019-02-12T19:18:28.787970Z", + "url": "https://files.pythonhosted.org/packages/70/e4/a9e9431f1ce0274d844b80b9993a940f8445289b6115f7a40d71a852f133/llvmlite-0.27.1-cp37-cp37m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "81946df6afaa8e30b6946eac5920f0d6", + "sha256": "48a1c3ae69fd8920cba153bfed8a46ac46474bc706a2100226df4abffe0000ab" + }, + "downloads": -1, + "filename": "llvmlite-0.27.1.tar.gz", + "has_sig": false, + "md5_digest": "81946df6afaa8e30b6946eac5920f0d6", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 104010, + "upload_time": "2019-03-12T19:09:38", + "upload_time_iso_8601": "2019-03-12T19:09:38.210898Z", + "url": "https://files.pythonhosted.org/packages/31/6a/2af9e150c053c194c751060b904ce9bdbb588ae3c6ce95569f95a2004884/llvmlite-0.27.1.tar.gz" + } + ], + "0.28.0": [ + { + "comment_text": "", + "digests": { + "md5": "5ecda86d4835aae6f6d326c88d938e17", + "sha256": "1770d6b4a234cbe87f58ce32bde5d83a7890ad7f1a3cf767baae07baba0f7673" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-1-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "5ecda86d4835aae6f6d326c88d938e17", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 16843724, + "upload_time": "2019-03-15T16:46:55", + "upload_time_iso_8601": "2019-03-15T16:46:55.435928Z", + "url": "https://files.pythonhosted.org/packages/ec/12/696ffbcefbbf4f701bccb4426c37030150bc54cad57a9a719386ab80eedf/llvmlite-0.28.0-1-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "41a71b4f6c607c1f00a89fa61e81e13f", + "sha256": "2a0703efaf5e0abce62effd200facb5c491e8452471d40866e0afe4f9698261b" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-1-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "41a71b4f6c607c1f00a89fa61e81e13f", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 16843704, + "upload_time": "2019-03-15T16:47:01", + "upload_time_iso_8601": "2019-03-15T16:47:01.002230Z", + "url": "https://files.pythonhosted.org/packages/d1/0e/d0ed03146d441ce92c62367c29c0e77c8b1e78f9a17c77d9015b959cff02/llvmlite-0.28.0-1-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "145fbb53ebc081144a3d775f0908f5a4", + "sha256": "0c5765dca193710ae6bb025961515126cc5ff50121f7eb9b092c422fbc889636" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-1-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "145fbb53ebc081144a3d775f0908f5a4", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 16843709, + "upload_time": "2019-03-15T16:47:05", + "upload_time_iso_8601": "2019-03-15T16:47:05.069934Z", + "url": "https://files.pythonhosted.org/packages/b5/f3/6d7f49db45df0276166f99723aa10310862a3783556cd284793da478afed/llvmlite-0.28.0-1-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f1799c47f721b0655a8f5d42fdbcad6d", + "sha256": "965fd21608977899bd0b9d03b7ce20df5d884753fb50aa34c84cfe11579df7a8" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-1-cp37-cp37m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "f1799c47f721b0655a8f5d42fdbcad6d", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 16843684, + "upload_time": "2019-03-15T16:47:09", + "upload_time_iso_8601": "2019-03-15T16:47:09.204058Z", + "url": "https://files.pythonhosted.org/packages/50/68/cd4617d21394addb479722b6c095828e20836ff19873136b4310671e9da2/llvmlite-0.28.0-1-cp37-cp37m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "ba7df9de053ba89268e5291b354fa3cd", + "sha256": "4039e6350b22de27576405693b2fe72e8e3f63175f1a6b7f60a97d2235f05ab8" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp27-cp27m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "ba7df9de053ba89268e5291b354fa3cd", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 13156392, + "upload_time": "2019-03-13T20:56:51", + "upload_time_iso_8601": "2019-03-13T20:56:51.778102Z", + "url": "https://files.pythonhosted.org/packages/ba/bd/4eae8f9d97d38d3c5f9dabb54a258cf4490b302c7b80bc9b5b305b07092a/llvmlite-0.28.0-cp27-cp27m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f1c00bc8a7914303654a333f8f7f4508", + "sha256": "51fb457dcda0df1cf07ccc89278f9408c4a10504d2d64e44a354e1cb97c96c0f" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "f1c00bc8a7914303654a333f8f7f4508", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 17455954, + "upload_time": "2019-03-13T20:57:03", + "upload_time_iso_8601": "2019-03-13T20:57:03.449771Z", + "url": "https://files.pythonhosted.org/packages/ee/a4/10013d9773e83b8440c744dfd35b521d8572b3cc89c0863d6e3ecdb62508/llvmlite-0.28.0-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "4ad41048e28167b63486edb1f0f40d56", + "sha256": "82f42b16fdea19d0b166bfe2f0b01cab13deec9cb3c47b70a20c870968d0dbe2" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "4ad41048e28167b63486edb1f0f40d56", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 17098645, + "upload_time": "2019-03-13T20:57:07", + "upload_time_iso_8601": "2019-03-13T20:57:07.935528Z", + "url": "https://files.pythonhosted.org/packages/48/85/b33499d954d252584278e88f51bc15b959599eb12f1246977ee85c148179/llvmlite-0.28.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c06c85f7e4938fdbc72ddcb6d00b23c9", + "sha256": "55561dffb145356dc1633f3cf325c11675e2d12b23adc6c6c3b4ef268d28d50f" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp27-cp27m-win32.whl", + "has_sig": false, + "md5_digest": "c06c85f7e4938fdbc72ddcb6d00b23c9", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 8704562, + "upload_time": "2019-03-13T20:56:55", + "upload_time_iso_8601": "2019-03-13T20:56:55.275792Z", + "url": "https://files.pythonhosted.org/packages/ff/27/0d867c047e22152a30ecdc7c288ea38aa2f60baa1c6a005c7724d14d9c13/llvmlite-0.28.0-cp27-cp27m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "99311120c4f113cd074df094c3a8b346", + "sha256": "4f9a3bac281806fc8d0f06c339ad7f295637edcb2a13621853e024941d53bd0e" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp27-cp27m-win_amd64.whl", + "has_sig": false, + "md5_digest": "99311120c4f113cd074df094c3a8b346", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 11287961, + "upload_time": "2019-03-13T20:56:59", + "upload_time_iso_8601": "2019-03-13T20:56:59.058641Z", + "url": "https://files.pythonhosted.org/packages/f2/b3/b727b0dd51bd596041bde2e62cc717860abbacf5befb73070dad40bfe259/llvmlite-0.28.0-cp27-cp27m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "da6537b146b178a9edbe7d2ab2acda83", + "sha256": "e91a044a996197c67dd8f73c02ab332c6deca090e3f6152ef0849e5c03e8ca21" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp35-cp35m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "da6537b146b178a9edbe7d2ab2acda83", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 13155160, + "upload_time": "2019-03-13T20:57:11", + "upload_time_iso_8601": "2019-03-13T20:57:11.932887Z", + "url": "https://files.pythonhosted.org/packages/68/80/970a66bc62bcae837f4e5a023b350bfc713456c82c2042a9539fe3039733/llvmlite-0.28.0-cp35-cp35m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "108739fdcde2547d10d120ba405171c9", + "sha256": "b0decf92f8de3fa2125e7b4822d5460488cfdf0a18b81b482c4865a17e8980af" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "108739fdcde2547d10d120ba405171c9", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 17454725, + "upload_time": "2019-03-13T20:57:16", + "upload_time_iso_8601": "2019-03-13T20:57:16.369395Z", + "url": "https://files.pythonhosted.org/packages/0e/87/60f79dcae050f636e88817d188cff62d29700c7c9874eaebec8c47dbfc24/llvmlite-0.28.0-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7cef11f191acb58c5149bfad3ee9fd01", + "sha256": "28b24ab2e95f80b2c4db9f97dd21b1630c35b427e429ac13b841f190146e420d" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "7cef11f191acb58c5149bfad3ee9fd01", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 17097414, + "upload_time": "2019-03-13T20:57:22", + "upload_time_iso_8601": "2019-03-13T20:57:22.313950Z", + "url": "https://files.pythonhosted.org/packages/d9/20/3086d4970454dc95bc3b702086d2cf6410ed5629bc70894d8c147cf98b9c/llvmlite-0.28.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "4e654650fe5a9cfd8706d663f7df4381", + "sha256": "59c6dcc8a37fee7703b444018d2c2929dce854f15c9a7db868a02ebe2f2e9302" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp35-cp35m-win32.whl", + "has_sig": false, + "md5_digest": "4e654650fe5a9cfd8706d663f7df4381", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 8703286, + "upload_time": "2019-03-13T20:57:26", + "upload_time_iso_8601": "2019-03-13T20:57:26.272308Z", + "url": "https://files.pythonhosted.org/packages/d7/70/6b559747c371ffe3baa4c4003e739aaa5909f976f3072aabcc62af556dc1/llvmlite-0.28.0-cp35-cp35m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f2e6e91fd70abf4919231b868c45479a", + "sha256": "36c280ad6fdfa79e69853ed706a5007ad3d3b9fcc6c4217aca0610b93f25a907" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp35-cp35m-win_amd64.whl", + "has_sig": false, + "md5_digest": "f2e6e91fd70abf4919231b868c45479a", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 11286682, + "upload_time": "2019-03-13T20:57:44", + "upload_time_iso_8601": "2019-03-13T20:57:44.805624Z", + "url": "https://files.pythonhosted.org/packages/28/f9/8b134aab6183c8874870859693d918cf143d4126aa0c40c8dd0057921c82/llvmlite-0.28.0-cp35-cp35m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "726b42bef852bbea410c66ec4dd8d749", + "sha256": "99bfe5d20344dce92d159f4cdaaac953a1e50b13aaeeab72c4c243bd60ce5819" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp36-cp36m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "726b42bef852bbea410c66ec4dd8d749", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 13156371, + "upload_time": "2019-03-13T20:57:48", + "upload_time_iso_8601": "2019-03-13T20:57:48.970143Z", + "url": "https://files.pythonhosted.org/packages/e2/54/151f408d4d3abbc4f705e9165d10983833976ab76eac37574b2ed0235039/llvmlite-0.28.0-cp36-cp36m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "90ed888ae45fd95306646dcbb22d0a8f", + "sha256": "dde4b5e4298976bd721974657ce76178176ea5e55437346b0d52503c0acb5db1" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "90ed888ae45fd95306646dcbb22d0a8f", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 17455950, + "upload_time": "2019-03-13T20:57:53", + "upload_time_iso_8601": "2019-03-13T20:57:53.439524Z", + "url": "https://files.pythonhosted.org/packages/c0/80/05c28794b222b36924d907690a749222f2b6c8786056a0b7deed650ed169/llvmlite-0.28.0-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "10191b37db21e01beb0ee5895f12f85f", + "sha256": "0dc9bd9e1ec44768dae990d026f9e25467a286d534550bf7185dbb0ddde9850a" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "10191b37db21e01beb0ee5895f12f85f", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 17098630, + "upload_time": "2019-03-13T20:57:57", + "upload_time_iso_8601": "2019-03-13T20:57:57.662920Z", + "url": "https://files.pythonhosted.org/packages/a1/d6/30e5b08c2a37c445f8c72dbfc080b2ed1724b740efbe2fed963053756a68/llvmlite-0.28.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "9d4a3645c0979ffd4cd80f5c22bd3c94", + "sha256": "3e7c020931bca3afb9aaf0a768abee7e689bdede56b1c832cef17d6c3a7d86a1" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp36-cp36m-win32.whl", + "has_sig": false, + "md5_digest": "9d4a3645c0979ffd4cd80f5c22bd3c94", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 8704511, + "upload_time": "2019-03-13T20:58:02", + "upload_time_iso_8601": "2019-03-13T20:58:02.434394Z", + "url": "https://files.pythonhosted.org/packages/63/da/71d63c8baa3c1fd5524c2b47f49d771b39e5a6ce6f9d50f573cab534d4ca/llvmlite-0.28.0-cp36-cp36m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "64ee8aa1206f659693e0d95f8ca2d7dc", + "sha256": "5112f5f7072d3d5c4615cb9f173701a42f3883d26f17ec1b4d8a442f80caa14a" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp36-cp36m-win_amd64.whl", + "has_sig": false, + "md5_digest": "64ee8aa1206f659693e0d95f8ca2d7dc", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 11287910, + "upload_time": "2019-03-13T20:58:06", + "upload_time_iso_8601": "2019-03-13T20:58:06.474092Z", + "url": "https://files.pythonhosted.org/packages/6d/b0/006917794be1285869dc93b4f50a100feb5c52f06e2eef88f0378a616385/llvmlite-0.28.0-cp36-cp36m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c0a3cff5cb4ca560cf25e5fe261451ea", + "sha256": "4c337e847a0f3f491361cb7cc90835b17fbe898994d175e4c8f444fbcf2dffd3" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp37-cp37m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "c0a3cff5cb4ca560cf25e5fe261451ea", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 13156372, + "upload_time": "2019-03-13T20:58:10", + "upload_time_iso_8601": "2019-03-13T20:58:10.890638Z", + "url": "https://files.pythonhosted.org/packages/cf/bd/16a7262976461bd2aaa82ebd2e7ebf6b303dc92abd0f4dbd0bd374994a6b/llvmlite-0.28.0-cp37-cp37m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "746127c2493947a8437bfe0c324ebc72", + "sha256": "035d55963fc45e0074aa0e5659dd2f37c1ebaabe2f803404e4b2857a5c8b692c" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp37-cp37m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "746127c2493947a8437bfe0c324ebc72", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 17455958, + "upload_time": "2019-03-13T20:58:15", + "upload_time_iso_8601": "2019-03-13T20:58:15.438489Z", + "url": "https://files.pythonhosted.org/packages/84/0e/53353fce0895b642a1ac279a43deeae01956e5cbe30ef27d0edd4e745469/llvmlite-0.28.0-cp37-cp37m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "6588594ad55a67f248d31712a716654d", + "sha256": "ddc7c4e4dd7851f845a3e4044ab4a83a3b6c46462f002b6c8c06bdb5d4a70a9f" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp37-cp37m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "6588594ad55a67f248d31712a716654d", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 17098649, + "upload_time": "2019-03-13T20:58:19", + "upload_time_iso_8601": "2019-03-13T20:58:19.819054Z", + "url": "https://files.pythonhosted.org/packages/22/74/655a7c6a2a8b9f96ec3f16891e4813aad673e30e6d560a500d50281589ef/llvmlite-0.28.0-cp37-cp37m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "16ead372cb40d1d9afa1123f2144c06d", + "sha256": "4e68173ab3be4654ecdbf9238347e23005405f2f5eb6a4e9b48f6e4f0d5a0e50" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp37-cp37m-win32.whl", + "has_sig": false, + "md5_digest": "16ead372cb40d1d9afa1123f2144c06d", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 8704510, + "upload_time": "2019-03-13T20:58:23", + "upload_time_iso_8601": "2019-03-13T20:58:23.612625Z", + "url": "https://files.pythonhosted.org/packages/14/0d/53d3b429f56ca5b53b8d5ba0b7ced1b7a5f731a90b0f1b89c69af1a99f6d/llvmlite-0.28.0-cp37-cp37m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "4d411472b13357e260221edd4420153f", + "sha256": "07ed7e38be53611dce7daa36274469dd99995b149c361efc9f509aa8569c2088" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0-cp37-cp37m-win_amd64.whl", + "has_sig": false, + "md5_digest": "4d411472b13357e260221edd4420153f", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 11287909, + "upload_time": "2019-03-13T20:58:27", + "upload_time_iso_8601": "2019-03-13T20:58:27.083215Z", + "url": "https://files.pythonhosted.org/packages/a4/af/437bb1822e86002e59cf552f74c5963edb8b1edcfba902a7868b16558bef/llvmlite-0.28.0-cp37-cp37m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "2e0b4586a8c8c1981ce49e837bf70781", + "sha256": "a189c0cd8a80e8bbd002a1e422b1efcc2bceab2cb63b961f2d03ab711c3ba45b" + }, + "downloads": -1, + "filename": "llvmlite-0.28.0.tar.gz", + "has_sig": false, + "md5_digest": "2e0b4586a8c8c1981ce49e837bf70781", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 106678, + "upload_time": "2019-03-13T20:59:21", + "upload_time_iso_8601": "2019-03-13T20:59:21.710272Z", + "url": "https://files.pythonhosted.org/packages/85/80/5fa60aee0b893ca0949e821ec2eb207dcee0ec98c862f6b97f851dda0275/llvmlite-0.28.0.tar.gz" + } + ], + "0.29.0": [ + { + "comment_text": "", + "digests": { + "md5": "f4e35aae80f26909153a19690eece088", + "sha256": "e47797cd29746c121e04ddef53d6f392fb6f684d99d86812951ec09df35dd717" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-1-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "f4e35aae80f26909153a19690eece088", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 20537489, + "upload_time": "2019-08-02T18:28:38", + "upload_time_iso_8601": "2019-08-02T18:28:38.337399Z", + "url": "https://files.pythonhosted.org/packages/3f/99/30db302f6ce7e623fa7101727a4b7cbd1b4888a770558e8662d4382aef5e/llvmlite-0.29.0-1-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "096e3d625474211b3f98c2ac5ab35778", + "sha256": "d49e0bd0f8c6a9769260b95c455fdfb6321448948b248b57d039d5b8baaaddf5" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-1-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "096e3d625474211b3f98c2ac5ab35778", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 20164739, + "upload_time": "2019-08-02T18:28:42", + "upload_time_iso_8601": "2019-08-02T18:28:42.797128Z", + "url": "https://files.pythonhosted.org/packages/f4/cd/a330deef3e77e765f9522f3d85d6c3b71fb893a7dfc738ddac1eb3b8dabd/llvmlite-0.29.0-1-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "0ab4aaf04f1c81312ce4fdbc6cef918f", + "sha256": "eb731ca9d435df4745cd311c0bccf97034ec8535f22bff1cc866995bf56e24ec" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-1-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "0ab4aaf04f1c81312ce4fdbc6cef918f", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 20537472, + "upload_time": "2019-08-02T18:28:47", + "upload_time_iso_8601": "2019-08-02T18:28:47.531633Z", + "url": "https://files.pythonhosted.org/packages/9d/42/36f46b60c11000ed4967c3cdfa1c0adba5e8f90fb2380608dc08f25773d6/llvmlite-0.29.0-1-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "094d79abdfa61bdbd0e34a22c228452f", + "sha256": "f9e01202420ffa13109370181b14e8391e1f3213bba526b2720a86d8481e2037" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-1-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "094d79abdfa61bdbd0e34a22c228452f", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 20164742, + "upload_time": "2019-08-02T18:28:52", + "upload_time_iso_8601": "2019-08-02T18:28:52.153860Z", + "url": "https://files.pythonhosted.org/packages/34/4e/7f31b4362a6e254ddb5af3035e8682cc63fa7c9d9f89b2a024adafab49b6/llvmlite-0.29.0-1-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7e7e6bf8fafef5c4349a05ac6c592b74", + "sha256": "59554474a84585a3d84d5ef3ea05e24b3687c091d6839a4da7dac496164bd1ab" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-1-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "7e7e6bf8fafef5c4349a05ac6c592b74", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 20537467, + "upload_time": "2019-08-02T18:28:56", + "upload_time_iso_8601": "2019-08-02T18:28:56.934205Z", + "url": "https://files.pythonhosted.org/packages/e8/c6/cddd99fcef50063d2fcfe3c992c780ae4cb8b9f61464c429114b56d62c81/llvmlite-0.29.0-1-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "bd5834dad15f3f4942c96a125a1dd785", + "sha256": "914de70f70efe016461eb0c16deb9734529575f206f0835e0035491bcbdd9422" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-1-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "bd5834dad15f3f4942c96a125a1dd785", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 20164740, + "upload_time": "2019-08-02T18:29:01", + "upload_time_iso_8601": "2019-08-02T18:29:01.122150Z", + "url": "https://files.pythonhosted.org/packages/1f/bf/c9fc3b6d7d46968186ac37a2453639979edd8fa7199bb9f4b820a813e8c8/llvmlite-0.29.0-1-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "ac3aabace930ae587fb903ede242978d", + "sha256": "0c3d593de39ea75bb72011dfb49657677eade16eb9958865acc7773d13827424" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-1-cp37-cp37m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "ac3aabace930ae587fb903ede242978d", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 20537483, + "upload_time": "2019-08-02T18:29:05", + "upload_time_iso_8601": "2019-08-02T18:29:05.917891Z", + "url": "https://files.pythonhosted.org/packages/0a/a9/a8e1a833d04d8e38e873a97d6aa00d5c21f86732e6156b02502aa978dcc0/llvmlite-0.29.0-1-cp37-cp37m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "66128ffa6bc563abb3f61e2c8958d3c8", + "sha256": "54ba8043c38aeff34679a4e9ea31c1cd6539bce7b221108ef0951e5480ee934b" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-1-cp37-cp37m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "66128ffa6bc563abb3f61e2c8958d3c8", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 20164732, + "upload_time": "2019-08-02T18:29:10", + "upload_time_iso_8601": "2019-08-02T18:29:10.409090Z", + "url": "https://files.pythonhosted.org/packages/30/ae/a33eb9a94734889c189ba4b05170ac0ede05904db5d3dd31158cb33ac16e/llvmlite-0.29.0-1-cp37-cp37m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "33f34cace95d1d575452ff87512a4098", + "sha256": "6af0f4eaa07ac1565ecb5bc64fee8b047763cca61520e23c8ab13316058c0f06" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp27-cp27m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "33f34cace95d1d575452ff87512a4098", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 15918242, + "upload_time": "2019-05-30T18:34:57", + "upload_time_iso_8601": "2019-05-30T18:34:57.770162Z", + "url": "https://files.pythonhosted.org/packages/88/56/9e44d7060a331cf31ef7429536852fbcb284178886deff96520ccb3f3ca8/llvmlite-0.29.0-cp27-cp27m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f070734092543a9e51d669da54840753", + "sha256": "c8f7099f31e3ba8257777d179e0186a80ec7a810ae4500da8aa6254017adc7bf" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "f070734092543a9e51d669da54840753", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 20780310, + "upload_time": "2019-05-30T18:35:10", + "upload_time_iso_8601": "2019-05-30T18:35:10.041193Z", + "url": "https://files.pythonhosted.org/packages/22/63/5dd4f1e36cf79b7dc1b7c2f5d60fe1c24f80da70c48a8a08ec8a849a9ed5/llvmlite-0.29.0-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "31c4115d4c04259bd10f9d490a0bbff9", + "sha256": "2b74a3edf542004edcf9cdb47e05ea481b33e01f633ce45ea0c68124ebf50647" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "31c4115d4c04259bd10f9d490a0bbff9", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 20394934, + "upload_time": "2019-05-30T18:35:15", + "upload_time_iso_8601": "2019-05-30T18:35:15.414138Z", + "url": "https://files.pythonhosted.org/packages/4d/a1/a081b78433b42e070f78e2ba439843af90d070c6272718f46d0b3a6ccd64/llvmlite-0.29.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "a24d289ab201880dad2b28d9bf3ae099", + "sha256": "9c75225903928fcef35fdda9bfb80460f90f12c442cb85bf524f91d9874fb17d" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp27-cp27m-win32.whl", + "has_sig": false, + "md5_digest": "a24d289ab201880dad2b28d9bf3ae099", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 10597888, + "upload_time": "2019-05-30T18:35:01", + "upload_time_iso_8601": "2019-05-30T18:35:01.630004Z", + "url": "https://files.pythonhosted.org/packages/12/a5/6ad3f14a06f3f5263dcfba1bacbb285f82f03404d3879b139325ed48e277/llvmlite-0.29.0-cp27-cp27m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "b04d62b36e7cb4fee434c4c4c2505144", + "sha256": "9b4bebf5ea91a389798fe3b84436f03e014553fc156389bf810be7c7479f71d6" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp27-cp27m-win_amd64.whl", + "has_sig": false, + "md5_digest": "b04d62b36e7cb4fee434c4c4c2505144", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 13626167, + "upload_time": "2019-05-30T18:35:05", + "upload_time_iso_8601": "2019-05-30T18:35:05.592235Z", + "url": "https://files.pythonhosted.org/packages/f1/88/f13cc89dc7fe58896a60765c5296141d4c68046b3a91cd1d6a2bae5a41ff/llvmlite-0.29.0-cp27-cp27m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "eac811350b0d2694a545b445b43db4de", + "sha256": "61e3f5e9a6fad63af1cb7f7d414dc4da260d315885fdc6cc252641fc911f9dec" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp35-cp35m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "eac811350b0d2694a545b445b43db4de", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 15917022, + "upload_time": "2019-05-30T18:35:20", + "upload_time_iso_8601": "2019-05-30T18:35:20.712173Z", + "url": "https://files.pythonhosted.org/packages/06/bd/e75f27cf3a8ca25f8401accf28b4571bc8679a51a9a341f04b9e7d333a7c/llvmlite-0.29.0-cp35-cp35m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "34386b6f2ea3b0001c19d2d30a720cc4", + "sha256": "f5d957dcb16756a795216515ade71433160f7485767ae14bdc429d5c9c40d624" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "34386b6f2ea3b0001c19d2d30a720cc4", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 20780276, + "upload_time": "2019-05-30T18:35:25", + "upload_time_iso_8601": "2019-05-30T18:35:25.680237Z", + "url": "https://files.pythonhosted.org/packages/be/6f/87a83ec31df76b1084b9320d2a77f35fc349a39ae355c39dac6d584018d1/llvmlite-0.29.0-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "d07b7d2f3d048c195cb9f88d3eb97693", + "sha256": "b51863eb1dc5397070e37124665dd472770d685cfff24546bacf3a779a5a8c32" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "d07b7d2f3d048c195cb9f88d3eb97693", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 20393719, + "upload_time": "2019-05-30T18:35:33", + "upload_time_iso_8601": "2019-05-30T18:35:33.483370Z", + "url": "https://files.pythonhosted.org/packages/fc/8c/6412b14976f90d703279b5cd53c6f036e4e1fda434007f305e8a1e103d06/llvmlite-0.29.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7904d9f66c864f72515ac4b597a74aad", + "sha256": "a1090704f44a2f2b1b6f69ec0bcf9c7179d16917b2ab9799af9e70130420c35d" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp35-cp35m-win32.whl", + "has_sig": false, + "md5_digest": "7904d9f66c864f72515ac4b597a74aad", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 10596620, + "upload_time": "2019-05-30T18:35:37", + "upload_time_iso_8601": "2019-05-30T18:35:37.569464Z", + "url": "https://files.pythonhosted.org/packages/45/c7/f862c958dfc8de97db0d700d3c5237865cd398cb1010259b5fc5852e264e/llvmlite-0.29.0-cp35-cp35m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "facbf6956879354f10062817a2200381", + "sha256": "dc8ac5f3b65cc7b50f4b777afb71b4e2896ecbbaf07657a6fc789098603e38e7" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp35-cp35m-win_amd64.whl", + "has_sig": false, + "md5_digest": "facbf6956879354f10062817a2200381", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 13624901, + "upload_time": "2019-05-30T18:35:41", + "upload_time_iso_8601": "2019-05-30T18:35:41.519465Z", + "url": "https://files.pythonhosted.org/packages/b9/6e/63bdb84e6e00705db0d9e79ffcca4091d7077babd84203974055c3aec173/llvmlite-0.29.0-cp35-cp35m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "f46ba4976cedba9249870474f4a6846d", + "sha256": "f0f93e0e0644dfb635f258d48971827236c3a235811f179465a16040b8f21228" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp36-cp36m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "f46ba4976cedba9249870474f4a6846d", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 15918246, + "upload_time": "2019-05-30T18:35:45", + "upload_time_iso_8601": "2019-05-30T18:35:45.981081Z", + "url": "https://files.pythonhosted.org/packages/c4/75/0a330b7f888485f070f7d79a10d1e07234e6870c15791ecc015f73206e51/llvmlite-0.29.0-cp36-cp36m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "10d496e8315e23375fe49e9762c070f9", + "sha256": "52886658699f70de42ec6aeba6982a1fc8fa05a69ef10b8094eaa54e883d749e" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "10d496e8315e23375fe49e9762c070f9", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 20780328, + "upload_time": "2019-05-30T18:35:50", + "upload_time_iso_8601": "2019-05-30T18:35:50.573630Z", + "url": "https://files.pythonhosted.org/packages/08/24/752c7d1d34c7e924aeb8fb7e038a09076d0dec9bc9833c925903b68f3201/llvmlite-0.29.0-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "6dcea9ab12cff01c182099d74e2be668", + "sha256": "bd68e01f1444e38983a364ad1810bdaf3eb59ca1fe8aff4a33cc17a90cb9fcdb" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "6dcea9ab12cff01c182099d74e2be668", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 20394942, + "upload_time": "2019-05-30T18:35:55", + "upload_time_iso_8601": "2019-05-30T18:35:55.173422Z", + "url": "https://files.pythonhosted.org/packages/09/f1/4fa99c2079132da8694361fb9a19094616f1ba2c2eae610379e75394575f/llvmlite-0.29.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c60dd66d59786ca4a1670312bd2049cf", + "sha256": "9c9cb21527cff7e7e7ab17f13c335cf66fe2c219309fd6693aab6c0edaf422d0" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp36-cp36m-win32.whl", + "has_sig": false, + "md5_digest": "c60dd66d59786ca4a1670312bd2049cf", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 10597846, + "upload_time": "2019-05-30T18:35:58", + "upload_time_iso_8601": "2019-05-30T18:35:58.909079Z", + "url": "https://files.pythonhosted.org/packages/85/15/df1d2666b88e462d641c029c09cb7e09417785f17d60f8f9e92b91d95536/llvmlite-0.29.0-cp36-cp36m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1c0e9d3368a062fc74349c76659d17e4", + "sha256": "8b24b13849b56cf94b9f3fcc1b7c54a89745589da23d800ace4675242266506e" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp36-cp36m-win_amd64.whl", + "has_sig": false, + "md5_digest": "1c0e9d3368a062fc74349c76659d17e4", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 13626126, + "upload_time": "2019-05-30T18:36:03", + "upload_time_iso_8601": "2019-05-30T18:36:03.035642Z", + "url": "https://files.pythonhosted.org/packages/ce/7b/3f18064766f42102ac6a7982372ef95f84211959be3e7b91c2837cbb201c/llvmlite-0.29.0-cp36-cp36m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "2863f493b015bd83d4c6e30bec3e50d7", + "sha256": "1f2424dfbc1f459aab3ed0a855b8ee1e88695cf6824343a116eb21cb6dc35ca1" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp37-cp37m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "2863f493b015bd83d4c6e30bec3e50d7", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 15918244, + "upload_time": "2019-05-30T18:36:07", + "upload_time_iso_8601": "2019-05-30T18:36:07.690781Z", + "url": "https://files.pythonhosted.org/packages/d7/45/9216cdbf71b94ae8eefe24cfbdf4c1b9045a58f297c6e2eab5cb8d05faf3/llvmlite-0.29.0-cp37-cp37m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "4b1e69a7105c9b09b09bdcd553474422", + "sha256": "c4e02a7496f43306d359edf22770014b650291978f5ad2a7a172e187ee3fd1e3" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp37-cp37m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "4b1e69a7105c9b09b09bdcd553474422", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 20780276, + "upload_time": "2019-05-30T18:36:12", + "upload_time_iso_8601": "2019-05-30T18:36:12.804829Z", + "url": "https://files.pythonhosted.org/packages/eb/ba/760afd748fe509bca6a2b99590d46de474ec696ac286255293a5470c7e49/llvmlite-0.29.0-cp37-cp37m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "15a09fe4805796bdf7ba27261edeccfa", + "sha256": "c8f3012179f2352badaf91c9d148814f0dcefb06951b313087585f5ff80b40a7" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp37-cp37m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "15a09fe4805796bdf7ba27261edeccfa", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 20394936, + "upload_time": "2019-05-30T18:36:18", + "upload_time_iso_8601": "2019-05-30T18:36:18.901690Z", + "url": "https://files.pythonhosted.org/packages/72/94/c1e4347ff8157de1d4064baee3820a6fbf0d374704feabe8e420a2697957/llvmlite-0.29.0-cp37-cp37m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "7af34f28cad774d3db6913876c90dee6", + "sha256": "1948dbefe77862c48dacb1f7a131ff1077fa0cc0afadd312d25d80fe6fc920ef" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp37-cp37m-win32.whl", + "has_sig": false, + "md5_digest": "7af34f28cad774d3db6913876c90dee6", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 10597848, + "upload_time": "2019-05-30T18:36:23", + "upload_time_iso_8601": "2019-05-30T18:36:23.551163Z", + "url": "https://files.pythonhosted.org/packages/40/a8/6f66515b39053cbd62c9e0bd15e4005dc714d008dce01deac11094ea4d9a/llvmlite-0.29.0-cp37-cp37m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "8d1a7aef326a04ca3a695ac37b22b9a2", + "sha256": "fe2aef8ad7a9f8306802a4b826b192de63dcf5a980343966773698c37cf90da6" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0-cp37-cp37m-win_amd64.whl", + "has_sig": false, + "md5_digest": "8d1a7aef326a04ca3a695ac37b22b9a2", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 13626126, + "upload_time": "2019-05-30T18:36:30", + "upload_time_iso_8601": "2019-05-30T18:36:30.472375Z", + "url": "https://files.pythonhosted.org/packages/e2/10/17af4ee132fd14fa17227a43f97930277eb72b97a189bbcec747588bfbdf/llvmlite-0.29.0-cp37-cp37m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "75b2c003a4626de8b90b3ed2db451915", + "sha256": "3adb0d4c9a17ad3dca82c7e88118babd61eeee0ee985ce31fa43ec27aa98c963" + }, + "downloads": -1, + "filename": "llvmlite-0.29.0.tar.gz", + "has_sig": false, + "md5_digest": "75b2c003a4626de8b90b3ed2db451915", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 109342, + "upload_time": "2019-05-30T18:37:23", + "upload_time_iso_8601": "2019-05-30T18:37:23.324569Z", + "url": "https://files.pythonhosted.org/packages/aa/48/f05704c49e9b7a092d6f1799f924bb5bf60ba58c08f946bcacd139809f2c/llvmlite-0.29.0.tar.gz" + } + ], + "0.30.0": [ + { + "comment_text": "", + "digests": { + "md5": "4b7e2187228ad6b170d5e692dbe81dfb", + "sha256": "965fc64a2f5ca38326d7755e6b1447c3d85bb8bd043907d4dc3eff337d1f3a5d" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp27-cp27m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "4b7e2187228ad6b170d5e692dbe81dfb", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 15919639, + "upload_time": "2019-10-10T19:14:52", + "upload_time_iso_8601": "2019-10-10T19:14:52.042780Z", + "url": "https://files.pythonhosted.org/packages/96/99/f7aed0fe4482f33f6e7282e398ed6b46c242fa69df44e554af463308ccd4/llvmlite-0.30.0-cp27-cp27m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "462a6e1e71b37cff8b57cf978f152d07", + "sha256": "d5a8b571f333c5bd6ca26092faec6b728e40c1a7d7c24ff4d9b8cf2a9799852c" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "462a6e1e71b37cff8b57cf978f152d07", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 20539095, + "upload_time": "2019-10-10T19:15:11", + "upload_time_iso_8601": "2019-10-10T19:15:11.562284Z", + "url": "https://files.pythonhosted.org/packages/3e/3b/9ecf9411d334edfda2fd8b2123483d25e05dc91f8bdef697237d89658ac4/llvmlite-0.30.0-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "ed2742f1d816c988d6da69f6102c156c", + "sha256": "c3f3c64be18b754175b78ab76e0f11d9d9ec11832fbc4ed15329dd52b2d6d40f" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "ed2742f1d816c988d6da69f6102c156c", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 20166082, + "upload_time": "2019-10-10T19:15:18", + "upload_time_iso_8601": "2019-10-10T19:15:18.582240Z", + "url": "https://files.pythonhosted.org/packages/b9/8f/94b6cec780a65fa9091df7d1a8b066d3642435108caaaed5ab2c64448d6f/llvmlite-0.30.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "0bd5e3b34d5945e3e0d5a874ae737f17", + "sha256": "6667551d737e31d7134c731bddf2c9177cc9bcac72da7b16999098218272fc0b" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp27-cp27m-win32.whl", + "has_sig": false, + "md5_digest": "0bd5e3b34d5945e3e0d5a874ae737f17", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 10598651, + "upload_time": "2019-10-10T19:15:00", + "upload_time_iso_8601": "2019-10-10T19:15:00.885806Z", + "url": "https://files.pythonhosted.org/packages/74/b5/07704ca1290796c18bf59d0b6638777364b49e7afe101b88e0aee2941ab3/llvmlite-0.30.0-cp27-cp27m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "4dabab4dbb6fdba78899f8d85db1b572", + "sha256": "327558ee71574ecd813b3feb3ffd1f5c32a20595f2c7d02b503aafa55d79285a" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp27-cp27m-win_amd64.whl", + "has_sig": false, + "md5_digest": "4dabab4dbb6fdba78899f8d85db1b572", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 13628627, + "upload_time": "2019-10-10T19:15:05", + "upload_time_iso_8601": "2019-10-10T19:15:05.842282Z", + "url": "https://files.pythonhosted.org/packages/47/27/5951e3fbf9d4ea2985dbbc2614775e1ce5610e55d1a46ed12b643d5a42e0/llvmlite-0.30.0-cp27-cp27m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "fadb3153c9d8a2dec4a1f3a14fd0929a", + "sha256": "8523c21b2ace8bf5ee2dfeb86c9703714be43ce93fa99e29143d25f1ef01b51e" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp35-cp35m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "fadb3153c9d8a2dec4a1f3a14fd0929a", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 15918420, + "upload_time": "2019-10-10T19:15:24", + "upload_time_iso_8601": "2019-10-10T19:15:24.749175Z", + "url": "https://files.pythonhosted.org/packages/ba/1e/5fbd5e03713bffde84e33e0b3e3028b0ba28c9bf3874937dbc4a1b45080e/llvmlite-0.30.0-cp35-cp35m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c0fe78c14085d6bf06eb445d526dd8ed", + "sha256": "327161412337f9e14e3a5babcfcfa4e7e6aa89cf1400fdbe162a4e19e6418013" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "c0fe78c14085d6bf06eb445d526dd8ed", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 20539062, + "upload_time": "2019-10-10T19:15:31", + "upload_time_iso_8601": "2019-10-10T19:15:31.814007Z", + "url": "https://files.pythonhosted.org/packages/f6/3c/76a26b5a26969d1d97c06c3a768d2a24c364f96694be10d8c46eda5ce2ff/llvmlite-0.30.0-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "0a74cb101021bf983b4e01c57e3d7907", + "sha256": "81db97d407012f474097c644cb689e4c4649ebf66a018cfa2b7580b1e5417677" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "0a74cb101021bf983b4e01c57e3d7907", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 20166082, + "upload_time": "2019-10-10T19:15:37", + "upload_time_iso_8601": "2019-10-10T19:15:37.981604Z", + "url": "https://files.pythonhosted.org/packages/46/76/2e5470636f57e88ba4a128457137cd6c2ca3c7e834f03b8890242b2df1b6/llvmlite-0.30.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "d755a95858a354e26c0000b9b47d1d12", + "sha256": "4f0bfd1cb98d4d240275ec83876e10f9b9d31e758e8464135c46a257b9837649" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp35-cp35m-win32.whl", + "has_sig": false, + "md5_digest": "d755a95858a354e26c0000b9b47d1d12", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 10597386, + "upload_time": "2019-10-10T19:15:47", + "upload_time_iso_8601": "2019-10-10T19:15:47.109453Z", + "url": "https://files.pythonhosted.org/packages/db/2a/60ee2642595f4d916486097d4d9665e8fb78d671fef2374b3899ca98214f/llvmlite-0.30.0-cp35-cp35m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1f0e063d8a4155d123c4a7baa55295cb", + "sha256": "dab58e45c0ef5bd47f657fa5ff2e7341846798632517aa319368c998fe994c4e" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp35-cp35m-win_amd64.whl", + "has_sig": false, + "md5_digest": "1f0e063d8a4155d123c4a7baa55295cb", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 13627366, + "upload_time": "2019-10-10T19:15:52", + "upload_time_iso_8601": "2019-10-10T19:15:52.691953Z", + "url": "https://files.pythonhosted.org/packages/1a/73/aeb0adc325bff9a927b9db12a9033ea98bd7de1000d6e490802f9625f3c2/llvmlite-0.30.0-cp35-cp35m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1a9bcc8fbf6e82bbae793f93a5ba6b94", + "sha256": "1ad4f3462169884b087a9c300db26841b20d996e9f07652ca7178f9a0296ffc4" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp36-cp36m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "1a9bcc8fbf6e82bbae793f93a5ba6b94", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 15919640, + "upload_time": "2019-10-10T19:15:59", + "upload_time_iso_8601": "2019-10-10T19:15:59.148223Z", + "url": "https://files.pythonhosted.org/packages/b4/6e/9dfac2466a7c920acb85ef6a061d8453b851bb06e5c8ac6cc6cdaf2e37c4/llvmlite-0.30.0-cp36-cp36m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "bdf9e374b4fa941d337c37d237a55665", + "sha256": "692ad0a0012f2cefe17b7bd0a0fddc903f9c6b2047a8e8fdb7a8f4e4b1f6cf95" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "bdf9e374b4fa941d337c37d237a55665", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 20539081, + "upload_time": "2019-10-10T19:16:05", + "upload_time_iso_8601": "2019-10-10T19:16:05.919643Z", + "url": "https://files.pythonhosted.org/packages/0f/c5/0900b446d216e2b29f0a4a6eb8b4abe12ef2d969ae575eef180632f65070/llvmlite-0.30.0-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "0e18097770392e0d9b19a61701c8cba2", + "sha256": "4386c310138aa381bace2a88ddf743ec944d11687e9a98777266abc66c8e53ee" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "0e18097770392e0d9b19a61701c8cba2", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 20166062, + "upload_time": "2019-10-10T19:16:11", + "upload_time_iso_8601": "2019-10-10T19:16:11.769891Z", + "url": "https://files.pythonhosted.org/packages/b3/93/924788871a889ead1c115ba2d43e67932a8865d38fdb179505c99e4bb575/llvmlite-0.30.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c14eaa10f955d6ff68a36fd7a8c40465", + "sha256": "d2596ea5346f7327d2fca01e047ea9e2b0a5e60df0a112f4d88d8cd4b98bc2b5" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp36-cp36m-win32.whl", + "has_sig": false, + "md5_digest": "c14eaa10f955d6ff68a36fd7a8c40465", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 10598614, + "upload_time": "2019-10-10T19:16:16", + "upload_time_iso_8601": "2019-10-10T19:16:16.264384Z", + "url": "https://files.pythonhosted.org/packages/63/f1/6214f4bd210391eb7c34c113c240d5f7e3a2fef466a40509ddd94fab02c6/llvmlite-0.30.0-cp36-cp36m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c6083bac402552f63e74260964c88df3", + "sha256": "a63fa4a09a2292d9b5a166e45c9feb65299a0520ba46f42af0b0a467329883e5" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp36-cp36m-win_amd64.whl", + "has_sig": false, + "md5_digest": "c6083bac402552f63e74260964c88df3", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 13628594, + "upload_time": "2019-10-10T19:16:20", + "upload_time_iso_8601": "2019-10-10T19:16:20.938963Z", + "url": "https://files.pythonhosted.org/packages/44/60/894615d70d4bfbb9d6b035354b5d72a2a0d5fefc579f8405d750e062cf77/llvmlite-0.30.0-cp36-cp36m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "41825625762b97f47de87aced000abe1", + "sha256": "983b5bfdce72f4008016a5d9e3bcca072ef08d13d782e45d94ef6ea32768814e" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp37-cp37m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "41825625762b97f47de87aced000abe1", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 15919639, + "upload_time": "2019-10-10T19:16:25", + "upload_time_iso_8601": "2019-10-10T19:16:25.816893Z", + "url": "https://files.pythonhosted.org/packages/ca/ba/1b1e5c4c707c082b1125c30f93887b827ee3db6a2e86184532fe529d31bd/llvmlite-0.30.0-cp37-cp37m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "042c4f34842ceae57db35c1d1825d7ad", + "sha256": "3f71e9a03da5b666ddbadf645182921fb399c7d4cf5c6660ebc456c3a491b041" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp37-cp37m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "042c4f34842ceae57db35c1d1825d7ad", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 20539077, + "upload_time": "2019-10-10T19:16:32", + "upload_time_iso_8601": "2019-10-10T19:16:32.201328Z", + "url": "https://files.pythonhosted.org/packages/ff/3c/38398cd47dd677db2a8dfe74588eee2f699d5be6f08bc119f7e76435f1ce/llvmlite-0.30.0-cp37-cp37m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "0d9ef8fe9e141910922b0a8ddf62e8d7", + "sha256": "c6daff653c0b516add52639c7b05b4176670e79cd308d53d801606b1b64bcd22" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp37-cp37m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "0d9ef8fe9e141910922b0a8ddf62e8d7", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 20166094, + "upload_time": "2019-10-10T19:16:38", + "upload_time_iso_8601": "2019-10-10T19:16:38.609695Z", + "url": "https://files.pythonhosted.org/packages/1f/3e/642ffb29ed35ca5e93f171ba327452bdee81ec76f2d711ef0f15b411928a/llvmlite-0.30.0-cp37-cp37m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1dbdcc3ce96b409f1f7c7ebc1abaa248", + "sha256": "06eb546c9d8f138dd91484e0e898cf0f10100e82f0112bb39f9fdcff18aca631" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp37-cp37m-win32.whl", + "has_sig": false, + "md5_digest": "1dbdcc3ce96b409f1f7c7ebc1abaa248", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 10598617, + "upload_time": "2019-10-10T19:16:43", + "upload_time_iso_8601": "2019-10-10T19:16:43.473617Z", + "url": "https://files.pythonhosted.org/packages/05/38/05295ddceebde072b44dbeeead2a8b598e0ec4b4a91fbd2936aefbd752aa/llvmlite-0.30.0-cp37-cp37m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "bbf1065df7ccd8c1fbd4a213091c0069", + "sha256": "960ac92388a23ea8036f7c321facd2d721952db3ee62d6aa763dc219e53aebf1" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp37-cp37m-win_amd64.whl", + "has_sig": false, + "md5_digest": "bbf1065df7ccd8c1fbd4a213091c0069", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 13628595, + "upload_time": "2019-10-10T19:16:48", + "upload_time_iso_8601": "2019-10-10T19:16:48.643839Z", + "url": "https://files.pythonhosted.org/packages/79/32/59b4f7037cb24aed86d962a805bb02319515608aa91473118c7ff3a02996/llvmlite-0.30.0-cp37-cp37m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "cb6f05ebd8985b16e2cd64296eb6f9bd", + "sha256": "4eaa398d4cafb76e2d8f30ca6ab875039a1023c91e7a690c6ddec20e58bb9a07" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0.tar.gz", + "has_sig": false, + "md5_digest": "cb6f05ebd8985b16e2cd64296eb6f9bd", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 110771, + "upload_time": "2019-10-10T19:17:58", + "upload_time_iso_8601": "2019-10-10T19:17:58.995138Z", + "url": "https://files.pythonhosted.org/packages/8b/b0/df26861e6ce2fc91c8bb93ea808fa2e631ee8a29fc4c3bc96626b78dae74/llvmlite-0.30.0.tar.gz" + } + ], + "0.4.0": [ + { + "comment_text": "", + "digests": { + "md5": "7d2b6e9edfe16df476385e3492eeac39", + "sha256": "8c1af4290db494563228cf6be8731f5069b9906e88712645a03a545822e27b16" + }, + "downloads": -1, + "filename": "llvmlite-0.4.0.tar.gz", + "has_sig": false, + "md5_digest": "7d2b6e9edfe16df476385e3492eeac39", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 69885, + "upload_time": "2015-04-13T18:37:32", + "upload_time_iso_8601": "2015-04-13T18:37:32.123239Z", + "url": "https://files.pythonhosted.org/packages/50/10/35919d99aba3da81953c05b41acd46ef8ae0b9cba22cad66954b69d4930b/llvmlite-0.4.0.tar.gz" + } + ], + "0.5.0": [ + { + "comment_text": "", + "digests": { + "md5": "0c2b2753e6cd514de607f0f2814aa00b", + "sha256": "616b0f16366dd1eec197b7067f4618c6c5183db852e7f4203862c0343ebdd31c" + }, + "downloads": -1, + "filename": "llvmlite-0.5.0.tar.gz", + "has_sig": false, + "md5_digest": "0c2b2753e6cd514de607f0f2814aa00b", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 74434, + "upload_time": "2015-06-05T18:51:11", + "upload_time_iso_8601": "2015-06-05T18:51:11.729618Z", + "url": "https://files.pythonhosted.org/packages/11/c0/1e768d5487b37d380a0aca7891f2553b7fd68649938a1fb5b1bef07bbb4d/llvmlite-0.5.0.tar.gz" + } + ], + "0.6.0": [ + { + "comment_text": "", + "digests": { + "md5": "58044c563d882d2c03de6588d9864ee4", + "sha256": "0ed6bbf850578dc99c06be3060a1067ea4993474392137760d1c020f7188a236" + }, + "downloads": -1, + "filename": "llvmlite-0.6.0.tar.gz", + "has_sig": false, + "md5_digest": "58044c563d882d2c03de6588d9864ee4", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 74834, + "upload_time": "2015-07-02T17:16:04", + "upload_time_iso_8601": "2015-07-02T17:16:04.228538Z", + "url": "https://files.pythonhosted.org/packages/55/da/1984ce6ac19940ba33568a78ca68ea3b27d2c1241afb3fc5c91987d97f7c/llvmlite-0.6.0.tar.gz" + } + ], + "0.7.0": [ + { + "comment_text": "", + "digests": { + "md5": "1826ff0edc052384f521c29206fd49df", + "sha256": "6d780980da05d2d82465991bce42c1b4625018d67feae17c672c6a9d5ad0bb1a" + }, + "downloads": -1, + "filename": "llvmlite-0.7.0.tar.gz", + "has_sig": false, + "md5_digest": "1826ff0edc052384f521c29206fd49df", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 84720, + "upload_time": "2015-08-31T17:10:29", + "upload_time_iso_8601": "2015-08-31T17:10:29.474518Z", + "url": "https://files.pythonhosted.org/packages/d4/e1/815c49ffa8d7d2899c2bd40efab1564d0f981509dfbaeb1769c465548bc4/llvmlite-0.7.0.tar.gz" + } + ], + "0.8.0": [ + { + "comment_text": "", + "digests": { + "md5": "31234966549a48f1ca8b0df70f883459", + "sha256": "a10d8d5e597c6a54ec418baddd31a51a0b7937a895d75b240d890aead946081c" + }, + "downloads": -1, + "filename": "llvmlite-0.8.0.tar.gz", + "has_sig": false, + "md5_digest": "31234966549a48f1ca8b0df70f883459", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 80497, + "upload_time": "2015-10-23T21:31:25", + "upload_time_iso_8601": "2015-10-23T21:31:25.021343Z", + "url": "https://files.pythonhosted.org/packages/31/dd/dc5e36abb391e81740ffd353faaff308b239ae4da8669fd75c6fa6424b9d/llvmlite-0.8.0.tar.gz" + } + ], + "0.9.0": [ + { + "comment_text": "", + "digests": { + "md5": "75c3d2ea8c0813404e75509bf843fe8c", + "sha256": "edf936f7c4ec7b2ad8da235a0a063e10bfab43a50395a1c8f8601a9a539ec809" + }, + "downloads": -1, + "filename": "llvmlite-0.9.0.tar.gz", + "has_sig": false, + "md5_digest": "75c3d2ea8c0813404e75509bf843fe8c", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 96549, + "upload_time": "2016-02-29T16:58:58", + "upload_time_iso_8601": "2016-02-29T16:58:58.339879Z", + "url": "https://files.pythonhosted.org/packages/97/48/3b9eba6c2f0d0211c87d6f4b1a4c89d86fbf24644d534c05ccd8a12138d4/llvmlite-0.9.0.tar.gz" + } + ] + }, + "urls": [ + { + "comment_text": "", + "digests": { + "md5": "4b7e2187228ad6b170d5e692dbe81dfb", + "sha256": "965fc64a2f5ca38326d7755e6b1447c3d85bb8bd043907d4dc3eff337d1f3a5d" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp27-cp27m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "4b7e2187228ad6b170d5e692dbe81dfb", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 15919639, + "upload_time": "2019-10-10T19:14:52", + "upload_time_iso_8601": "2019-10-10T19:14:52.042780Z", + "url": "https://files.pythonhosted.org/packages/96/99/f7aed0fe4482f33f6e7282e398ed6b46c242fa69df44e554af463308ccd4/llvmlite-0.30.0-cp27-cp27m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "462a6e1e71b37cff8b57cf978f152d07", + "sha256": "d5a8b571f333c5bd6ca26092faec6b728e40c1a7d7c24ff4d9b8cf2a9799852c" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp27-cp27mu-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "462a6e1e71b37cff8b57cf978f152d07", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 20539095, + "upload_time": "2019-10-10T19:15:11", + "upload_time_iso_8601": "2019-10-10T19:15:11.562284Z", + "url": "https://files.pythonhosted.org/packages/3e/3b/9ecf9411d334edfda2fd8b2123483d25e05dc91f8bdef697237d89658ac4/llvmlite-0.30.0-cp27-cp27mu-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "ed2742f1d816c988d6da69f6102c156c", + "sha256": "c3f3c64be18b754175b78ab76e0f11d9d9ec11832fbc4ed15329dd52b2d6d40f" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp27-cp27mu-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "ed2742f1d816c988d6da69f6102c156c", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 20166082, + "upload_time": "2019-10-10T19:15:18", + "upload_time_iso_8601": "2019-10-10T19:15:18.582240Z", + "url": "https://files.pythonhosted.org/packages/b9/8f/94b6cec780a65fa9091df7d1a8b066d3642435108caaaed5ab2c64448d6f/llvmlite-0.30.0-cp27-cp27mu-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "0bd5e3b34d5945e3e0d5a874ae737f17", + "sha256": "6667551d737e31d7134c731bddf2c9177cc9bcac72da7b16999098218272fc0b" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp27-cp27m-win32.whl", + "has_sig": false, + "md5_digest": "0bd5e3b34d5945e3e0d5a874ae737f17", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 10598651, + "upload_time": "2019-10-10T19:15:00", + "upload_time_iso_8601": "2019-10-10T19:15:00.885806Z", + "url": "https://files.pythonhosted.org/packages/74/b5/07704ca1290796c18bf59d0b6638777364b49e7afe101b88e0aee2941ab3/llvmlite-0.30.0-cp27-cp27m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "4dabab4dbb6fdba78899f8d85db1b572", + "sha256": "327558ee71574ecd813b3feb3ffd1f5c32a20595f2c7d02b503aafa55d79285a" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp27-cp27m-win_amd64.whl", + "has_sig": false, + "md5_digest": "4dabab4dbb6fdba78899f8d85db1b572", + "packagetype": "bdist_wheel", + "python_version": "cp27", + "requires_python": null, + "size": 13628627, + "upload_time": "2019-10-10T19:15:05", + "upload_time_iso_8601": "2019-10-10T19:15:05.842282Z", + "url": "https://files.pythonhosted.org/packages/47/27/5951e3fbf9d4ea2985dbbc2614775e1ce5610e55d1a46ed12b643d5a42e0/llvmlite-0.30.0-cp27-cp27m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "fadb3153c9d8a2dec4a1f3a14fd0929a", + "sha256": "8523c21b2ace8bf5ee2dfeb86c9703714be43ce93fa99e29143d25f1ef01b51e" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp35-cp35m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "fadb3153c9d8a2dec4a1f3a14fd0929a", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 15918420, + "upload_time": "2019-10-10T19:15:24", + "upload_time_iso_8601": "2019-10-10T19:15:24.749175Z", + "url": "https://files.pythonhosted.org/packages/ba/1e/5fbd5e03713bffde84e33e0b3e3028b0ba28c9bf3874937dbc4a1b45080e/llvmlite-0.30.0-cp35-cp35m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c0fe78c14085d6bf06eb445d526dd8ed", + "sha256": "327161412337f9e14e3a5babcfcfa4e7e6aa89cf1400fdbe162a4e19e6418013" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp35-cp35m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "c0fe78c14085d6bf06eb445d526dd8ed", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 20539062, + "upload_time": "2019-10-10T19:15:31", + "upload_time_iso_8601": "2019-10-10T19:15:31.814007Z", + "url": "https://files.pythonhosted.org/packages/f6/3c/76a26b5a26969d1d97c06c3a768d2a24c364f96694be10d8c46eda5ce2ff/llvmlite-0.30.0-cp35-cp35m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "0a74cb101021bf983b4e01c57e3d7907", + "sha256": "81db97d407012f474097c644cb689e4c4649ebf66a018cfa2b7580b1e5417677" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp35-cp35m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "0a74cb101021bf983b4e01c57e3d7907", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 20166082, + "upload_time": "2019-10-10T19:15:37", + "upload_time_iso_8601": "2019-10-10T19:15:37.981604Z", + "url": "https://files.pythonhosted.org/packages/46/76/2e5470636f57e88ba4a128457137cd6c2ca3c7e834f03b8890242b2df1b6/llvmlite-0.30.0-cp35-cp35m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "d755a95858a354e26c0000b9b47d1d12", + "sha256": "4f0bfd1cb98d4d240275ec83876e10f9b9d31e758e8464135c46a257b9837649" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp35-cp35m-win32.whl", + "has_sig": false, + "md5_digest": "d755a95858a354e26c0000b9b47d1d12", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 10597386, + "upload_time": "2019-10-10T19:15:47", + "upload_time_iso_8601": "2019-10-10T19:15:47.109453Z", + "url": "https://files.pythonhosted.org/packages/db/2a/60ee2642595f4d916486097d4d9665e8fb78d671fef2374b3899ca98214f/llvmlite-0.30.0-cp35-cp35m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1f0e063d8a4155d123c4a7baa55295cb", + "sha256": "dab58e45c0ef5bd47f657fa5ff2e7341846798632517aa319368c998fe994c4e" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp35-cp35m-win_amd64.whl", + "has_sig": false, + "md5_digest": "1f0e063d8a4155d123c4a7baa55295cb", + "packagetype": "bdist_wheel", + "python_version": "cp35", + "requires_python": null, + "size": 13627366, + "upload_time": "2019-10-10T19:15:52", + "upload_time_iso_8601": "2019-10-10T19:15:52.691953Z", + "url": "https://files.pythonhosted.org/packages/1a/73/aeb0adc325bff9a927b9db12a9033ea98bd7de1000d6e490802f9625f3c2/llvmlite-0.30.0-cp35-cp35m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1a9bcc8fbf6e82bbae793f93a5ba6b94", + "sha256": "1ad4f3462169884b087a9c300db26841b20d996e9f07652ca7178f9a0296ffc4" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp36-cp36m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "1a9bcc8fbf6e82bbae793f93a5ba6b94", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 15919640, + "upload_time": "2019-10-10T19:15:59", + "upload_time_iso_8601": "2019-10-10T19:15:59.148223Z", + "url": "https://files.pythonhosted.org/packages/b4/6e/9dfac2466a7c920acb85ef6a061d8453b851bb06e5c8ac6cc6cdaf2e37c4/llvmlite-0.30.0-cp36-cp36m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "bdf9e374b4fa941d337c37d237a55665", + "sha256": "692ad0a0012f2cefe17b7bd0a0fddc903f9c6b2047a8e8fdb7a8f4e4b1f6cf95" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp36-cp36m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "bdf9e374b4fa941d337c37d237a55665", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 20539081, + "upload_time": "2019-10-10T19:16:05", + "upload_time_iso_8601": "2019-10-10T19:16:05.919643Z", + "url": "https://files.pythonhosted.org/packages/0f/c5/0900b446d216e2b29f0a4a6eb8b4abe12ef2d969ae575eef180632f65070/llvmlite-0.30.0-cp36-cp36m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "0e18097770392e0d9b19a61701c8cba2", + "sha256": "4386c310138aa381bace2a88ddf743ec944d11687e9a98777266abc66c8e53ee" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp36-cp36m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "0e18097770392e0d9b19a61701c8cba2", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 20166062, + "upload_time": "2019-10-10T19:16:11", + "upload_time_iso_8601": "2019-10-10T19:16:11.769891Z", + "url": "https://files.pythonhosted.org/packages/b3/93/924788871a889ead1c115ba2d43e67932a8865d38fdb179505c99e4bb575/llvmlite-0.30.0-cp36-cp36m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c14eaa10f955d6ff68a36fd7a8c40465", + "sha256": "d2596ea5346f7327d2fca01e047ea9e2b0a5e60df0a112f4d88d8cd4b98bc2b5" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp36-cp36m-win32.whl", + "has_sig": false, + "md5_digest": "c14eaa10f955d6ff68a36fd7a8c40465", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 10598614, + "upload_time": "2019-10-10T19:16:16", + "upload_time_iso_8601": "2019-10-10T19:16:16.264384Z", + "url": "https://files.pythonhosted.org/packages/63/f1/6214f4bd210391eb7c34c113c240d5f7e3a2fef466a40509ddd94fab02c6/llvmlite-0.30.0-cp36-cp36m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "c6083bac402552f63e74260964c88df3", + "sha256": "a63fa4a09a2292d9b5a166e45c9feb65299a0520ba46f42af0b0a467329883e5" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp36-cp36m-win_amd64.whl", + "has_sig": false, + "md5_digest": "c6083bac402552f63e74260964c88df3", + "packagetype": "bdist_wheel", + "python_version": "cp36", + "requires_python": null, + "size": 13628594, + "upload_time": "2019-10-10T19:16:20", + "upload_time_iso_8601": "2019-10-10T19:16:20.938963Z", + "url": "https://files.pythonhosted.org/packages/44/60/894615d70d4bfbb9d6b035354b5d72a2a0d5fefc579f8405d750e062cf77/llvmlite-0.30.0-cp36-cp36m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "41825625762b97f47de87aced000abe1", + "sha256": "983b5bfdce72f4008016a5d9e3bcca072ef08d13d782e45d94ef6ea32768814e" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp37-cp37m-macosx_10_9_x86_64.whl", + "has_sig": false, + "md5_digest": "41825625762b97f47de87aced000abe1", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 15919639, + "upload_time": "2019-10-10T19:16:25", + "upload_time_iso_8601": "2019-10-10T19:16:25.816893Z", + "url": "https://files.pythonhosted.org/packages/ca/ba/1b1e5c4c707c082b1125c30f93887b827ee3db6a2e86184532fe529d31bd/llvmlite-0.30.0-cp37-cp37m-macosx_10_9_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "042c4f34842ceae57db35c1d1825d7ad", + "sha256": "3f71e9a03da5b666ddbadf645182921fb399c7d4cf5c6660ebc456c3a491b041" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp37-cp37m-manylinux1_i686.whl", + "has_sig": false, + "md5_digest": "042c4f34842ceae57db35c1d1825d7ad", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 20539077, + "upload_time": "2019-10-10T19:16:32", + "upload_time_iso_8601": "2019-10-10T19:16:32.201328Z", + "url": "https://files.pythonhosted.org/packages/ff/3c/38398cd47dd677db2a8dfe74588eee2f699d5be6f08bc119f7e76435f1ce/llvmlite-0.30.0-cp37-cp37m-manylinux1_i686.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "0d9ef8fe9e141910922b0a8ddf62e8d7", + "sha256": "c6daff653c0b516add52639c7b05b4176670e79cd308d53d801606b1b64bcd22" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp37-cp37m-manylinux1_x86_64.whl", + "has_sig": false, + "md5_digest": "0d9ef8fe9e141910922b0a8ddf62e8d7", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 20166094, + "upload_time": "2019-10-10T19:16:38", + "upload_time_iso_8601": "2019-10-10T19:16:38.609695Z", + "url": "https://files.pythonhosted.org/packages/1f/3e/642ffb29ed35ca5e93f171ba327452bdee81ec76f2d711ef0f15b411928a/llvmlite-0.30.0-cp37-cp37m-manylinux1_x86_64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "1dbdcc3ce96b409f1f7c7ebc1abaa248", + "sha256": "06eb546c9d8f138dd91484e0e898cf0f10100e82f0112bb39f9fdcff18aca631" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp37-cp37m-win32.whl", + "has_sig": false, + "md5_digest": "1dbdcc3ce96b409f1f7c7ebc1abaa248", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 10598617, + "upload_time": "2019-10-10T19:16:43", + "upload_time_iso_8601": "2019-10-10T19:16:43.473617Z", + "url": "https://files.pythonhosted.org/packages/05/38/05295ddceebde072b44dbeeead2a8b598e0ec4b4a91fbd2936aefbd752aa/llvmlite-0.30.0-cp37-cp37m-win32.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "bbf1065df7ccd8c1fbd4a213091c0069", + "sha256": "960ac92388a23ea8036f7c321facd2d721952db3ee62d6aa763dc219e53aebf1" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0-cp37-cp37m-win_amd64.whl", + "has_sig": false, + "md5_digest": "bbf1065df7ccd8c1fbd4a213091c0069", + "packagetype": "bdist_wheel", + "python_version": "cp37", + "requires_python": null, + "size": 13628595, + "upload_time": "2019-10-10T19:16:48", + "upload_time_iso_8601": "2019-10-10T19:16:48.643839Z", + "url": "https://files.pythonhosted.org/packages/79/32/59b4f7037cb24aed86d962a805bb02319515608aa91473118c7ff3a02996/llvmlite-0.30.0-cp37-cp37m-win_amd64.whl" + }, + { + "comment_text": "", + "digests": { + "md5": "cb6f05ebd8985b16e2cd64296eb6f9bd", + "sha256": "4eaa398d4cafb76e2d8f30ca6ab875039a1023c91e7a690c6ddec20e58bb9a07" + }, + "downloads": -1, + "filename": "llvmlite-0.30.0.tar.gz", + "has_sig": false, + "md5_digest": "cb6f05ebd8985b16e2cd64296eb6f9bd", + "packagetype": "sdist", + "python_version": "source", + "requires_python": null, + "size": 110771, + "upload_time": "2019-10-10T19:17:58", + "upload_time_iso_8601": "2019-10-10T19:17:58.995138Z", + "url": "https://files.pythonhosted.org/packages/8b/b0/df26861e6ce2fc91c8bb93ea808fa2e631ee8a29fc4c3bc96626b78dae74/llvmlite-0.30.0.tar.gz" + } + ] +} diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27m-macosx_10_9_x86_64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27m-macosx_10_9_x86_64.whl new file mode 100644 index 00000000..73e90bd2 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27m-macosx_10_9_x86_64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27m-win32.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27m-win32.whl new file mode 100644 index 00000000..65570ddf Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27m-win32.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27m-win_amd64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27m-win_amd64.whl new file mode 100644 index 00000000..65570ddf Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27m-win_amd64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27mu-manylinux1_i686.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27mu-manylinux1_i686.whl new file mode 100644 index 00000000..b546e0b7 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27mu-manylinux1_i686.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27mu-manylinux1_x86_64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27mu-manylinux1_x86_64.whl new file mode 100644 index 00000000..b546e0b7 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp27-cp27mu-manylinux1_x86_64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-macosx_10_9_x86_64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-macosx_10_9_x86_64.whl new file mode 100644 index 00000000..b546e0b7 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-macosx_10_9_x86_64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-manylinux1_i686.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-manylinux1_i686.whl new file mode 100644 index 00000000..b546e0b7 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-manylinux1_i686.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-manylinux1_x86_64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-manylinux1_x86_64.whl new file mode 100644 index 00000000..b546e0b7 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-manylinux1_x86_64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-win32.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-win32.whl new file mode 100644 index 00000000..b546e0b7 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-win32.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-win_amd64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-win_amd64.whl new file mode 100644 index 00000000..b546e0b7 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp35-cp35m-win_amd64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-macosx_10_9_x86_64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-macosx_10_9_x86_64.whl new file mode 100644 index 00000000..73e90bd2 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-macosx_10_9_x86_64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-manylinux1_i686.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-manylinux1_i686.whl new file mode 100644 index 00000000..b546e0b7 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-manylinux1_i686.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-manylinux1_x86_64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-manylinux1_x86_64.whl new file mode 100644 index 00000000..b546e0b7 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-manylinux1_x86_64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-win32.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-win32.whl new file mode 100644 index 00000000..73e90bd2 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-win32.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-win_amd64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-win_amd64.whl new file mode 100644 index 00000000..73e90bd2 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp36-cp36m-win_amd64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-macosx_10_9_x86_64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-macosx_10_9_x86_64.whl new file mode 100644 index 00000000..73e90bd2 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-macosx_10_9_x86_64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-manylinux1_i686.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-manylinux1_i686.whl new file mode 100644 index 00000000..b546e0b7 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-manylinux1_i686.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-manylinux1_x86_64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-manylinux1_x86_64.whl new file mode 100644 index 00000000..b546e0b7 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-manylinux1_x86_64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-win32.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-win32.whl new file mode 100644 index 00000000..73e90bd2 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-win32.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-win_amd64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-win_amd64.whl new file mode 100644 index 00000000..73e90bd2 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp37-cp37m-win_amd64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-macosx_10_9_x86_64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-macosx_10_9_x86_64.whl new file mode 100644 index 00000000..73e90bd2 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-macosx_10_9_x86_64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-manylinux1_i686.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-manylinux1_i686.whl new file mode 100644 index 00000000..b546e0b7 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-manylinux1_i686.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-manylinux1_x86_64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-manylinux1_x86_64.whl new file mode 100644 index 00000000..b546e0b7 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-manylinux1_x86_64.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-win32.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-win32.whl new file mode 100644 index 00000000..73e90bd2 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-win32.whl differ diff --git a/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-win_amd64.whl b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-win_amd64.whl new file mode 100644 index 00000000..73e90bd2 Binary files /dev/null and b/tests/fixtures/wheels/llvmlite/llvmlite-0.30.0-cp38-cp38-win_amd64.whl differ diff --git a/tests/unit/test_metadata.py b/tests/unit/test_metadata.py new file mode 100644 index 00000000..13dd7402 --- /dev/null +++ b/tests/unit/test_metadata.py @@ -0,0 +1,65 @@ +# -*- coding=utf-8 -*- +import io +import json +import zipfile + +import pytest + +import requirementslib.models.metadata + + +@pytest.mark.parametrize( + "package_json", [{"name": "celery"}, {"name": "llvmlite"},], indirect=True, +) +def test_metadata(monkeypatch_wheel_download, package_json): + package = requirementslib.models.metadata.Package.from_json(package_json) + package = package.get_dependencies() + deps = sorted([str(d.requirement) for d in package.dependencies]) + if package.name == "llvmlite": + assert list(set(deps)) == ["enum34"] + elif package.name == "celery": + assert list(deps) == [ + "Django>=1.11", + "PyYAML>=3.10", + "azure-common==1.1.5", + "azure-storage-common==1.1.0", + "azure-storage==0.36.0", + "backports.lzma", + "billiard<4.0,>=3.6.1", + "boto3>=1.9.125", + "boto3>=1.9.178", + 'brotli>=1.0.0; platform_python_implementation == "CPython"', + 'brotlipy>=0.7.0; platform_python_implementation == "PyPy"', + "cassandra-driver", + "couchbase", + 'couchbase-cffi; platform_python_implementation == "PyPy"', + "cryptography", + "elasticsearch", + "ephem", + "eventlet>=0.24.1", + "gevent", + "kazoo>=1.3.1", + "kombu<4.7,>=4.6.7", + "librabbitmq>=1.5.0", + "msgpack", + "pyArango>=1.3.2", + "pycouchdb", + "pycurl", + "pydocumentdb==2.3.2", + "pylibmc", + "pymongo[srv]>=3.3.0", + "pyro4", + "python-consul", + "python-memcached", + "pytz>dev", + "redis>=3.2.0", + "riak>=2.0", + "softlayer-messaging>=1.0.3", + "sqlalchemy", + "tblib>=1.3.0", + "tblib>=1.5.0", + "vine==1.3.0", + "zstandard", + ] + +