{
    "info": {
        "author": "Andrew Ilyas and Logan Engstrom",
        "author_email": "ailyas@mit.edu",
        "bugtrack_url": null,
        "classifiers": [
            "Development Status :: 4 - Beta",
            "Intended Audience :: Developers",
            "License :: OSI Approved :: MIT License",
            "Programming Language :: Python :: 3",
            "Programming Language :: Python :: 3.5",
            "Programming Language :: Python :: 3.6",
            "Topic :: Software Development :: Build Tools"
        ],
        "description": "# Cox: An experimental design and analysis framework\nYou can find API Documentation on Cox [here](https://cox.readthedocs.io), along with a copy of the\nWalkthrough below.\n\n## Introduction\nCox is a lightweight, serverless framework for designing and managing\nexperiments. Inspired by our own struggles with ad-hoc filesystem-based\nexperiment collection, Cox aims\nto be a minimal burden while inducing more organization. Created by [Logan\nEngstrom](https://twitter.com/logan_engstrom) and [Andrew\nIlyas](https://twitter.com/andrew_ilyas). \n\nCox works by helping you easily __log__, __collect__, and\n__analyze__ experimental results. For API documentation, see [here](https://cox.readthedocs.io); below, we\nprovide a walkthrough that illustrates the most important features of Cox.\n\n__Why \"Cox\"? (Aside)__: The name Cox draws both from\n[Coxswain](https://en.wikipedia.org/wiki/Coxswain), the person in charge of\nsteering the boat in a rowing crew, and from the name of [Gertrude\nCox](https://en.wikipedia.org/wiki/Gertrude_Mary_Cox), a pioneer of experimental\ndesign.\n\n#### Installation\nCox can by installed via PyPI as:\n```bash\npip3 install cox\n```\n\nCox requires Python 3 and has been tested with Python 3.7.\n\n#### Citation\n```\n@unpublished{cox,\n    title={Cox: A Lightweight Experimental Design Library},\n    author={Logan Engstrom and Andrew Ilyas},\n    year={2019},\n    url={https://github.com/MadryLab/cox}\n}\n```\n\n#### Illustrative example\n```python\nimport os\nfrom cox.store import Store\nimport shutil\nimport subprocess\nfrom cox.readers import CollectionReader\n\n\"\"\"\nBackground: suppose we have two functions f(x, param) and g(x, param) that we\nwant to track as x ranges from 0 to 100, over a set of values for param. We also\nwant to visualize f(x) with TensorBoard\n\"\"\"\nOUT_DIR = ...\nPOSSIBLE_PARAM_VALUES = [...]\n\ndef f(x, param):\n    ...\n\ndef g(x, param):\n    ...\n\nfor param in POSSIBLE_PARAM_VALUES:\n    # Creates a cox.Store, which stores a set of tables and a tensorboard\n    store = Store(OUT_DIR)\n    # Create a table to store hyperparameters in for each run\n    store.add_table('metadata', {'param': float})\n    # The metadata table will just have a single row with the param stored\n    store['metadata'].append_row({'param': param})\n\n    # Create a table to store our results\n    store.add_table('results', {'f(x)': float, 'g(x)': float})\n\n    for x in range(100):\n\t# Log f(x) to the results table and to tensorboard\n\tstore.log_table_and_tb('results', {\n\t    'f(x)': f(x, param), \n\t})\n\t# Log g(x) to the table but not to TensorBoard. The working row has not\n\t# changed, so f(x) above and g(x) will be in the same row\n\tstore['results'].update_row({ 'g(x)': g(x, param) })\n\n\t# Close the working row\n\tstore['results'].flush_row()\n\n    store.close()\n\n    # Comparing results programmatically with CollectionReader\n    reader = CollectionReader(OUT_DIR)\n    df = reader.df('results')\n    m_df = reader.df('metadata')\n\n    # Filter by experiments have \"param\" less than 1.0\n    exp_ids = set(m_df[m_df['param'] < 1.0]['exp_id].tolist())\n    print(df[df['exp_id'].isin(exp_ids)]) # The filtered DataFrame\n\n    # Finding which experiment has lowest minimum f(x)\n    exp_id = df[df['results'] == min(df['results'].tolist())]['exp_id'].tolist()[0]\n    print(m_df[m_df['exp_id'] == exp_id]) # Metadata of the best experiment\n\n    # Start tensorboard to compare across parameters who match the regex REGEX\n    os.system(\"python -m cox.tensorboard_view --logdir OUT_DIR --format-str p-{param} \\ \n\t    --filter-param param REGEX --metadata-table metadata\"])\n\n```\n\n## Quick Logging Overview \nThe cox logging system is designed for dealing with repeated experiments. The\nuser defines schemas for [Pandas\ndataframes](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html)\nthat contain all the data necessary for each experiment instance. Each\nexperiment ran corresponds to a __data store__, and each specified dataframe\nfrom above corresponds to a table within this store. The experiment stores are\norganized within the same directory. Cox has a number of utilities for running\nand collecting data from experiments of this nature.\n\n## Interactive Introduction\n\nWe use Cox most in our machine learning work, but Cox is agnostic to the type or\nstyle of code that you write. To illustrate this, we go through an extremely\nsimple example in a walkthrough.\n\n## Walkthrough 1: Logging in Cox\n__Note 1__: you can view all of the components of this running example in the [example file here](examples/logging_example.py)!\n\n__Note 2__: a copy of this walkthrough is also available together with our API\ndocumentation, [here](https://cox.readthedocs.io/en/latest/)\n\nIn this walkthrough, we'll be starting with the following simple piece of code,\nwhich tries to finds the minimum of a quadratic function:\n\n```python\nimport sys\n\ndef f(x):\n    return (x - 2.03)**2 + 3\n\nx = ...\ntol = ...\nstep = ...\n\nfor _ in range(1000):\n    # Take a uniform step in the direction of decrease\n    if f(x + step) < f(x - step):\n        x += step\n    else:\n        x -= step\n\n    # If the difference between the directions\n    # is less than the tolerance, stop\n    if f(x + step) - f(x - step) < tol:\n        break\n```\n### Initializing stores\nLogging in Cox is done through the `Store` class, which can be created as follows:\n```python\nfrom cox.store import Store\n# rest of program here...\nstore = Store(OUT_DIR)\n```\n\nUpon construction, the `Store` instance creates a directory with a random `uuid`\ngenerated name in ```OUT_DIR```, a `HDFStore` for storing data, some logging\nfiles, and a tensorboard directory (named `tensorboard`). Therefore, after we run this command, our `OUT_DIR` directory should look something like this:\n\n```bash\n$ ls OUT_DIR\n7753a944-568d-4cc2-9bb2-9019cc0b3f49\n$ ls 7753a944-568d-4cc2-9bb2-9019cc0b3f49\nsave        store.h5    tensorboard\n```\n\nThe experiment ID string `7753a944-568d-4cc2-9bb2-9019cc0b3f49` was\nautogenerated. If we wanted to name the experiment something else, we could pass\nit as the second parameter; i.e. making a store with `Store(OUT_DIR, 'exp1')`\nwould make the corresponding experiment ID `exp1`.\n\n\n### Creating tables\nThe next step is to declare the data we want to store via _tables_. We can add\narbitrary tables according to our needs, but we need to specify the structure\nahead of time by passing the schema. In our case, we will start out with just a\nsimple metadata table containing the parameters used to run an instance of the\nprogram above, along with a table for writing the result:\n\n```python\nstore.add_table('metadata', {\n  'step_size': float,\n  'tolerance': float, \n  'initial_x': float,\n  'out_dir': str\n})\n\nstore.add_table('result', {\n    'final_x': float,\n    'final_opt':float\n})\n\n```\n\nEach table corresponds exactly to a [Pandas dataframe](https://pandas.pydata.org/pandas-docs/version/0.23.4/generated/pandas.DataFrame.html) found in an `HDFStore`\nobject.\n\n#### Note on serialization\nCox supports basic object types (like `float`, `int`, `str`, etc) along with any\nkind of serializable object (via `dill` or using PyTorch's serialization\nmethod). In particular, if we want to serialize an object we can pass one of the\nfollowing types: `cox.store.[OBJECT|PICKLE|PYTORCH_STATE]` as the type value\nthat is mapped to in the schema dictionary. `cox.store.PYTORCH_STATE` is\nparticularly useful for dealing with PyTorch objects like weights.\nIn detail: `OBJECT` corresponds to storing the object as a\nserialized string in the table, `PICKLE` corresponds to storing the object as a\nserialized string on disk in a separate file, and `PYTORCH_STATE` corresponds to\nstoring the object as a serialized string on disk using `torch.save`. \n\n### Logging\nNow that we have a table, we can write rows to it! Logging in Cox is done in a\nrow-by-row manner: at any time, there is a _working row_ that can be appended\nto/updated; the row can then be flushed (i.e. written to the file), which starts\na new (empty) working row. The relevant commands are:\n\n```python\n# This updates the working row, but does not write it permenantly yet!\nstore['result'].update_row({\n  \"final_x\": 3.0\n})\n\n# This updates it again\nstore['result'].update_row({\n  \"final_opt\": 3.9409\n})\n\n# Write the row permenantly, and start a new working row!\nstore['result'].flush_row()\n\n# A shortcut for appending a row directly\nstore['metadata'].append_row({\n  'step_size': 0.01,\n  'tolerance': 1e-6, \n  'initial_x': 1.0,\n  'out_dir': '/tmp/'\n}) \n```\n\n#### Incremental updates with `update_row`\nSubsequent calls to update_row will edit the same working row. \nThis is useful if different parts of the row are computed in different \nfunctions/locations in the code, as it removes the need for passing statistics \naround all over the place.\n\n### Reading data\nBy populating tables rows, we are really just adding rows to an underlying\n`HDFStore` table. If we want to read the store later, we can simply open another\nstore at the same location, and then read dataframes with simple commands:\n\n```python\n# Note that EXP_ID is the directory the store wrote to in OUT_DIR\ns = Store(OUT_DIR, EXP_ID)\n\n# Read tables we wrote earlier\nmetadata = s['metadata'].df\nresult = s['result'].df\n\nprint(result)\n```\n\nInspecting the `result` table, we see the expected result in our Pandas dataframe!\n```\n     final_x   final_opt\n0   3.000000   3.940900\n```\n\n### `CollectionReader`: Reading many experiments at once\nNow, in our quadratic example, we aren't just going to try one set of\nparameters, we are going to try a number of different values for `step_size`,\n`tolerance`, and `initial_x`, as we have not yet discovered convex optimization.\nTo do this, we just run the script above a bunch of times with the desired\nhyperparameters,  supplying the _same_ `OUT_DIR` for all of the runs (recall\nthat `cox` will automatically create different, `uuid`-named folders inside\n`OUT_DIR` for each experiment).\n\nImagine that we have done so (using any standard tool, e.g. `sbatch` in SLURM,\n`sklearn` grid search, etc.), and that we have a directory full of stores (this\nis why we use `uuid`s instead of handpicked names!):\n\n```bash\n$ ls $OUT_DIR\ndrwxr-xr-x  6 engstrom  0424807a-c9c0-4974-b881-f927fc5ae7c3\n...\n...\ndrwxr-xr-x  6 engstrom  e3646fcf-569b-46fc-aba5-1e9734fedbcf\ndrwxr-xr-x  6 engstrom  f23d6da4-e3f9-48af-aa49-82f5c017e14f\n```\n\nNow, we want to collect all the results from this directory. We can use\n`cox.readers.CollectionReader` to read all the tables together in a concatenated\n`pandas` table.\n\n```python\nfrom cox.readers import CollectionReader\nreader = CollectionReader(OUT_DIR)\nprint(reader.df('result'))\n```\n\nWhich gives us all the `result` tables concatenated together as a \n[Pandas DataFrame](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html) for easy manipulation:\n\n```\n     final_x   final_opt                                exp_id\n0   1.000000    4.060900  ed892c4f-069f-4a6d-9775-be8fdfce4713\n0   0.000010    7.120859  44ea3334-d2b4-47fe-830c-2d13dc0e7aaa\n...\n...\n0   2.000000    3.000900  f031fc42-8788-4876-8c96-2c1237ceb63d\n0 -14.000000  259.960900  73181d27-2928-48ec-9ac6-744837616c4b\n```\n\n`pandas` has a ton of powerful utilities for searching through and\nmanipulating DataFrames. We recommend looking at [their\ndocs](https://pandas.pydata.org/pandas-docs/stable/reference/api/) for\ninformation on how to do this. For convenience, we've given a few simple\nexamples below:\n\n```python\ndf = reader.df('result')\nm_df = reader.df('metadata')\n\n# Filter by experiments have step_size less than 1.0\nexp_ids = set(m_df[m_df['step_size'] < 1.0]['exp_id].tolist())\nprint(df[df['exp_id'].isin(exp_ids)]) # The filtered DataFrame\n\n# Finding which experiment has the lowest final_opt\nexp_id = df[df['final_opt'] == min(df['final_opt'].tolist())]['exp_id'].tolist()[0]\nprint(m_df[m_df['exp_id'] == exp_id]) # Metadata of the best experiment\n```\n\n## Walkthrough 2: Using `cox` with `tensorboardX`\n__Note__: As with the first walkthrough, a working example file with all of\nthese commands can be found [here](examples/tb_example.py)\n\nHere, we'll show how to use `cox` and `tensorboardX` in unison for logging.\nWe'll use the following simple running example:\n```python\nfrom cox.store import Store\n\nfor slope in range(5):\n    s = Store(OUT_DIR) # Create OUT_DIR/RANDOM_UUID\n    s.add_table('line_graphs', {'mx': int, 'mx^2': int})\n    s.add_table('metadata', {'slope': int})\n    s['metadata'].append_row({'slope': slope})\n\n    # GOAL: plot and log the lines \"y=slope*x\" and \"y=slope*x^2\"\n```\n\nAs previously mentioned, `cox.Store` objects also automatically creates a\n`tensorboard` folder that is written to via the\n[tensorboardX](https://tensorboardx.readthedocs.io/en/latest/tensorboard.html)\nlibrary. A created `cox.store.Store` object will actually a `writer` property\nthat is a fully functioning\n[SummaryWriter](https://tensorboardx.readthedocs.io/en/latest/tensorboard.html#tensorboardX.SummaryWriter)\nobject. That means we can plot the lines we want in TensorBoard as follows:\n\n```python\nfor x in range(10):\n    s.writer.add_scalar('line', slope*x, x)\n    s.writer.add_scalar('parabola', slope*(x**2), x)\n```\n\nUnfortunately, TensorBoard data is quite hard to read/manipulate through means\nother than the TensorBoard interface. For convenience, the `store` object also\nprovides the ability to write to a table and the `tensorboardX` writer at the same\ntime through the `log_table_and_tb` function, meaning that we can replace the\nabove with:\n\n```python\n# Does the same thing as the example above but also stores the results in a\n# readable 'line_graphs' table \nfor x in range(10):\n    s.log_table_and_tb('line_graphs', {'mx': slope*x, 'mx^2': slope*(x**2)})\n    s['line_graphs'].flush_row()\n```\n\n### Viewing multiple tensorboards with `cox.tensorboard_view`\n**Note: the `python -m cox.tensorboard_view` command can be called as\n`cox-tensorboard` from the command line**\n\nContinuing with our running example, we may now want to visually compare\nTensorBoards across multiple parameter settings. Fortunately, `cox`\nprovides utilities for comparing TensorBoards across experiments in a readable\nway.  In our example, where we made a `Store` object and a table\ncalled `metadata` where we stored hyperparameters. We also showed how to\nintegrate TensorBoard logging via `tensorboardX`. We'll now use the\n`cox.tensorboard-view` utility to view the tensorboards from multiple jobs at\nonce (this is useful when comparing parameters for a grid search).\n\nThe way to achieve this is through the `cox.tensorboard_view` command, which is\ncalled as `python3 -m cox.tensorboard_view` with the following arguments:\n\n- `--logdir`: **(required)**, the directory where all of the stores are located\n- `--port`: **(default 6006)**, the port on which to run the tensorboard server\n- `--metadata-table` **(default \"metadata\")**, the name of the table where the\n  hyperparameters are saved (i.e. \"metadata\" in our running example). This\nshould be a table with a single row, as in our running example.\n- `--filter-param` **(optional)** Can be used more than once, filters out stores\n  from the tensorboard aggregation. For each argument of the form\n`--filter-param PARAM_NAME PARAM_REGEX`, only the stores where `PARAM_NAME` in\nthe metadata matches `PARAM_REGEX` will be kept.\n- `--format-str` **(required)** How to display the name of the stores. Recall\n  that each store has a `uuid`-generated name by default. This argument\ndetermines how their names will be displayed in the TensorBoard. Curly braces\nrepresent parameter values, and the uuid will always be appended to the name. So\nin our running example, `--format-str ss-{step_size}` will result in a\nTensorBoard with names of the form `ss-1.0-ed892c4f-069f-4a6d-9775-be8fdfce4713`.\n\nSo in our running example, if we run the following command, displaying the slope\nin the TensorBoard names and filtering for slopes between 1 and 3:\n```bash\npython3 -m cox.tensorboard_view --logdir OUT_DIR --format-str slope-{slope} \\\n    --filter-param slope [1-3] --metadata-table metadata\n```\nor \n```bash\ncox-tensorboard --logdir OUT_DIR --format-str slope-{slope} \\\n    --filter-param slope [1-3] --metadata-table metadata\n```\nthen navigating to `localhost:6006` yields:\n\n![TensorBoard view](docs/_static/tensorboard.png)\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": "https://github.com/MadryLab/cox",
        "keywords": "logging tools madrylab",
        "license": "MIT",
        "maintainer": "",
        "maintainer_email": "",
        "name": "cox",
        "package_url": "https://pypi.org/project/cox/",
        "platform": "",
        "project_url": "https://pypi.org/project/cox/",
        "project_urls": {
            "Homepage": "https://github.com/MadryLab/cox"
        },
        "release_url": "https://pypi.org/project/cox/0.1.post3/",
        "requires_dist": [
            "tqdm",
            "grpcio",
            "psutil",
            "gitpython",
            "py3nvml"
        ],
        "requires_python": "",
        "summary": "Tools for Experiment Logging",
        "version": "0.1.post3",
        "yanked": false,
        "yanked_reason": null
    },
    "last_serial": 7630064,
    "releases": {
        "0.1": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "e47b1b0cf280f2e151fcf4d926fada5b",
                    "sha256": "b4af0c9495d322e0e534ec883fb2bb9fb7198c127a1994b34af82f5b454f3d19"
                },
                "downloads": -1,
                "filename": "cox-0.1-py3-none-any.whl",
                "has_sig": false,
                "md5_digest": "e47b1b0cf280f2e151fcf4d926fada5b",
                "packagetype": "bdist_wheel",
                "python_version": "py3",
                "requires_python": null,
                "size": 17621,
                "upload_time": "2019-08-08T15:23:46",
                "upload_time_iso_8601": "2019-08-08T15:23:46.317410Z",
                "url": "https://files.pythonhosted.org/packages/16/3b/d136631bda195e9e8165524ca3a2ef3c01cbabfbeb484702ed48c3f83ea5/cox-0.1-py3-none-any.whl",
                "yanked": false,
                "yanked_reason": null
            },
            {
                "comment_text": "",
                "digests": {
                    "md5": "53c048ced1a5221d0f3880df8beb062f",
                    "sha256": "b3f8c7d61ece436d730cab6ed6b103693b2b7137f2cc9b584ebf679a43cc7ca5"
                },
                "downloads": -1,
                "filename": "cox-0.1.tar.gz",
                "has_sig": false,
                "md5_digest": "53c048ced1a5221d0f3880df8beb062f",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 22539,
                "upload_time": "2019-08-08T15:23:50",
                "upload_time_iso_8601": "2019-08-08T15:23:50.612420Z",
                "url": "https://files.pythonhosted.org/packages/fe/27/59048f6a38ce191b454a8a5f1e42eff06b2694d037627f83e6f72af55445/cox-0.1.tar.gz",
                "yanked": false,
                "yanked_reason": null
            }
        ],
        "0.1.post1": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "b750411098e4ad51935b9400f025c415",
                    "sha256": "ac0201dd4b5d3d0057bcfc796d730f58db59e71b7ba7566f8c5df5ae2f70ee05"
                },
                "downloads": -1,
                "filename": "cox-0.1.post1-py3-none-any.whl",
                "has_sig": false,
                "md5_digest": "b750411098e4ad51935b9400f025c415",
                "packagetype": "bdist_wheel",
                "python_version": "py3",
                "requires_python": null,
                "size": 18468,
                "upload_time": "2019-10-25T17:18:31",
                "upload_time_iso_8601": "2019-10-25T17:18:31.963928Z",
                "url": "https://files.pythonhosted.org/packages/80/05/d7f4f9d7f291919c45cea15ec99228fa48a9ef78d6b405655aa6ac46e9a8/cox-0.1.post1-py3-none-any.whl",
                "yanked": false,
                "yanked_reason": null
            },
            {
                "comment_text": "",
                "digests": {
                    "md5": "e349a400de5edfbdb775d483295b9b98",
                    "sha256": "5aed8153d8e1950b6cb9da9f4e4aff00077dfd5851b6d3be330bea74cafda68a"
                },
                "downloads": -1,
                "filename": "cox-0.1.post1.tar.gz",
                "has_sig": false,
                "md5_digest": "e349a400de5edfbdb775d483295b9b98",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 22528,
                "upload_time": "2019-10-25T17:18:33",
                "upload_time_iso_8601": "2019-10-25T17:18:33.519067Z",
                "url": "https://files.pythonhosted.org/packages/0f/1a/e5bc0729d77271492982fcd7f38df3b064b9ccf250adf2f22070b6217193/cox-0.1.post1.tar.gz",
                "yanked": false,
                "yanked_reason": null
            }
        ],
        "0.1.post2": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "ccfd6167596927d35eb75c44be7c79b2",
                    "sha256": "dc2278e06113228f385c62136f6f70206c2b2c5f846929feaab6ff65e41cefa7"
                },
                "downloads": -1,
                "filename": "cox-0.1.post2-py3-none-any.whl",
                "has_sig": false,
                "md5_digest": "ccfd6167596927d35eb75c44be7c79b2",
                "packagetype": "bdist_wheel",
                "python_version": "py3",
                "requires_python": null,
                "size": 18468,
                "upload_time": "2019-10-27T23:57:52",
                "upload_time_iso_8601": "2019-10-27T23:57:52.579928Z",
                "url": "https://files.pythonhosted.org/packages/3a/42/7602dbce4bfc3740c678117c90625d552985b7f6d33423d116837a1a0777/cox-0.1.post2-py3-none-any.whl",
                "yanked": false,
                "yanked_reason": null
            },
            {
                "comment_text": "",
                "digests": {
                    "md5": "43a9a5b1039035b8cb41edd46688b795",
                    "sha256": "6aae4968eb122754b32ae76dc4f0bf21249289ffcc15d8af78faf412aba88a15"
                },
                "downloads": -1,
                "filename": "cox-0.1.post2.tar.gz",
                "has_sig": false,
                "md5_digest": "43a9a5b1039035b8cb41edd46688b795",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 24486,
                "upload_time": "2019-10-27T23:57:54",
                "upload_time_iso_8601": "2019-10-27T23:57:54.412589Z",
                "url": "https://files.pythonhosted.org/packages/20/70/00305946f99e0c25f0ffc4ea4846a8eecb63889e82acab54b00af7c2f6c3/cox-0.1.post2.tar.gz",
                "yanked": false,
                "yanked_reason": null
            }
        ],
        "0.1.post3": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "e2e98cf135ff2a129b444f38ec941ebf",
                    "sha256": "50d37d24945d8f0701e889c48964c411cd6e4a56768973a41519976ee489fa28"
                },
                "downloads": -1,
                "filename": "cox-0.1.post3-py3-none-any.whl",
                "has_sig": false,
                "md5_digest": "e2e98cf135ff2a129b444f38ec941ebf",
                "packagetype": "bdist_wheel",
                "python_version": "py3",
                "requires_python": null,
                "size": 18501,
                "upload_time": "2020-07-04T18:03:03",
                "upload_time_iso_8601": "2020-07-04T18:03:03.182019Z",
                "url": "https://files.pythonhosted.org/packages/f8/70/757ff7669cfe9f5726c991e856892c4fb98362b1f17abd34326937356729/cox-0.1.post3-py3-none-any.whl",
                "yanked": false,
                "yanked_reason": null
            },
            {
                "comment_text": "",
                "digests": {
                    "md5": "b624bc07969bf32f5b48ccc93f84188b",
                    "sha256": "baa6efce249e4f696de66df5939066f826cebe4b97379ebab8070cc15c9f812e"
                },
                "downloads": -1,
                "filename": "cox-0.1.post3.tar.gz",
                "has_sig": false,
                "md5_digest": "b624bc07969bf32f5b48ccc93f84188b",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 19728,
                "upload_time": "2020-07-04T18:03:05",
                "upload_time_iso_8601": "2020-07-04T18:03:05.261989Z",
                "url": "https://files.pythonhosted.org/packages/44/a5/1e109e189baf5c30cc57f630fd6e2b3fc68ad944008301ffd307b3cec2e1/cox-0.1.post3.tar.gz",
                "yanked": false,
                "yanked_reason": null
            }
        ]
    },
    "urls": [
        {
            "comment_text": "",
            "digests": {
                "md5": "e2e98cf135ff2a129b444f38ec941ebf",
                "sha256": "50d37d24945d8f0701e889c48964c411cd6e4a56768973a41519976ee489fa28"
            },
            "downloads": -1,
            "filename": "cox-0.1.post3-py3-none-any.whl",
            "has_sig": false,
            "md5_digest": "e2e98cf135ff2a129b444f38ec941ebf",
            "packagetype": "bdist_wheel",
            "python_version": "py3",
            "requires_python": null,
            "size": 18501,
            "upload_time": "2020-07-04T18:03:03",
            "upload_time_iso_8601": "2020-07-04T18:03:03.182019Z",
            "url": "https://files.pythonhosted.org/packages/f8/70/757ff7669cfe9f5726c991e856892c4fb98362b1f17abd34326937356729/cox-0.1.post3-py3-none-any.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": "",
            "digests": {
                "md5": "b624bc07969bf32f5b48ccc93f84188b",
                "sha256": "baa6efce249e4f696de66df5939066f826cebe4b97379ebab8070cc15c9f812e"
            },
            "downloads": -1,
            "filename": "cox-0.1.post3.tar.gz",
            "has_sig": false,
            "md5_digest": "b624bc07969bf32f5b48ccc93f84188b",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": null,
            "size": 19728,
            "upload_time": "2020-07-04T18:03:05",
            "upload_time_iso_8601": "2020-07-04T18:03:05.261989Z",
            "url": "https://files.pythonhosted.org/packages/44/a5/1e109e189baf5c30cc57f630fd6e2b3fc68ad944008301ffd307b3cec2e1/cox-0.1.post3.tar.gz",
            "yanked": false,
            "yanked_reason": null
        }
    ],
    "vulnerabilities": []
}