{ "info": { "author": "Erik Rose", "author_email": "erikrose@grinchcentral.com", "bugtrack_url": null, "classifiers": [ "Development Status :: 3 - Alpha", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Natural Language :: English", "Operating System :: OS Independent", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Topic :: Scientific/Engineering :: Information Analysis", "Topic :: Software Development :: Libraries", "Topic :: Text Processing :: General" ], "description": "============\nParsimonious\n============\n\nParsimonious aims to be the fastest arbitrary-lookahead parser written in pure\nPython\u2014and the most usable. It's based on parsing expression grammars (PEGs),\nwhich means you feed it a simplified sort of EBNF notation. Parsimonious was\ndesigned to undergird a MediaWiki parser that wouldn't take 5 seconds or a GB\nof RAM to do one page, but it's applicable to all sorts of languages.\n\n\nGoals\n=====\n\n* Speed\n* Frugal RAM use\n* Minimalistic, understandable, idiomatic Python code\n* Readable grammars\n* Extensible grammars\n* Complete test coverage\n* Separation of concerns. Some Python parsing kits mix recognition with\n instructions about how to turn the resulting tree into some kind of other\n representation. This is limiting when you want to do several different things\n with a tree: for example, render wiki markup to HTML *or* to text.\n* Good error reporting. I want the parser to work *with* me as I develop a\n grammar.\n\n\nExample Usage\n=============\n\nHere's how to build a simple grammar:\n\n.. code:: python\n\n >>> from parsimonious.grammar import Grammar\n >>> grammar = Grammar(\n ... \"\"\"\n ... bold_text = bold_open text bold_close\n ... text = ~\"[A-Z 0-9]*\"i\n ... bold_open = \"((\"\n ... bold_close = \"))\"\n ... \"\"\")\n\nYou can have forward references and even right recursion; it's all taken care\nof by the grammar compiler. The first rule is taken to be the default start\nsymbol, but you can override that.\n\nNext, let's parse something and get an abstract syntax tree:\n\n.. code:: python\n\n >>> print grammar.parse('((bold stuff))')\n \n \n \n \n\nYou'd typically then use a ``nodes.NodeVisitor`` subclass (see below) to walk\nthe tree and do something useful with it.\n\n\nStatus\n======\n\n* Everything that exists works. Test coverage is good.\n* I don't plan on making any backward-incompatible changes to the rule syntax\n in the future, so you can write grammars with confidence.\n* It may be slow and use a lot of RAM; I haven't measured either yet. However,\n I have yet to begin optimizing in earnest.\n* Error reporting is now in place. ``repr`` methods of expressions, grammars,\n and nodes are clear and helpful as well. The ``Grammar`` ones are\n even round-trippable!\n* The grammar extensibility story is underdeveloped at the moment. You should\n be able to extend a grammar by simply concatening more rules onto the\n existing ones; later rules of the same name should override previous ones.\n However, this is untested and may not be the final story.\n* Sphinx docs are coming, but the docstrings are quite useful now.\n* Note that there may be API changes until we get to 1.0, so be sure to pin to\n the version you're using.\n\nComing Soon\n-----------\n\n* Optimizations to make Parsimonious worthy of its name\n* Tighter RAM use\n* Better-thought-out grammar extensibility story\n* Amazing grammar debugging\n\n\nA Little About PEG Parsers\n==========================\n\nPEG parsers don't draw a distinction between lexing and parsing; everything is\ndone at once. As a result, there is no lookahead limit, as there is with, for\ninstance, Yacc. And, due to both of these properties, PEG grammars are easier\nto write: they're basically just a more practical dialect of EBNF. With\ncaching, they take O(grammar size * text length) memory (though I plan to do\nbetter), but they run in O(text length) time.\n\nMore Technically\n----------------\n\nPEGs can describe a superset of *LL(k)* languages, any deterministic *LR(k)*\nlanguage, and many others\u2014including some that aren't context-free\n(http://www.brynosaurus.com/pub/lang/peg.pdf). They can also deal with what\nwould be ambiguous languages if described in canonical EBNF. They do this by\ntrading the ``|`` alternation operator for the ``/`` operator, which works the\nsame except that it makes priority explicit: ``a / b / c`` first tries matching\n``a``. If that fails, it tries ``b``, and, failing that, moves on to ``c``.\nThus, ambiguity is resolved by always yielding the first successful recognition.\n\n\nWriting Grammars\n================\n\nGrammars are defined by a series of rules. The syntax should be familiar to\nanyone who uses regexes or reads programming language manuals. An example will\nserve best:\n\n.. code:: python\n\n my_grammar = Grammar(r\"\"\"\n styled_text = bold_text / italic_text\n bold_text = \"((\" text \"))\"\n italic_text = \"''\" text \"''\"\n text = ~\"[A-Z 0-9]*\"i\n \"\"\")\n\nYou can wrap a rule across multiple lines if you like; the syntax is very\nforgiving.\n\n\nSyntax Reference\n----------------\n\n==================== ========================================================\n``\"some literal\"`` Used to quote literals. Backslash escaping and Python\n conventions for \"raw\" and Unicode strings help support\n fiddly characters.\n\n[space] Sequences are made out of space- or tab-delimited\n things. ``a b c`` matches spots where those 3\n terms appear in that order.\n\n``a / b / c`` Alternatives. The first to succeed of ``a / b / c``\n wins.\n\n``thing?`` An optional expression. This is greedy, always consuming\n ``thing`` if it exists.\n\n``&thing`` A lookahead assertion. Ensures ``thing`` matches at the\n current position but does not consume it.\n\n``!thing`` A negative lookahead assertion. Matches if ``thing``\n isn't found here. Doesn't consume any text.\n\n``things*`` Zero or more things. This is greedy, always consuming as\n many repetitions as it can.\n\n``things+`` One or more things. This is greedy, always consuming as\n many repetitions as it can.\n\n``~r\"regex\"ilmsux`` Regexes have ``~`` in front and are quoted like\n literals. Any flags follow the end quotes as single\n chars. Regexes are good for representing character\n classes (``[a-z0-9]``) and optimizing for speed. The\n downside is that they won't be able to take advantage\n of our fancy debugging, once we get that working.\n Ultimately, I'd like to deprecate explicit regexes and\n instead have Parsimonious dynamically build them out of\n simpler primitives.\n\n``(things)`` Parentheses are used for grouping, like in every other\n language.\n==================== ========================================================\n\n\nOptimizing Grammars\n===================\n\nDon't Repeat Expressions\n------------------------\n\nIf you need a ``~\"[a-z0-9]\"i`` at two points in your grammar, don't type it\ntwice. Make it a rule of its own, and reference it from wherever you need it. \nYou'll get the most out of the caching this way, since cache lookups are by \nexpression object identity (for speed). \n\nEven if you have an expression that's very simple, not repeating it will \nsave RAM, as there can, at worst, be a cached int for every char in the text \nyou're parsing. In the future, we may identify repeated subexpressions \nautomatically and factor them up while building the grammar.\n\nHow much should you shove into one regex, versus how much should you break them\nup to not repeat yourself? That's a fine balance and worthy of benchmarking.\nMore stuff jammed into a regex will execute faster, because it doesn't have to\nrun any Python between pieces, but a broken-up one will give better cache\nperformance if the individual pieces are re-used elsewhere. If the pieces of a\nregex aren't used anywhere else, by all means keep the whole thing together.\n\n\nQuantifiers\n-----------\n\nBring your ``?`` and ``*`` quantifiers up to the highest level you\ncan. Otherwise, lower-level patterns could succeed but be empty and put a bunch\nof useless nodes in your tree that didn't really match anything.\n\n\nProcessing Parse Trees\n======================\n\nA parse tree has a node for each expression matched, even if it matched a\nzero-length string, like ``\"thing\"?`` might.\n\nThe ``NodeVisitor`` class provides an inversion-of-control framework for\nwalking a tree and returning a new construct (tree, string, or whatever) based\non it. For now, have a look at its docstrings for more detail. There's also a\ngood example in ``grammar.RuleVisitor``. Notice how we take advantage of nodes'\niterability by using tuple unpacks in the formal parameter lists:\n\n.. code:: python\n\n def visit_or_term(self, or_term, (slash, _, term)):\n ...\n\nFor reference, here is the production the above unpacks::\n\n or_term = \"/\" _ term\n\nWhen something goes wrong in your visitor, you get a nice error like this::\n\n [normal traceback here...]\n VisitationException: 'Node' object has no attribute 'foo'\n\n Parse tree:\n <-- *** We were here. ***\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\nThe parse tree is tacked onto the exception, and the node whose visitor method\nraised the error is pointed out.\n\nWhy No Streaming Tree Processing?\n---------------------------------\n\nSome have asked why we don't process the tree as we go, SAX-style. There are\ntwo main reasons:\n\n1. It wouldn't work. With a PEG parser, no parsing decision is final until the\n whole text is parsed. If we had to change a decision, we'd have to backtrack\n and redo the SAX-style interpretation as well, which would involve\n reconstituting part of the AST and quite possibly scuttling whatever you\n were doing with the streaming output. (Note that some bursty SAX-style\n processing may be possible in the future if we use cuts.)\n\n2. It interferes with the ability to derive multiple representations from the\n AST: for example, turning wiki markup into first HTML and then text.\n\n\nFuture Directions\n=================\n\nRule Syntax Changes\n-------------------\n\n* Maybe support left-recursive rules like PyMeta, if anybody cares.\n* Ultimately, I'd like to get rid of explicit regexes and break them into more\n atomic things like character classes. Then we can dynamically compile bits\n of the grammar into regexes as necessary to boost speed.\n\nOptimizations\n-------------\n\n* Make RAM use almost constant by automatically inserting \"cuts\", as described\n in\n http://ialab.cs.tsukuba.ac.jp/~mizusima/publications/paste513-mizushima.pdf.\n This would also improve error reporting, as we wouldn't backtrack out of\n everything informative before finally failing.\n* Find all the distinct subexpressions, and unify duplicates for a better cache\n hit ratio.\n* Think about having the user (optionally) provide some representative input\n along with a grammar. We can then profile against it, see which expressions\n are worth caching, and annotate the grammar. Perhaps there will even be\n positions at which a given expression is more worth caching. Or we could keep\n a count of how many times each cache entry has been used and evict the most\n useless ones as RAM use grows.\n* We could possibly compile the grammar into VM instructions, like in \"A\n parsing machine for PEGs\" by Medeiros.\n* If the recursion gets too deep in practice, use trampolining to dodge it.\n\nNiceties\n--------\n\n* Pijnu has a raft of tree manipulators. I don't think I want all of them, but\n a judicious subset might be nice. Don't get into mixing formatting with tree\n manipulation.\n https://github.com/erikrose/pijnu/blob/master/library/node.py#L333. PyPy's\n parsing lib exposes a sane subset:\n http://doc.pypy.org/en/latest/rlib.html#tree-transformations.\n\n\nVersion History\n===============\n\n0.8.1\n * Switch to a function-style ``print`` in the benchmark tests so we work\n cleanly as a dependency on Python 3. (Edward Betts)\n\n0.8.0\n * Make Grammar iteration ordered, making the ``__repr__`` more like the\n original input. (Lucas Wiman)\n * Improve text representation and error messages for anonymous\n subexpressions. (Lucas Wiman)\n * Expose BadGrammar and VisitationError as top-level imports.\n * No longer crash when you try to compare a Node to an instance of a\n different class. (Esben Sonne)\n * Pin ``six`` at 1.9.0 to ensure we have ``python_2_unicode_compatible``.\n (Sam Raker)\n * Drop Python 2.6 support.\n\n0.7.0\n * Add experimental token-based parsing, via TokenGrammar class, for those\n operating on pre-lexed streams of tokens. This can, for example, help parse\n indentation-sensitive languages that use the \"off-side rule\", like Python.\n (Erik Rose)\n * Common codebase for Python 2 and 3: no more 2to3 translation step (Mattias\n Urlichs, Lucas Wiman)\n * Drop Python 3.1 and 3.2 support.\n * Fix a bug in ``Grammar.__repr__`` which fails to work on Python 3 since the\n string_escape codec is gone in Python 3. (Lucas Wiman)\n * Don't lose parentheses when printing representations of expressions.\n (Michael Kelly)\n * Make Grammar an immutable mapping (until we add automatic recompilation).\n (Michael Kelly)\n\n0.6.2\n * Make grammar compilation 100x faster. Thanks to dmoisset for the initial\n patch.\n\n0.6.1\n * Fix bug which made the default rule of a grammar invalid when it\n contained a forward reference.\n\n0.6\n .. warning::\n\n This release makes backward-incompatible changes:\n\n * The ``default_rule`` arg to Grammar's constructor has been replaced\n with a method, ``some_grammar.default('rule_name')``, which returns a\n new grammar just like the old except with its default rule changed.\n This is to free up the constructor kwargs for custom rules.\n * ``UndefinedLabel`` is no longer a subclass of ``VisitationError``. This\n matters only in the unlikely case that you were catching\n ``VisitationError`` exceptions and expecting to thus also catch\n ``UndefinedLabel``.\n\n * Add support for \"custom rules\" in Grammars. These provide a hook for simple\n custom parsing hooks spelled as Python lambdas. For heavy-duty needs,\n you can put in Compound Expressions with LazyReferences as subexpressions,\n and the Grammar will hook them up for optimal efficiency--no calling\n ``__getitem__`` on Grammar at parse time.\n * Allow grammars without a default rule (in cases where there are no string\n rules), which leads to also allowing empty grammars. Perhaps someone\n building up grammars dynamically will find that useful.\n * Add ``@rule`` decorator, allowing grammars to be constructed out of\n notations on ``NodeVisitor`` methods. This saves looking back and forth\n between the visitor and the grammar when there is only one visitor per\n grammar.\n * Add ``parse()`` and ``match()`` convenience methods to ``NodeVisitor``.\n This makes the common case of parsing a string and applying exactly one\n visitor to the AST shorter and simpler.\n * Improve exception message when you forget to declare a visitor method.\n * Add ``unwrapped_exceptions`` attribute to ``NodeVisitor``, letting you\n name certain exceptions which propagate out of visitors without being\n wrapped by ``VisitationError`` exceptions.\n * Expose much more of the library in ``__init__``, making your imports\n shorter.\n * Drastically simplify reference resolution machinery. (Vladimir Keleshev)\n\n0.5\n .. warning::\n\n This release makes some backward-incompatible changes. See below.\n\n * Add alpha-quality error reporting. Now, rather than returning ``None``,\n ``parse()`` and ``match()`` raise ``ParseError`` if they don't succeed.\n This makes more sense, since you'd rarely attempt to parse something and\n not care if it succeeds. It was too easy before to forget to check for a\n ``None`` result. ``ParseError`` gives you a human-readable unicode\n representation as well as some attributes that let you construct your own\n custom presentation.\n * Grammar construction now raises ``ParseError`` rather than ``BadGrammar``\n if it can't parse your rules.\n * ``parse()`` now takes an optional ``pos`` argument, like ``match()``.\n * Make the ``_str__()`` method of ``UndefinedLabel`` return the right type.\n * Support splitting rules across multiple lines, interleaving comments,\n putting multiple rules on one line (but don't do that) and all sorts of\n other horrific behavior.\n * Tolerate whitespace after opening parens.\n * Add support for single-quoted literals.\n\n0.4\n * Support Python 3.\n * Fix ``import *`` for ``parsimonious.expressions``.\n * Rewrite grammar compiler so right-recursive rules can be compiled and\n parsing no longer fails in some cases with forward rule references.\n\n0.3\n * Support comments, the ``!`` (\"not\") operator, and parentheses in grammar\n definition syntax.\n * Change the ``&`` operator to a prefix operator to conform to the original\n PEG syntax. The version in Parsing Techniques was infix, and that's what I\n used as a reference. However, the unary version is more convenient, as it\n lets you spell ``AB & A`` as simply ``A &B``.\n * Take the ``print`` statements out of the benchmark tests.\n * Give Node an evaluate-able ``__repr__``.\n\n0.2\n * Support matching of prefixes and other not-to-the-end slices of strings by\n making ``match()`` public and able to initialize a new cache. Add\n ``match()`` callthrough method to ``Grammar``.\n * Report a ``BadGrammar`` exception (rather than crashing) when there are\n mistakes in a grammar definition.\n * Simplify grammar compilation internals: get rid of superfluous visitor\n methods and factor up repetitive ones. Simplify rule grammar as well.\n * Add ``NodeVisitor.lift_child`` convenience method.\n * Rename ``VisitationException`` to ``VisitationError`` for consistency with\n the standard Python exception hierarchy.\n * Rework ``repr`` and ``str`` values for grammars and expressions. Now they\n both look like rule syntax. Grammars are even round-trippable! This fixes a\n unicode encoding error when printing nodes that had parsed unicode text.\n * Add tox for testing. Stop advertising Python 2.5 support, which never\n worked (and won't unless somebody cares a lot, since it makes Python 3\n support harder).\n * Settle (hopefully) on the term \"rule\" to mean \"the string representation of\n a production\". Get rid of the vague, mysterious \"DSL\".\n\n0.1\n * A rough but useable preview release\n\nThanks to Wiki Loves Monuments Panama for showing their support with a generous\ngift.", "description_content_type": "", "docs_url": null, "download_url": "", "downloads": { "last_day": -1, "last_month": -1, "last_week": -1 }, "home_page": "https://github.com/erikrose/parsimonious", "keywords": "parse,parser,parsing,peg,packrat,grammar,language", "license": "MIT", "maintainer": "", "maintainer_email": "", "name": "parsimonious", "package_url": "https://pypi.org/project/parsimonious/", "platform": "", "project_url": "https://pypi.org/project/parsimonious/", "project_urls": { "Homepage": "https://github.com/erikrose/parsimonious" }, "release_url": "https://pypi.org/project/parsimonious/0.8.1/", "requires_dist": null, "requires_python": "", "summary": "(Soon to be) the fastest pure-Python PEG parser I could muster", "version": "0.8.1" }, "last_serial": 3983512, "releases": { "0.1": [ { "comment_text": "", "digests": { "md5": "0d20529608681e9014046ae805e0d495", "sha256": "38befd276f1b9df8aad3f9ec73d8845c76d9072b3fb2fee8d636abc9f0cba0d4" }, "downloads": -1, "filename": "parsimonious-0.1.tar.gz", "has_sig": false, "md5_digest": "0d20529608681e9014046ae805e0d495", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 23496, "upload_time": "2012-12-01T11:05:12", "url": "https://files.pythonhosted.org/packages/89/ab/72d5399c76e2428b3393b991603b7b542fd311e94773d415bb60baf7cf13/parsimonious-0.1.tar.gz" } ], "0.2": [ { "comment_text": "", "digests": { "md5": "77a9383470627f9803c471a41799cc78", "sha256": "03d0f1f948ad29bd60d48100d6cd0631b0fe7e5e8dfad483f0764cd8bba644c3" }, "downloads": -1, "filename": "parsimonious-0.2.tar.gz", "has_sig": false, "md5_digest": "77a9383470627f9803c471a41799cc78", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 23946, "upload_time": "2012-12-12T04:43:03", "url": "https://files.pythonhosted.org/packages/15/eb/f1c3885a1fda8e75eab64cb7a9d755b502492b221a15a97bc15c5bec1fe8/parsimonious-0.2.tar.gz" } ], "0.3": [ { "comment_text": "", "digests": { "md5": "b9de92de3c5d7155aec9e8c15ba25ed5", "sha256": "83613ac6d7226071331ba45277c59c8ea9e8d3c5b1896b8a68cd511b2236c034" }, "downloads": -1, "filename": "parsimonious-0.3.tar.gz", "has_sig": false, "md5_digest": "b9de92de3c5d7155aec9e8c15ba25ed5", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 25423, "upload_time": "2013-01-05T08:23:12", "url": "https://files.pythonhosted.org/packages/bc/25/f2268d92c24dea6315e0d6f9f2d18e5459c94069d5457c598e2ae0d5718d/parsimonious-0.3.tar.gz" } ], "0.4": [ { "comment_text": "", "digests": { "md5": "2533787e4b05c2ec4971c27b4953ff87", "sha256": "ae6bdc8c669f6b83557b3c0b5a2d6a0e1326cf933b301842bba09fb546d5e6fd" }, "downloads": -1, "filename": "parsimonious-0.4.tar.gz", "has_sig": false, "md5_digest": "2533787e4b05c2ec4971c27b4953ff87", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 26968, "upload_time": "2013-04-17T06:27:02", "url": "https://files.pythonhosted.org/packages/04/ed/0a1a92a97eb03ae37dc92718ce86402f107655bfc8cfa1f791df32163833/parsimonious-0.4.tar.gz" } ], "0.5": [ { "comment_text": "", "digests": { "md5": "09fde0f5d8a8c0e77173a82ee5d16f88", "sha256": "d43832ba25ea4ce747b0aab675c07ea4638417a2cc9b9c5c0cb8ef68294b12c0" }, "downloads": -1, "filename": "parsimonious-0.5.tar.gz", "has_sig": false, "md5_digest": "09fde0f5d8a8c0e77173a82ee5d16f88", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 30389, "upload_time": "2013-05-21T23:39:00", "url": "https://files.pythonhosted.org/packages/4d/55/831dd0d5e552f2d7bc68f5cf5dbdc02d3f3cabf096a4dbb0bc43c870eae2/parsimonious-0.5.tar.gz" } ], "0.6": [ { "comment_text": "", "digests": { "md5": "0cb92a858670074864bf1819f952337c", "sha256": "44f2e29cde9ef7bf348c8754b26139a608690d9f023dbc849ead0246a0c95d0a" }, "downloads": -1, "filename": "parsimonious-0.6.tar.gz", "has_sig": false, "md5_digest": "0cb92a858670074864bf1819f952337c", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 35236, "upload_time": "2014-09-09T19:18:39", "url": "https://files.pythonhosted.org/packages/cf/dc/2e6813aaefa826a08848b0667e92313942429e19e63349f14241b239e485/parsimonious-0.6.tar.gz" } ], "0.6.1": [ { "comment_text": "", "digests": { "md5": "0ff5dfa13fd62e682708f68665be5218", "sha256": "51542176aec3a1146086318dfccde31b38cd2477a25f987e84770f3388e89bc5" }, "downloads": -1, "filename": "parsimonious-0.6.1.tar.gz", "has_sig": false, "md5_digest": "0ff5dfa13fd62e682708f68665be5218", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 35424, "upload_time": "2014-09-24T17:42:34", "url": "https://files.pythonhosted.org/packages/1c/69/9c5beb595ebafc91f703c1ce3f69708275ddf5ba1beeea87c38cc8535433/parsimonious-0.6.1.tar.gz" } ], "0.6.2": [ { "comment_text": "", "digests": { "md5": "7a32835027927522be5ae2b523862a75", "sha256": "423ae2e16061504418ab7abf0a740e26a781f9bc7674a6cf5e2f11edb4ae8029" }, "downloads": -1, "filename": "parsimonious-0.6.2.tar.gz", "has_sig": false, "md5_digest": "7a32835027927522be5ae2b523862a75", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 35529, "upload_time": "2014-10-20T04:48:25", "url": "https://files.pythonhosted.org/packages/ae/37/b58d4c02513b4831db14e9759d886075bcc95a2c4f13a68c28ddfca33268/parsimonious-0.6.2.tar.gz" } ], "0.7.0": [ { "comment_text": "", "digests": { "md5": "7fce85c276a07066337990c344b3ba85", "sha256": "396d424f64f834f9463e81ba79a331661507a21f1ed7b644f7f6a744006fd938" }, "downloads": -1, "filename": "parsimonious-0.7.0.tar.gz", "has_sig": false, "md5_digest": "7fce85c276a07066337990c344b3ba85", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 37650, "upload_time": "2016-09-09T17:11:12", "url": "https://files.pythonhosted.org/packages/11/db/06a1d0a41b4d236cd84fb27fced4479645b1fb6100501e03accde2804e51/parsimonious-0.7.0.tar.gz" } ], "0.8.0": [ { "comment_text": "", "digests": { "md5": "e9b5af1a3ccc04a0f1321e1084b553be", "sha256": "ae0869d72a6e57703f24313a5f5748e73ebff836e6fe8b3ddf34ea0dc00d086b" }, "downloads": -1, "filename": "parsimonious-0.8.0.tar.gz", "has_sig": false, "md5_digest": "e9b5af1a3ccc04a0f1321e1084b553be", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 38730, "upload_time": "2017-08-05T01:07:19", "url": "https://files.pythonhosted.org/packages/4a/89/32c55944cd30dff856f16859ee325b13c83c260d0c56c0eed511e8063c87/parsimonious-0.8.0.tar.gz" } ], "0.8.1": [ { "comment_text": "", "digests": { "md5": "6cd62ccdb5f4a6e2f8d2886a08a36209", "sha256": "3add338892d580e0cb3b1a39e4a1b427ff9f687858fdd61097053742391a9f6b" }, "downloads": -1, "filename": "parsimonious-0.8.1.tar.gz", "has_sig": false, "md5_digest": "6cd62ccdb5f4a6e2f8d2886a08a36209", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 45057, "upload_time": "2018-06-21T01:50:51", "url": "https://files.pythonhosted.org/packages/02/fc/067a3f89869a41009e1a7cdfb14725f8ddd246f30f63c645e8ef8a1c56f4/parsimonious-0.8.1.tar.gz" } ] }, "urls": [ { "comment_text": "", "digests": { "md5": "6cd62ccdb5f4a6e2f8d2886a08a36209", "sha256": "3add338892d580e0cb3b1a39e4a1b427ff9f687858fdd61097053742391a9f6b" }, "downloads": -1, "filename": "parsimonious-0.8.1.tar.gz", "has_sig": false, "md5_digest": "6cd62ccdb5f4a6e2f8d2886a08a36209", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 45057, "upload_time": "2018-06-21T01:50:51", "url": "https://files.pythonhosted.org/packages/02/fc/067a3f89869a41009e1a7cdfb14725f8ddd246f30f63c645e8ef8a1c56f4/parsimonious-0.8.1.tar.gz" } ] }