{
"info": {
"author": "Mauricio Villegas",
"author_email": "mauricio@omnius.com",
"bugtrack_url": null,
"classifiers": [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: MacOS",
"Operating System :: POSIX :: Linux",
"Operating System :: Unix",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3 :: Only"
],
"description": ".. image:: https://circleci.com/gh/omni-us/jsonargparse.svg?style=svg\n :target: https://circleci.com/gh/omni-us/jsonargparse\n.. image:: https://badge.fury.io/py/jsonargparse.svg\n :target: https://badge.fury.io/py/jsonargparse\n.. image:: https://img.shields.io/badge/contributions-welcome-brightgreen.svg\n :target: https://github.com/omni-us/jsonargparse\n\n\njsonargparse (former yamlargparse)\n==================================\n\nhttps://omni-us.github.io/jsonargparse/\n\nThis module is an extension to python's argparse which simplifies parsing of\nconfiguration options from command line arguments, json supersets (`yaml\n`__ or `jsonnet `__) configuration files,\nenvironment variables and hard-coded defaults.\n\nThe aim is similar to other projects such as `configargparse\n`__, `yconf\n`__ and `confuse\n`__. The obvious question is, why yet another\nmodule similar to many already existing ones? The answer is simply that none of\nthe existing projects had the exact features we wanted and after analyzing the\nalternatives it seemed simpler to create a new module.\n\n\nFeatures\n========\n\n- Parsers are configured just like with python's argparse, thus it has a gentile learning curve.\n\n- Not exclusively intended for parsing command line arguments. The main focus is parsing yaml or jsonnet configuration files and not necessarily from a command line tool.\n\n- Support for nested namespaces which makes it possible to parse config files with non-flat hierarchies.\n\n- Support for two popular supersets of json, making config files more versatile and powerful.\n\n- Parsing of relative paths within config files and path lists.\n\n- Several convenient action classes to ease common parsing use cases (paths, comparison operators, json schemas, ...).\n\n- Default behavior is not identical to argparse, though it is possible to configure it to be identical. The main differences are:\n\n - When parsing fails `ParserError` is raised, instead of printing usage and program exit.\n - To modify the behavior for parsing errors (e.g. print usage) an error handler function can be provided.\n\n- Configuration values are overridden based on the following precedence.\n\n - **Parsing command line:** command line arguments (might include config file) > environment variables > default config file > defaults.\n - **Parsing files:** config file > environment variables > default config file > defaults.\n - **Parsing environment:** environment variables > default config file > defaults.\n\n\nBasic usage\n===========\n\nA parser is created just like it is done with argparse. You import the module,\ncreate a parser object and then add arguments to it. A simple example would be:\n\n.. code-block:: python\n\n import jsonargparse\n parser = jsonargparse.ArgumentParser(\n prog='app',\n description='Description for my app.')\n\n parser.add_argument('--opt1',\n type=int,\n default=0,\n help='Help for option 1.')\n\n parser.add_argument('--opt2',\n type=float,\n default=1.0,\n help='Help for option 2.')\n\n\nAfter creating the parser, you can use it to parse command line arguments with\nthe `jsonargparse.ArgumentParser.parse_args` function, after which you get\nan object with the parsed values or defaults available as attributes. For\nillustrative purposes giving to `parse_args` a list of arguments (instead\nof automatically getting them from the command line arguments), with the parser\nfrom above you would observe:\n\n.. code-block:: python\n\n >>> cfg = parser.parse_args(['--opt2', '2.3'])\n >>> cfg.opt1, type(cfg.opt1)\n (0, )\n >>> cfg.opt2, type(cfg.opt2)\n (2.3, )\n\nIf the parsing fails a `ParserError` is raised, so depending on the use case it\nmight be necessary to catch it.\n\n.. code-block:: python\n\n >>> try:\n ... cfg = parser.parse_args(['--opt2', 'four'])\n ... except jsonargparse.ParserError as ex:\n ... print('parser error: '+str(ex))\n ...\n parser error: argument --opt2: invalid float value: 'four'\n\nTo get the default behavior of argparse the ArgumentParser can be initialized as\nfollows:\n\n.. code-block:: python\n\n parser = jsonargparse.ArgumentParser(\n prog='app',\n error_handler='usage_and_exit_error_handler',\n description='Description for my app.')\n\n\n.. _nested-namespaces:\n\nNested namespaces\n=================\n\nA difference with respect to the basic argparse is that it by using dot notation\nin the argument names, you can define a hierarchy of nested namespaces. So for\nexample you could do the following:\n\n.. code-block:: python\n\n >>> parser = jsonargparse.ArgumentParser(prog='app')\n >>> parser.add_argument('--lev1.opt1', default='from default 1')\n >>> parser.add_argument('--lev1.opt2', default='from default 2')\n >>> cfg = parser.get_defaults()\n >>> cfg.lev1.opt1\n 'from default 2'\n >>> cfg.lev1.opt2\n 'from default 2'\n\n\nEnvironment variables\n=====================\n\nThe jsonargparse parsers can also get values from environment variables. The\nparser checks existing environment variables whose name is of the form\n:code:`[PREFIX_][LEV__]*OPT`, that is all in upper case, first a prefix (set by\n:code:`env_prefix`, or if unset the :code:`prog` without extension) followed by\nunderscore and then the argument name replacing dots with two underscores. Using\nthe parser from the `nested-namespaces` section above, in your shell you\nwould set the environment variables as:\n\n.. code-block:: bash\n\n export APP_LEV1__OPT1='from env 1'\n export APP_LEV1__OPT2='from env 2'\n\nThen in python the parser would use these variables, unless overridden by the\ncommand line arguments, that is:\n\n.. code-block:: python\n\n >>> parser = jsonargparse.ArgumentParser(env_prefix='app', default_env=True)\n >>> parser.add_argument('--lev1.opt1', default='from default 1')\n >>> parser.add_argument('--lev1.opt2', default='from default 2')\n >>> cfg = parser.parse_args(['--lev1.opt1', 'from arg 1'])\n >>> cfg.lev1.opt1\n 'from arg 1'\n >>> cfg.lev1.opt2\n 'from env 2'\n\nNote that when creating the parser, :code:`default_env=True` was given as\nargument. By default `jsonargparse.ArgumentParser.parse_args` does not\ncheck environment variables, so it has to be enabled explicitly.\n\nThere is also the `jsonargparse.ArgumentParser.parse_env` function to only\nparse environment variables, which might be useful for some use cases in which\nthere is no command line call involved.\n\n\nYAML files\n==========\n\nAn important feature of this module is the parsing of yaml files. The dot\nnotation hierarchy of the arguments (see `nested-namespaces`) are\nused for the expected structure of the yaml files.\n\nWhen creating the `.ArgumentParser` the :code:`default_config_files`\nargument can be given to specify patterns to search for configuration files.\nOnly the first matched config file is parsed.\n\nWhen parsing command line arguments, it is possible to add a yaml configuration\nfile path argument. The yaml file would be read and parsed in the specific\nposition among the command line arguments, so the arguments after would override\nthe values from the yaml file. Again using the parser from the\n`nested-namespaces` section above, for example we could have the\nfollowing yaml:\n\n.. code-block:: yaml\n\n # File: example.yaml\n lev1:\n opt1: from yaml 1\n opt2: from yaml 2\n\nThen in python adding a yaml file argument and parsing some example arguments,\nthe following would be observed:\n\n.. code-block:: python\n\n >>> parser = jsonargparse.ArgumentParser()\n >>> parser.add_argument('--lev1.opt1', default='from default 1')\n >>> parser.add_argument('--lev1.opt2', default='from default 2')\n >>> parser.add_argument('--cfg', action=jsonargparse.ActionConfigFile)\n >>> cfg = parser.parse_args(['--lev1.opt1', 'from arg 1', '--cfg', 'example.yaml', '--lev1.opt2', 'from arg 2'])\n >>> cfg.lev1.opt1\n 'from yaml 1'\n >>> cfg.lev1.opt2\n 'from arg 2'\n\nInstead of providing a path to a configuration file, a string with the\nconfiguration content can also be provided.\n\n.. code-block:: python\n\n >>> cfg = parser.parse_args(['--cfg', '{\"lev1\":{\"opt1\":\"from string 1\"}}'])\n >>> cfg.lev1.opt1\n 'from string 1'\n\nA configuration file or string can also be parsed without parsing command line\narguments. The functions for this are\n`jsonargparse.ArgumentParser.parse_path` and\n`jsonargparse.ArgumentParser.parse_string` to parse a config file or a\nconfig contained in a string respectively.\n\n\nJson schemas\n============\n\nThe `.ActionJsonSchema` class is provided to allow parsing and validation\nof values using a json schema. This class requires the `jsonschema\n`__ python package. Though note that\njsonschema is not a requirement of the minimal jsonargparse install. To enable\nthis functionality install the module with the *all* extras requires as:\n\n.. code-block:: bash\n\n $ pip3 install jsonargparse[all]\n\nCheck out the `jsonschema documentation\n`__ to learn how to write a schema.\nThe current version of jsonargparse uses Draft4Validator. Parsing an argument\nusing a json schema is done like in the following example:\n\n.. code-block:: python\n\n >>> schema = {\n ... \"type\" : \"object\",\n ... \"properties\" : {\n ... \"price\" : {\"type\" : \"number\"},\n ... \"name\" : {\"type\" : \"string\"},\n ... },\n ... }\n\n >>> parser.add_argument('--op', action=jsonargparse.ActionJsonSchema(schema=schema))\n\n >>> parser.parse_args(['--op', '{\"price\": 1.5, \"name\": \"cookie\"}'])\n namespace(op=namespace(name='cookie', price=1.5))\n\nInstead of giving a json string as argument value, it is also possible to\nprovide a path to a json/yaml file, which would be loaded and validated against\nthe schema. If the schema defines default values, these will be used by the\nparser to initialize the config values that are not specified. When adding an\nargument with the `.ActionJsonSchema` action, you can use \"%s\" in the\n:code:`help` string so that in that position the schema will be printed.\n\n\nJsonnet files\n=============\n\nThe Jsonnet support requires `jsonschema\n`__ and `jsonnet\n`__ python packages which are not included\nwith minimal jsonargparse install. To enable this functionality install\njsonargparse with the *all* extras requires as:\n\n.. code-block:: bash\n\n $ pip3 install 'jsonargparse[all]'\n\nBy default an `.ArgumentParser` parses configuration files as yaml.\nHowever, if instantiated giving as argument :code:`parser_mode='jsonnet'`, then\n`parse_args`, `parse_path` and `parse_string` will expect\nconfig files to be in jsonnet format instead. Example:\n\n.. code-block:: python\n\n >>> parser = jsonargparse.ArgumentParser(parser_mode='jsonnet')\n >>> parser.add_argument('--cfg', action=jsonargparse.ActionConfigFile)\n >>> cfg = parser.parse_args(['--cfg', 'example.jsonnet'])\n\nJsonnet files are commonly parametrized, thus requiring external variables for\nparsing. For these cases, instead of changing the parser mode away from yaml,\nthe `.ActionJsonnet` class can be used. This action allows to define an\nargument which would be a path to a jsonnet file. Moreover, another argument can\nbe specified as the source for any external variables required, which would be\neither a path to or a string containing a json dictionary of variables. Its use\nwould be as follows:\n\n.. code-block:: python\n\n parser = ArgumentParser()\n parser.add_argument('--in_ext_vars',\n action=jsonargparse.ActionJsonnetExtVars)\n parser.add_argument('--in_jsonnet',\n action=jsonargparse.ActionJsonnet(ext_vars='in_ext_vars'))\n\nFor example, if a jsonnet file required some external variable :code:`param`,\nthen the jsonnet and the external variable could be given as:\n\n.. code-block:: python\n\n cfg = parser.parse_args(['--in_ext_vars', '{\"param\": 123}', '--in_jsonnet', 'path_to_jsonnet'])\n\nNote that the external variables argument must be provided before the jsonnet\npath so that this dictionary already exists when parsing the jsonnet.\n\nThe `.ActionJsonnet` class also accepts as argument a json schema, in\nwhich case the jsonnet would be validated against this schema right after\nparsing.\n\n\nParsing paths\n=============\n\nFor some use cases it is necessary to parse file paths, checking its existence\nand access permissions, but not necessarily opening the file. Moreover, a file\npath could be included in a config file as relative with respect to the config\nfile's location. After parsing it should be easy to access the parsed file path\nwithout having to consider the location of the config file. To help in these\nsituations jsonargparse includes the `.ActionPath` and the\n`.ActionPathList` classes.\n\nFor example suppose you have a directory with a configuration file\n:code:`app/config.yaml` and some data :code:`app/data/info.db`. The contents of\nthe yaml file is the following:\n\n.. code-block:: yaml\n\n # File: config.yaml\n databases:\n info: data/info.db\n\nTo create a parser that checks that the value of :code:`databases.info` exists\nand is readable, the following could be done:\n\n.. code-block:: python\n\n >>> parser = jsonargparse.ArgumentParser()\n >>> parser.add_argument('--databases.info', action=jsonargparse.ActionPath(mode='fr'))\n >>> cfg = parser.parse_path('app/config.yaml')\n\nAfter parsing it is possible to get both the original relative path as included\nin the yaml file, or the corresponding absolute path:\n\n.. code-block:: python\n\n >>> cfg.databases.info(absolute=False)\n 'data/info.db'\n >>> cfg.databases.info()\n '/YOUR_CWD/app/data/info.db'\n\nLikewise directories can also be parsed by including in the mode the :code:`'d'`\nflag, e.g. :code:`ActionPath(mode='drw')`.\n\nAn argument with `.ActionPath` can be given :code:`nargs='+'` to parse\nmultiple paths. But it might also be wanted to parse a list of paths found in a\nplain text file or from stdin. For this the `.ActionPathList` is used and\nas argument either the path to a file listing the paths is given or the special\n:code:`'-'` string for reading the list from stdin. For for example:\n\n.. code-block:: python\n\n >>> parser.add_argument('--list', action=jsonargparse.ActionPathList(mode='fr'))\n >>> cfg = parser.parse_args(['--list', 'paths.lst') # Text file with paths\n >>> cfg = parser.parse_args(['--list', '-') # List from stdin\n\nIf :code:`nargs='+'` is given to :code:`add_argument` then a single list is\ngenerated including all paths in all lists provided.\n\n\nComparison operators\n====================\n\nIt is quite common that when parsing a number, its range should be limited. To\nease these cases the module includes the `.ActionOperators`. Some\nexamples of arguments that can be added using this action are the following:\n\n.. code-block:: python\n\n # Larger than zero\n parser.add_argument('--op1', action=jsonargparse.ActionOperators(expr=('>', 0)))\n # Between 0 and 10\n parser.add_argument('--op2', action=jsonargparse.ActionOperators(expr=[('>=', 0), ('<=', 10)]))\n # Either larger than zero or 'off' string\n def int_or_off(x): return x if x == 'off' else int(x)\n parser.add_argument('--op3', action=jsonargparse.ActionOperators(expr=[('>', 0), ('==', 'off')], join='or', type=int_or_off))\n\n\nBoolean arguments\n=================\n\nParsing boolean arguments is very common, however, the original argparse only\nhas a limited support for them, via :code:`store_true` and :code:`store_false`.\nFuthermore unexperienced users might mistakenly use :code:`type=bool` which\nwould not provide the intended behavior.\n\nWith jsonargparse adding an argument with :code:`type=bool` the intended action\nis implemented. If given as values :code:`{'yes', 'true'}` or :code:`{'no',\n'false'}` the corresponding parsed values would be :code:`True` or\n:code:`False`. For example:\n\n.. code-block:: python\n\n >>> parser.add_argument('--op1', type=bool, default=False)\n >>> parser.add_argument('--op2', type=bool, default=True)\n >>> parser.parse_args(['--op1', 'yes', '--op2', 'false'])\n namespace(op1=True, op2=False)\n\nSometimes it is also useful to define two paired options, one to set\n:code:`True` and the other to set :code:`False`. The `.ActionYesNo` class\nmakes this straightforward. A couple of examples would be:\n\n.. code-block:: python\n\n # --opt1 for true and --no_opt1 for false.\n parser.add_argument('--op1', action=jsonargparse.ActionYesNo)\n # --with-opt2 for true and --without-opt2 for false.\n parser.add_argument('--with-op2', action=jsonargparse.ActionYesNo(yes_prefix='with-', no_prefix='without-'))\n\nIf the `.ActionYesNo` class is used in conjunction with\n:code:`nargs='?'` the options can also be set by giving as value any of\n:code:`{'true', 'yes', 'false', 'no'}`.\n\n\nContributing\n============\n\nContributions to the jsonargparse package are very welcome, be it just to create\n`issues `_ for reporting bugs\nand proposing enhancements, or more directly by creating `pull requests\n`_.\n\nIf you intend to work with the source code, note that this project does not\ninclude any :code:`requirements.txt` file. This is by intention. To make it very\nclear what are the requirements for different use cases, all the requirements of\nthe project are stored in the file :code:`setup.cfg`. The basic runtime\nrequirements are defined in section :code:`[options]` in the\n:code:`install_requires` entry. All optional requirements are stored in section\n:code:`[options.extras_require]` in the :code:`all` entry. And finally there is\na :code:`dev` entry in the same :code:`[options.extras_require]` section which\nlists requirements for development.\n\nThe recommended way to work with the source code is the following. First clone\nthe repository, then create a virtual environment, activate it and finally\ninstall the development requirements. More precisely the steps would be:\n\n.. code-block:: bash\n\n git clone https://github.com/omni-us/jsonargparse.git\n cd jsonargparse\n virtualenv -p python3 venv\n . venv/bin/activate\n\nThe crucial step is installing the requirements which would be done by running:\n\n.. code-block:: bash\n\n pip install --editable .[dev,all]\n\n\n",
"description_content_type": "",
"docs_url": null,
"download_url": "",
"downloads": {
"last_day": -1,
"last_month": -1,
"last_week": -1
},
"home_page": "https://omni-us.github.io/jsonargparse",
"keywords": "",
"license": "MIT",
"maintainer": "",
"maintainer_email": "",
"name": "jsonargparse",
"package_url": "https://pypi.org/project/jsonargparse/",
"platform": "any",
"project_url": "https://pypi.org/project/jsonargparse/",
"project_urls": {
"CircleCI": "https://circleci.com/gh/omni-us/jsonargparse",
"Documentation": "https://omni-us.github.io/jsonargparse",
"GitHub": "https://github.com/omni-us/jsonargparse",
"Homepage": "https://omni-us.github.io/jsonargparse",
"PyPI": "https://pypi.org/project/jsonargparse"
},
"release_url": "https://pypi.org/project/jsonargparse/2.9.0/",
"requires_dist": [
"PyYAML (>=3.13)",
"jsonschema (>=2.6.0) ; extra == 'all'",
"jsonnet (>=0.13.0) ; extra == 'all'",
"bump2version (>=0.5.11) ; extra == 'bump'",
"twine (>=1.12.1) ; extra == 'bump'",
"coverage (>=4.5.1) ; extra == 'dev'",
"pylint (>=1.8.3) ; extra == 'dev'",
"pycodestyle (>=2.5.0) ; extra == 'dev'",
"mypy (>=0.701) ; extra == 'dev'",
"Sphinx (>=1.7.9) ; extra == 'dev'",
"sphinx-rtd-theme (>=0.4.3) ; extra == 'dev'",
"autodocsumm (>=0.1.10) ; extra == 'dev'"
],
"requires_python": ">=3.4",
"summary": "Parsing of command line options, yaml/jsonnet config files and/or environment variables based on argparse.",
"version": "2.9.0"
},
"last_serial": 5955563,
"releases": {
"2.0.0": [
{
"comment_text": "",
"digests": {
"md5": "3a74c7ce03ba25c1ac360c96482efdd9",
"sha256": "6070a2f5f83ad542936495fc5862959ae10cfc44050b307977d566e0df978adb"
},
"downloads": -1,
"filename": "jsonargparse-2.0.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "3a74c7ce03ba25c1ac360c96482efdd9",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.5",
"size": 20557,
"upload_time": "2019-08-26T16:36:38",
"url": "https://files.pythonhosted.org/packages/54/9f/0e9d2c372212dd7a9c061dc5a1b168cbd1747cc4f6664ce8668cbe20f20e/jsonargparse-2.0.0-py3-none-any.whl"
}
],
"2.1.0": [
{
"comment_text": "",
"digests": {
"md5": "52644611d974c21405744adf6c5eadde",
"sha256": "7892130a64e7c9236c3fb244c7de30d24a41f1820a7683d9995895c7b1582cd5"
},
"downloads": -1,
"filename": "jsonargparse-2.1.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "52644611d974c21405744adf6c5eadde",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.5",
"size": 21532,
"upload_time": "2019-08-27T06:07:29",
"url": "https://files.pythonhosted.org/packages/75/1c/1024001ca903a5e2d68e9d80756e23b3785e0eee46fb17523cc7b3c9ea80/jsonargparse-2.1.0-py3-none-any.whl"
}
],
"2.1.1": [
{
"comment_text": "",
"digests": {
"md5": "7030a1fc38751f1187ec78dedd3dda5d",
"sha256": "ae804120bfd6b626e82c1ccb940805175c2d3138aafcf97635823bdfd08dc5a3"
},
"downloads": -1,
"filename": "jsonargparse-2.1.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "7030a1fc38751f1187ec78dedd3dda5d",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.5",
"size": 21557,
"upload_time": "2019-08-31T05:59:32",
"url": "https://files.pythonhosted.org/packages/8d/f3/517d267a8d189d038ee0a7472003ebe0882c781f3c2520b3689fbd1c4fa3/jsonargparse-2.1.1-py3-none-any.whl"
}
],
"2.2.1": [
{
"comment_text": "",
"digests": {
"md5": "7e9d067d04d87549b4282e2bd25fe542",
"sha256": "f50d3e3001db207e25576e58e2e4f48ed63bd2831005c7d26676b548bed83b59"
},
"downloads": -1,
"filename": "jsonargparse-2.2.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "7e9d067d04d87549b4282e2bd25fe542",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.5",
"size": 23244,
"upload_time": "2019-09-02T06:20:03",
"url": "https://files.pythonhosted.org/packages/cf/84/dff5b43d35ac2aae5d0c65047c4bb9e3ad1d0d5a58040afd26d659921188/jsonargparse-2.2.1-py3-none-any.whl"
}
],
"2.3.0": [
{
"comment_text": "",
"digests": {
"md5": "568a34fc9c16fe0f6276690939e3b978",
"sha256": "7f1fb53f76073b59420cfe54eeed1f9007a0fa0fe7b5ac82635319d5e1b44ff1"
},
"downloads": -1,
"filename": "jsonargparse-2.3.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "568a34fc9c16fe0f6276690939e3b978",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.5",
"size": 23549,
"upload_time": "2019-09-06T04:58:25",
"url": "https://files.pythonhosted.org/packages/50/dd/d587b901fdd8c241bf56d72cdc53b791ecad35c8cdc1027e645aa5f16304/jsonargparse-2.3.0-py3-none-any.whl"
}
],
"2.4.0": [
{
"comment_text": "",
"digests": {
"md5": "51db996c51b9737f5f97ecebdc5a54e3",
"sha256": "fccee36dc606a991266113c8da6585447c568281d9d8b60d57dfa328be12caba"
},
"downloads": -1,
"filename": "jsonargparse-2.4.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "51db996c51b9737f5f97ecebdc5a54e3",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.5",
"size": 23660,
"upload_time": "2019-09-06T08:35:16",
"url": "https://files.pythonhosted.org/packages/21/0e/86f858674788b8c731301b346dabc61ff0f77c729dca133d51564ca93ec1/jsonargparse-2.4.0-py3-none-any.whl"
}
],
"2.4.1": [
{
"comment_text": "",
"digests": {
"md5": "f95de4980a68a305172e121f602d24eb",
"sha256": "1b905b720453467ede682c7169ccfd99cf96e330c413d33d2e2c4b69fd9a3493"
},
"downloads": -1,
"filename": "jsonargparse-2.4.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "f95de4980a68a305172e121f602d24eb",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.4",
"size": 23657,
"upload_time": "2019-09-06T09:49:16",
"url": "https://files.pythonhosted.org/packages/f6/86/a9eb63976dd07a5ed17959da6cfe7e17561ad642b6a513cf4e5ac8cb81fa/jsonargparse-2.4.1-py3-none-any.whl"
}
],
"2.5.0": [
{
"comment_text": "",
"digests": {
"md5": "54d446b6d04b54963f9dc28f35db6c56",
"sha256": "c208577b1fec1ac4b76c8b56f2322fa68c756f3940c206ed33842fb26f535c44"
},
"downloads": -1,
"filename": "jsonargparse-2.5.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "54d446b6d04b54963f9dc28f35db6c56",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.4",
"size": 24352,
"upload_time": "2019-09-13T04:39:34",
"url": "https://files.pythonhosted.org/packages/4f/25/997cefd4857ea4b7cc699de17e54ebcfc914553843ddb6b36033cd255031/jsonargparse-2.5.0-py3-none-any.whl"
}
],
"2.6.0": [
{
"comment_text": "",
"digests": {
"md5": "86f2ce071f256b78a169332d40f3abd6",
"sha256": "11a8b187fa47fb65637259f7767ad47de7b47e9614bf9b24d203aa6661ce166f"
},
"downloads": -1,
"filename": "jsonargparse-2.6.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "86f2ce071f256b78a169332d40f3abd6",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.4",
"size": 25307,
"upload_time": "2019-09-14T09:42:38",
"url": "https://files.pythonhosted.org/packages/f2/a9/3ca6e3bcd025f578c506368e3db17c88c7e878717c69525408602fe03968/jsonargparse-2.6.0-py3-none-any.whl"
}
],
"2.6.1": [
{
"comment_text": "",
"digests": {
"md5": "8a3abd1519a2a6ee930ebb7f2a38d8bb",
"sha256": "8171411ef0b9554adc7f4af2aea242d5a7b05c9f5a3bcad9348f9b6622b224a5"
},
"downloads": -1,
"filename": "jsonargparse-2.6.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "8a3abd1519a2a6ee930ebb7f2a38d8bb",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.4",
"size": 25305,
"upload_time": "2019-09-17T05:48:10",
"url": "https://files.pythonhosted.org/packages/34/2a/66d62ca9df43f77761160fb8ea7bcc9167a3821f19be501ed374d086cf93/jsonargparse-2.6.1-py3-none-any.whl"
}
],
"2.7.0": [
{
"comment_text": "",
"digests": {
"md5": "e72e088cd38326409ff759090f033476",
"sha256": "5a1934b3abfce97685df2a9e54cf9fc2a1c90520c13c01ed24322c586dd50cc4"
},
"downloads": -1,
"filename": "jsonargparse-2.7.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "e72e088cd38326409ff759090f033476",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.4",
"size": 25366,
"upload_time": "2019-10-07T15:03:52",
"url": "https://files.pythonhosted.org/packages/c2/a9/2daac08fa368779a0e97d1198de5676fc11f67ebdb286cc838045223a07b/jsonargparse-2.7.0-py3-none-any.whl"
}
],
"2.8.0": [
{
"comment_text": "",
"digests": {
"md5": "d5ffa9919bbf2534f51e5f7820c32e74",
"sha256": "a348f40d69c29d2bf66c9fa3786927531a04eda03649e435f6b2fdd32d240111"
},
"downloads": -1,
"filename": "jsonargparse-2.8.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "d5ffa9919bbf2534f51e5f7820c32e74",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.4",
"size": 25638,
"upload_time": "2019-10-10T05:07:14",
"url": "https://files.pythonhosted.org/packages/dd/31/5480eea20381a123cbd284effa3f4e3ade77785c765622a480a480b2dd5c/jsonargparse-2.8.0-py3-none-any.whl"
}
],
"2.9.0": [
{
"comment_text": "",
"digests": {
"md5": "2534a4428f962d54b64f6c41696bdf70",
"sha256": "28b76acc8d143c22a9be0bdfe36344aa643991be196e994d9391a4c8117addf2"
},
"downloads": -1,
"filename": "jsonargparse-2.9.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "2534a4428f962d54b64f6c41696bdf70",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.4",
"size": 25720,
"upload_time": "2019-10-10T15:41:19",
"url": "https://files.pythonhosted.org/packages/f4/ae/f149c36157c554d952d9cbe9c7978faa9b022fa237a1a0237889423ed639/jsonargparse-2.9.0-py3-none-any.whl"
}
]
},
"urls": [
{
"comment_text": "",
"digests": {
"md5": "2534a4428f962d54b64f6c41696bdf70",
"sha256": "28b76acc8d143c22a9be0bdfe36344aa643991be196e994d9391a4c8117addf2"
},
"downloads": -1,
"filename": "jsonargparse-2.9.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "2534a4428f962d54b64f6c41696bdf70",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.4",
"size": 25720,
"upload_time": "2019-10-10T15:41:19",
"url": "https://files.pythonhosted.org/packages/f4/ae/f149c36157c554d952d9cbe9c7978faa9b022fa237a1a0237889423ed639/jsonargparse-2.9.0-py3-none-any.whl"
}
]
}