{
    "info": {
        "author": "Sergey Krilov",
        "author_email": "",
        "bugtrack_url": null,
        "classifiers": [
            "License :: OSI Approved :: MIT License",
            "Programming Language :: Python",
            "Programming Language :: Python :: 3",
            "Programming Language :: Python :: 3.6",
            "Programming Language :: Python :: Implementation :: CPython",
            "Programming Language :: Python :: Implementation :: PyPy"
        ],
        "description": "\n# gltflib\n\nLibrary for parsing, creating, and converting glTF 2.0 files in Python 3.6+.\n\n## Overview\n\nThis library is intended for working with glTF 2.0 at a fairly low level, meaning you are\nresponsible for managing the actual geometry data yourself. This library facilitates saving\nthis data into a properly formatted glTF/GLB file. It also helps with converting resources\ninside a glTF/GLB file between external files or web URLs, data URLs, and embedded GLB\nresources.\n\n## Installation\n\nThis library can be installed using pip:\n\n```\npip install gltflib\n```\n\n## Usage\n\nThe examples below illustrate how to use this library for a couple sample scenarios. The\nexample models come from the Khronos glTF-Sample-Models repository available here:\n\n[https://github.com/KhronosGroup/glTF-Sample-Models](https://github.com/KhronosGroup/glTF-Sample-Models)\n\n### Parsing a glTF 2.0 Model\n\nTo load a glTF 2.0 model:\n\n```python\nfrom gltflib import GLTF\n\ngltf = GLTF.load('glTF-Sample-Models/2.0/BoxTextured/glTF/BoxTextured.gltf')\n```\n\nThe `GLTF.load` static method supports loading both the JSON-based `.gltf` format, as well\nas the binary `.glb` format. The type of the file will be determined based on the filename\nextension. Alternatively, you can use `GLTF.load_gltf(filename)` or `GLTF.load_glb(filename)`.\n\nAfter loading, you can inspect the model structure by accessing the `model` property:\n\n```python\nprint(gltf.model)\n# GLTFModel(extensions=None, extras=None, accessors=[Accessor(extensions=None, extras=None, name=None, bufferView=0, byteOffset=0, componentType=5123, ...\n```\n\nYou can also inspect the various model properties:\n\n```python\nprint(gltf.model.buffers[0].uri)\n# BoxTextured0.bin\n```\n\nA glTF 2.0 model may contain resources, such as vertex geometry or image textures. These\nresources can be embedded as part of the model file, or (as with the above example) be\nreferenced as external file resources.\n\nIn either case, the resources are parsed alongside the model structure into the `resources`\nproperty after loading a model:\n\n```python\nprint(gltf.resources)\n# [FileResource(CesiumLogoFlat.png), FileResource(BoxTextured0.bin)]\n```\n\nNote that the actual content of these external file resources is *not* loaded by default\nwhen loading a model. You can load the resource into memory in one of two ways. One way\nis to call the `load()` method on the resource:\n\n```python\nresource = gltf.resources[0]\nresource.load()     # Assumes resource is a FileResource\n```\n\nAnother way is to pass the `load_file_resources` flag when calling `GLTF.load()`:\n\n```python\ngltf = GLTF.load(filename, load_file_resources=True)\n```\n\nIn either case, now the file resource data can be accessed via the `data` property:\n\n```python\nprint(resource.data)\n# b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x80?\\x00\\x00\\x00\\x00\\x00\\x00\\...\n```\n\nEmbedded resources in binary GLB files are also parsed into the `resources` list, but\nthey will be of type `GLBResource` instead of `FileResource`:\n\n```python\nglb = GLTF.load('glTF-Sample-Models/2.0/BoxTextured/glTF-Binary/BoxTextured.glb')\nprint(glb.resources)\n# [<gltflib.gltf_resource.GLBResource object at 0x7f03db7c1400>]\n```\n\nFor embedded resources, the content is parsed into memory automatically. The binary data\ncan be accessed using the `data` property:\n\n```python\nresource = glb.resources[0]\nprint(resource.data)\n# b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x80?\\x00\\x00\\x00\\x00\\x00\\x00\\...'\n```\n\n### Exporting a glTF 2.0 Model\n\nTo export a model, call the `GLTF.export()` instance method in the `GLTF` class.\n\nThe example below creates a simple glTF 2.0 mode in memory (consisting of a single\ntriangle), then exports it as a glTF file named `triangle.gltf` (alongside with an\nexternal file resource named `vertices.bin`):\n\n```python\nimport struct\nimport operator\nfrom gltflib import (\n    GLTF, GLTFModel, Asset, Scene, Node, Mesh, Primitive, Attributes, Buffer, BufferView, Accessor, AccessorType,\n    BufferTarget, ComponentType, GLBResource, FileResource)\n\nvertices = [\n    (-4774424.719997984, 4163079.2597148907, 671001.6353722484),\n    (-4748098.650098154, 4163079.259714891, 837217.8990777463),\n    (-4689289.5292739635, 4246272.966707474, 742710.4976137652)\n]\n\nvertex_bytearray = bytearray()\nfor vertex in vertices:\n    for value in vertex:\n        vertex_bytearray.extend(struct.pack('f', value))\nbytelen = len(vertex_bytearray)\nmins = [min([operator.itemgetter(i)(vertex) for vertex in vertices]) for i in range(3)]\nmaxs = [max([operator.itemgetter(i)(vertex) for vertex in vertices]) for i in range(3)]\nmodel = GLTFModel(\n    asset=Asset(version='2.0'),\n    scenes=[Scene(nodes=[0])],\n    nodes=[Node(mesh=0)],\n    meshes=[Mesh(primitives=[Primitive(attributes=Attributes(POSITION=0))])],\n    buffers=[Buffer(byteLength=bytelen, uri='vertices.bin')],\n    bufferViews=[BufferView(buffer=0, byteOffset=0, byteLength=bytelen, target=BufferTarget.ARRAY_BUFFER.value)],\n    accessors=[Accessor(bufferView=0, byteOffset=0, componentType=ComponentType.FLOAT.value, count=len(vertices),\n                        type=AccessorType.VEC3.value, min=mins, max=maxs)]\n)\n\nresource = FileResource('vertices.bin', data=vertex_bytearray)\ngltf = GLTF(model=model, resources=[resource])\ngltf.export('triangle.gltf')\n```\n\nAs with `load`, the `export` method infers the format based on the filename extension\n(`.gltf` vs `.glb`). However, you can also call `export_gltf` or `export_glb` to manually\nforce the format.\n\nIn the above example, the export will produce two files: `triangle.gltf` and `vertices.bin`.\nHowever, it is possible to bypass saving external file resources by setting the\n`save_file_resources` flag to `False` when calling `export`:\n\n```python\ngltf.export('triangle.gltf', save_file_resources=False)\n```\n\nTo export the model as a binary GLB instead, simply change the extension when calling\n`export`, or use `export_glb`:\n\n```python\ngltf.export('triangle.glb')\n```\n\nNote that when exporting as a GLB, all resources will be embedded by default (even if\nthey were instantiated as a `FileResource`). This is generally the desired behavior when\nsaving as a GLB.\n\nHowever, it is possible to force some or all resources to remain external when exporting\na GLB. To do so, you must call `export_glb` (instead of `export`), and setting either\n`embed_buffer_resources` or `embed_image_resources` (or both) to `False`:\n\n```python\nresource = FileResource('vertices.bin', data=vertex_bytearray)\ngltf = GLTF(model=model, resources=[resource])\ngltf.export_glb('triangle.glb', embed_buffer_resources=False, embed_image_resources=False)\n```\n\nIn this case, you will also need to ensure that the associated buffers still have the\nappropriate `uri` set in the model:\n\n```python\nmodel = GLTFModel(\n    ...,\n    buffers=[Buffer(byteLength=bytelen, uri='vertices.bin')],\n```\n\nThe model will be exported as a binary GLB, but with external file resources. These\nfile resources will be saved by default when exporting the model. However, it is also\npossible to bypass saving external file resources by setting the `save_file_resources`\nto `False` when calling `export_glb`:\n\n```python\ngltf.export_glb('triangle.glb', embed_buffer_resources=False, embed_image_resources=False,\n                save_file_resources=False)\n```\n\n### Converting Between glTF and GLB\n\nTo convert a glTF model to GLB, simply load it and export it using the `glb` extension:\n\n```python\nfrom gltflib import GLTF\n\ngltf = GLTF.load('glTF-Sample-Models/2.0/BoxTextured/glTF/BoxTextured.gltf')\ngltf.export('BoxTextured.glb')\n```\n\nThis will automatically convert all external file resources to become embedded GLB\nresources.\n\nThe reverse conversion is also possible, though with some caveats. Since a non-binary\nglTF model may not have embedded binary data, the `GLBResource` must first be converted\nto a different resource type. The section on **Resources** below goes into more details,\nbut here is a quick example where the `GLBResource` is first converted to a `FileResource`\nwith the filename `BoxTextured.bin` prior to exporting to glTF:\n\n```python\nfrom gltflib import GLTF\n\ngltf = GLTF.load('glTF-Sample-Models/2.0/BoxTextured/glTF-Binary/BoxTextured.glb')\nglb_resource = gltf.get_glb_resource()\ngltf.convert_to_file_resource(glb_resource, 'BoxTextured.bin')\ngltf.export('BoxTextured.gltf')\n```\n\nNote that a GLB file typically contains a single binary GLB chunk that combines data\nfrom multiple buffers (which are then consumed by multiple buffer views, images, and\naccessors). Currently, when converting a GLB to glTF, the entire GLB chunk can be\nconverted to a resource of a different type, but the resource cannot be split out into\nmultiple resources (e.g., separate resource per buffer).\n\n### Resources\n\nglTF and GLB models can refer to embedded or external resources (via the buffer or image\nURIs, or in the case of GLB, by leaving the first buffer's URI undefined). These\nresources are represented in this library using subclasses of the `GLTFResource` base\nclass. These resources will be parsed when loading a model, and must be properly\ninstantiated and added to the model prior to exporting.\n\nThere are 4 resource types that are supported by this library:\n\n* `FileResource`: File resources are resources that refer to a file path.\n* `Base64Resource`: Resources that are embedded directly in the glTF (or GLB) file\nusing a Base64-encoded data URI.\n* `GLBResource`: Used only by GLB files, this resource type represents the binary GLB\nchunk that is embedded directly in the GLB file.\n* `ExternalResource`: External resources refer to external web URLs.\n\nA reference to a particular resource can be obtained if its URI is known by\ncalling `get_resource`:\n\n```python\ngltf = GLTF.load('glTF-Sample-Models/2.0/BoxTextured/glTF/BoxTextured.gltf')\nlogo = gltf.get_resource('CesiumLogoFlat.png')\nprint(logo)\n# FileResource(CesiumLogoFlat.png)\n```\n\nAlternatively, a list of all resources in a model can be obtained using the\n`resources` list on the loaded model:\n\n```python\ngltf = GLTF.load('glTF-Sample-Models/2.0/BoxTextured/glTF/BoxTextured.gltf')\nprint(gltf.resources)\n# [FileResource(CesiumLogoFlat.png), FileResource(BoxTextured0.bin)]\n```\n\nThe `GLTF` class provides helper methods that can be used to convert a resource\nfrom one type to another. Some of these methods require some additional information\nto do the conversion; for instance, the filename when converting to a `FileResource`,\nor the MIME type when converting to a `Base64Resource`.\n\nThe sections below go into more detail about each resource type, including their\ncaveats and limitations, as well as how to convert a given resource to that type.\n\n#### File Resources\n\nFile resources are denoted using the `FileResource` class, and represent resources\nthat refer to a file path (generally a relative path, though absolute file paths are\nalso supported).\n\nWhen loading a model, these resources are parsed by looking at the `uri` property on\nbuffers and images; however, their content is not automatically loaded unless the\n`load_file_resources` flag is set to `True` when calling `GLTF.load()`:\n\n```python\ngltf = GLTF.load(filename, load_file_resources=True)\n```\n\nAlternatively, the `load()` method can be called on a `FileResource` instance to load\nthe data into memory:\n\n```python\nresource = FileResource('triangleWithoutIndices.bin')\nresource.load()\n```\n\nOnce the file resource is loaded into memory, its content is accessible via the `data`\nproperty:\n\n```python\nprint(resource.data)\n# b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x80?\\x00\\x00\\x00\\x00\\x00\\x00\\...\n```\n\nWhen exporting a model, file resources will be written to disk by default. However,\nthis can be bypassed by setting the `save_file_resources` flag `False` when calling\n`export`:\n\n```python\ngltf.export(filename, save_file_resources=False)\n```\n\nWhen creating a model instance manually, if the intention is to also save file\nresources, then there must be a corresponding `FileResource` in the `resources`\nlist for every buffer or image that references a file path (otherwise, an error\nwill be raised when attempting to export):\n\n```python\nresource = FileResource('buffer.bin')\nmodel = GLTFModel(asset=Asset(version='2.0'), buffers=[Buffer(uri='buffer.bin', byteLength=18)])\ngltf = GLTF(model=model, resources=[resource])\ngltf.export('model.gltf')\n```\n\nWhen instantiating a `FileResource`, if the content of the file is known, it can\nbe provided via the `data` constructor parameter:\n\n```python\nresource = FileResource('buffer.bin', data=b'binary content here')\n```\n\nA resource of another type can be converted to a `FileResource` using the\n`convert_to_file_resource` helper method on the GLTF class. This method\nrequires a filename as a parameter, and returns the converted `FileResource`\ninstance:\n\n```python\nresource = gltf.resources[0]\nfile_resource = gltf.convert_to_file_resource(resource, 'BoxTextured.bin')\n```\n\nNote the file will not be created until the model is saved (with `save_file_resources`\nflag set to `True`). Also, note that the resource to be converted must be\npart of the `resources` list in the model (otherwise an error will be raised).\n\nIf the resource is already a `FileResource` and the filename matches, no action\nis performed. If the filename is different, then the filename will be updated\non any buffers and images that reference it.\n\nIf the resource to be converted is a `GLBResource` or `Base64Resource`, it will be\nun-embedded and converted to an external file resource, and any buffers that reference\nthe resource will be updated appropriately. Any embedded images that reference the\nresource will be updated. If the image previously referenced a buffer view, it will\nnow reference a URI instead; the corresponding buffer view will be removed if no\nother parts of the model refer to it. Further, after removing the buffer view, if\nno other buffer views refer to the same buffer, then the buffer will be removed as\nwell.\n\nIf the resource to be converted is an `ExternalResource`, this method will raise an\nerror (accessing external resource data is not supported).\n\n#### Base-64 (Data URI) Resources\n\nglTF supports embedding a resource directly into a JSON-based glTF file (or a GLB\nfile, though it's not as common) using a\n[data URI](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs).\nIn this scenario, the resource is defined as part of the URI itself, allowing the\nmodel to be self-contained without necessarily using the GLB format:\n\n```\n{\n  ...\n  \"images\": [\n    {\n      \"uri\": \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAEDW...\"\n    }\n  ],\n  ...\n}\n```\n\nWhen loading such a model, a resource of type `Base64Resource` will be instantiated\nand added to the model's `resources` list. The `uri` property of the resource will\ncontain the original data URI, while the `data` property can be used to access the\ndecoded binary data:\n\n```python\ngltf = GLTF.load('glTF-Sample-Models/2.0/BoxTextured/glTF-Embedded/BoxTextured.gltf')\nlogo = gltf.resources[1]\nprint(logo.data)\n# b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x80?\\x00\\x00\\x00\\x00\\x00\\x00\\...\n```\n\nTo instantiate a `Base64Resource`, there are two options. One is to use the\nconstructor to pass in the binary data and MIME type (which defaults to\n`application/octet-stream` if not provided):\n\n```python\nresource = Base64Resource(b'sample binary data', mime_type='application/octet-stream')\n```\n\nThe other way is to use the `Base64Resource.from_uri` factory method and pass\nin the data URI:\n\n```python\nresource = Base64Resource.from_uri('data:application/octet-stream;base64,c2FtcGxlIGJpbmFyeSBkYXRh')\n```\n\nTo convert a resource of another type to a `Base64Resource`, use the\n`GLTF.convert_to_base64_resource` helper method. This method accepts an optional\n`mime_type` parameter if the MIME type of the original resource is known (defaults\nto `application/octet-stream` if not provided):\n\n```python\ngltf = GLTF.load('glTF-Sample-Models/2.0/BoxTextured/glTF/BoxTextured.gltf')\nlogo = gltf.get_resource('CesiumLogoFlat.png')\ngltf.convert_to_base64_resource(logo, 'image/png')\ngltf.export('BoxTexturedBase64.gltf')\n```\n\nIf the resource to be converted is already a `Base64Resource`, no action is performed.\n\nIf the resource is a `FileResource`, then it will be converted to a `Base64Resource`.\nThe data for the `FileResource` will be loaded from disk if not already loaded (which\nmay raise an `IOError` if the file does not exist).\n\nIf the resource is a `GLBResource`, it will be converted to a `Base64Resource`. The\nGLB buffer will be replaced with a buffer with a data URI (or removed entirely if it\nis only used by images). Any images that refer to the resource via a buffer view will\ninstead refer to the image directly via a data URI, and the corresponding buffer view\nwill be removed (if it is not also referenced elsewhere). Further, if no other buffer\nviews refer to the same buffer as the removed buffer view, then the buffer will be\nremoved entirely as well.\n\nIf the resource is an `ExternalResource`, this method will raise an error (accessing\nexternal resource data is not supported).\n\n#### GLB Resources\n\nGLB Resources are resources that are embedded directly in a GLB file as binary\nchunks. These resources can only be used with a GLB file (if saving to glTF, these\nresources must first be converted to a different type).\n\nThere is generally one GLB chunk in a file (with the chunk type `BIN`), though it\nis valid to have multiple GLB chunks if they have a different chunk type. This\nlibrary supports loading and saving these additional GLB chunks, though no\nassumptions are made about their content.\n\nA reference to the `GLBResource` corresponding to the primary GLB chunk (with the\nchunk type `BIN`) can be obtained by calling `get_glb_resource` on a model\ninstance, and its data can be accessed via the `data` property:\n\n```python\ngltf = GLTF.load('glTF-Sample-Models/2.0/BoxTextured/glTF-Binary/BoxTextured.glb')\nglb_resource = gltf.get_glb_resource()\nprint(glb_resource.data)\n# b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x80?\\x00\\x00\\x00\\x00\\x00\\x00\\...\n```\n\nAdditional GLB chunks can be referenced by calling `get_glb_resource` with a\n`resource_type` parameter set to the chunk type:\n\n```python\nmy_custom_glb_resource = gltf.get_glb_resource(resource_type=123)\n```\n\nAn individual resource of another type can be converted to a `GLBResource` using\nthe `embed_resource` helper method. This allows embedding a particular resource\nwhile leaving others external when exporting to GLB (in this scenario, ensure\nto use `export_glb` instead of `export`, and set both `embed_buffer_resources`\nand `embed_image_resources` to `False` to prevent the other resources from also\nbeing automatically embedded):\n\n```python\ngltf = GLTF.load('glTF-Sample-Models/2.0/BoxTextured/glTF-Binary/BoxTextured.glb')\nlogo = gltf.get_resource('CesiumLogoFlat.png')\ngltf.embed_resource(logo)\ngltf.export_glb('BoxTexturedPartial.glb', embed_buffer_resources=False, embed_image_resources=False)\n```\n\nHowever, the most common scenario is to embed all resources regardless of their\ntype, which happens automatically when calling `export` with a `.glb` extension\n(or when calling `export_glb` with the default set of parameters).\n\nNote that embedding an `ExternalResource` is not supported because its data is\nnot accessible (this library does not support loading resources from an external\nweb URL).\n\nAs explained in the other sections, converting a `GLBResource` to a resource of\nanother type (i.e., \"un-embedding\" a resource) will typically not only replace\nthe URIs on the corresponding buffers and images, but may also result in removing\nthe GLB buffer and buffer views entirely if they are not also referenced elsewhere.\n\n#### External Resources\n\nExternal resources (represented by the `ExternalResource` class) are resources\nthat have an external web URL. While this library is able to load models with\nexternal web URLs, the resource itself will not be fetched. A resource of type\n`ExternalResource` will be instantiated with the corresponding URI, but the\nlibrary will not perform any web requests to load the resource data. Likewise,\nthe library supports saving a model containing `ExternalResource` instances,\nbut again, no web requests will be performed.\n\nA resource of another type can be converted to an `ExternalResource` using the\n`GLTF.convert_to_external_resource` helper method, which accepts a URL:\n\n```python\ngltf = GLTF.load('glTF-Sample-Models/2.0/BoxTextured/glTF/BoxTextured.gltf')\nlogo = gltf.get_resource('CesiumLogoFlat.png')\ngltf.convert_to_external_resource(logo, 'http://www.example.com/image.png')\ngltf.export('BoxTexturedExternal.gltf')\n```\n\nAgain, since this library does not handle calling out to external resources,\nthis is strictly a bookkeeping operation. It is the responsibility of the caller\nto ensure that the resource exists externally. Note when converting a resource\nto an `ExternalResource`, the resource data becomes inaccessible.\n\nIf the resource is already an `ExternalResource` and the URI matches, no action\nis performed. If the URI is different, then the URI will be updated on the resource\ninstance as well as on any corresponding buffers or images in the model.\n\nIf the resource is a `FileResource` or `Base64Resource`, then it will be converted\nto an `ExternalResource`, and all buffers and images will be updated appropriately.\n\nIf the resource is a `GLBResource`, it will be converted to an `ExternalResource`.\nThe GLB buffer will be replaced with a buffer with a data URI (or removed entirely\nif it is only used by images). Any images that refer to the resource via a buffer\nview will instead refer to the image directly via a data URI, and the corresponding\nbuffer view will be removed (if it is not also referenced elsewhere). Further, if\nno other buffer views refer to the same buffer as the removed buffer view, then the\nbuffer will be removed entirely as well.\n\n## Credits\n\nThis project is based on the `pygltflib` library by\n[dodgyville](https://gitlab.com/dodgyville) available here:\n\nhttps://gitlab.com/dodgyville/pygltflib\n\nSpecifically, this project is based on a much earlier version of `pygltflib` at a\ntime when it didn't seem to be actively maintained. I used that library as a\nstarting point and added some features I needed for my own work. Since then, the\noriginal `pygltflib` project has been revived, but our implementations have\ndiverged significantly. So now there are two :-)\n\n\n",
        "description_content_type": "text/markdown",
        "docs_url": null,
        "download_url": "",
        "downloads": {
            "last_day": -1,
            "last_month": -1,
            "last_week": -1
        },
        "home_page": "http://github.com/sergkr/gltflib",
        "keywords": "",
        "license": "MIT",
        "maintainer": "",
        "maintainer_email": "",
        "name": "gltflib",
        "package_url": "https://pypi.org/project/gltflib/",
        "platform": "",
        "project_url": "https://pypi.org/project/gltflib/",
        "project_urls": {
            "Homepage": "http://github.com/sergkr/gltflib"
        },
        "release_url": "https://pypi.org/project/gltflib/1.0.1/",
        "requires_dist": [
            "dataclasses (>=0.6)",
            "dataclasses-json (>=0.2.2)"
        ],
        "requires_python": ">=3.6.0",
        "summary": "Library for parsing, creating, and converting glTF 2.0 files in Python.",
        "version": "1.0.1"
    },
    "last_serial": 5796710,
    "releases": {
        "1.0.0": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "061470c97f55da3ffa67edf48fb1fab8",
                    "sha256": "ce6d71e158c19801ad85fb3ea7c4b1ede0bc4daa2d8c5ee5010f9a9e21e621f5"
                },
                "downloads": -1,
                "filename": "gltflib-1.0.0-py3-none-any.whl",
                "has_sig": false,
                "md5_digest": "061470c97f55da3ffa67edf48fb1fab8",
                "packagetype": "bdist_wheel",
                "python_version": "py3",
                "requires_python": ">=3.6.0",
                "size": 43347,
                "upload_time": "2019-06-03T01:20:40",
                "url": "https://files.pythonhosted.org/packages/81/5e/103f745bf38ffe9accd883102945488dddd10b56213dba19c3cc1fb4c118/gltflib-1.0.0-py3-none-any.whl"
            },
            {
                "comment_text": "",
                "digests": {
                    "md5": "c8e276eb368c1b753b0732f49ec42808",
                    "sha256": "9200b8c26c0e78496695887f985ad744874335ee57fe8127ac0a1a97a07badea"
                },
                "downloads": -1,
                "filename": "gltflib-1.0.0.tar.gz",
                "has_sig": false,
                "md5_digest": "c8e276eb368c1b753b0732f49ec42808",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": ">=3.6.0",
                "size": 35545,
                "upload_time": "2019-06-03T01:20:42",
                "url": "https://files.pythonhosted.org/packages/ac/d2/350053e1f7bcdf87212db2dd3c871a56721ebe251387b6f9a4abd923fa56/gltflib-1.0.0.tar.gz"
            }
        ],
        "1.0.1": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "f7c68cfc14f3357a5673e0d2b416a716",
                    "sha256": "db66a72e5e4abd029e18f49ef11414382b5207e4a2624173f993685ccff1caec"
                },
                "downloads": -1,
                "filename": "gltflib-1.0.1-py3-none-any.whl",
                "has_sig": false,
                "md5_digest": "f7c68cfc14f3357a5673e0d2b416a716",
                "packagetype": "bdist_wheel",
                "python_version": "py3",
                "requires_python": ">=3.6.0",
                "size": 43334,
                "upload_time": "2019-09-07T16:58:25",
                "url": "https://files.pythonhosted.org/packages/94/0d/a92b4c499c8ea0a497e3dd04bb79c9a5055fe28bf532b1e5a353c7dcf4f0/gltflib-1.0.1-py3-none-any.whl"
            },
            {
                "comment_text": "",
                "digests": {
                    "md5": "1376b2a09a097895c3934285ce737d8d",
                    "sha256": "c3dcc853116c5d1f79d0fd1459f5516a6e6d48dd61226c8094f201cfb2e8bbad"
                },
                "downloads": -1,
                "filename": "gltflib-1.0.1.tar.gz",
                "has_sig": false,
                "md5_digest": "1376b2a09a097895c3934285ce737d8d",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": ">=3.6.0",
                "size": 35822,
                "upload_time": "2019-09-07T16:58:26",
                "url": "https://files.pythonhosted.org/packages/2e/65/4e0812a190711f76cdad8733bebbf62dd35880fae172f17e9f0fdfeb5935/gltflib-1.0.1.tar.gz"
            }
        ]
    },
    "urls": [
        {
            "comment_text": "",
            "digests": {
                "md5": "f7c68cfc14f3357a5673e0d2b416a716",
                "sha256": "db66a72e5e4abd029e18f49ef11414382b5207e4a2624173f993685ccff1caec"
            },
            "downloads": -1,
            "filename": "gltflib-1.0.1-py3-none-any.whl",
            "has_sig": false,
            "md5_digest": "f7c68cfc14f3357a5673e0d2b416a716",
            "packagetype": "bdist_wheel",
            "python_version": "py3",
            "requires_python": ">=3.6.0",
            "size": 43334,
            "upload_time": "2019-09-07T16:58:25",
            "url": "https://files.pythonhosted.org/packages/94/0d/a92b4c499c8ea0a497e3dd04bb79c9a5055fe28bf532b1e5a353c7dcf4f0/gltflib-1.0.1-py3-none-any.whl"
        },
        {
            "comment_text": "",
            "digests": {
                "md5": "1376b2a09a097895c3934285ce737d8d",
                "sha256": "c3dcc853116c5d1f79d0fd1459f5516a6e6d48dd61226c8094f201cfb2e8bbad"
            },
            "downloads": -1,
            "filename": "gltflib-1.0.1.tar.gz",
            "has_sig": false,
            "md5_digest": "1376b2a09a097895c3934285ce737d8d",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": ">=3.6.0",
            "size": 35822,
            "upload_time": "2019-09-07T16:58:26",
            "url": "https://files.pythonhosted.org/packages/2e/65/4e0812a190711f76cdad8733bebbf62dd35880fae172f17e9f0fdfeb5935/gltflib-1.0.1.tar.gz"
        }
    ]
}