{
    "info": {
        "author": "Paul Wolf",
        "author_email": "paul.wolf@yewleaf.com",
        "bugtrack_url": null,
        "classifiers": [
            "Development Status :: 5 - Production/Stable",
            "Intended Audience :: Developers",
            "License :: OSI Approved :: BSD License",
            "Programming Language :: Python",
            "Programming Language :: Python :: 2.6",
            "Programming Language :: Python :: 2.7",
            "Programming Language :: Python :: 3.3",
            "Programming Language :: Python :: 3.4",
            "Programming Language :: Python :: 3.5",
            "Programming Language :: Python :: 3.6",
            "Topic :: Software Development :: Libraries :: Python Modules"
        ],
        "description": "strgen\n======\n\n|Build Status|\n\nGenerate test data, unique ids, passwords, vouchers or other randomized\ntextual data very quickly using a template language. The template\nlanguage is superficially similar to regular expressions but instead of\ndefining how to match or capture strings, it defines how to generate\nrandomized strings. A very simple invocation to produce a random string\nwith word characters and digits of 10 characters length:\n\n::\n\n    >>> import strgen\n    >>> strgen.StringGenerator(\"[\\d\\w]{10}\").render()\n    'sj5ic8vebF'\n\nThe purpose of this module is to save the Python developer from having\nto write verbose code around the same pattern every time to generate\npasswords, keys, tokens, test data, etc. of this sort:\n\n::\n\n      my_secret_key = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(30))\n\nthat is:\n\n1. Hard to read even at this simplistic level.\n\n2. Hard to safely change quickly. Even modest additions to the\n   requirements need unreasonably verbose solutions.\n\n3. Doesn\u2019t use safe encryption standards.\n\n4. Doesn\u2019t provide the implied minimal guarantees of character\n   occurance.\n\n5. Hard to track back to requirements (\u201cmust be between x and y in\n   length and have characters from sets Q, R and S\u201d).\n\nThe template uses short forms similar to those of regular expressions.\nAn example template for generating a strong password:\n\n::\n\n     [\\w\\p\\d]{20}\n\nwill generate something like the following:\n\n::\n\n     P{:45Ec5$3)2!I68x`{6\n\nGuarantee at least two \u201cspecial\u201d characters in a string:\n\n::\n\n     [\\w\\p]{10}&[\\p]{2}\n\nYou can also generate useful test data, like fake emails with plenty of\nvariation:\n\n::\n\n     [\\c]{10}.[\\c]{5:10}@[\\c]{3:12}.(com|net|org)\n\nInstallation\n------------\n\nInstall as standard for Python packages from PyPi:\n\n::\n\n    pip install StringGenerator\n\nUsage\n-----\n\n::\n\n    from strgen import StringGenerator\n    StringGenerator(<template>).render()\n\nor to produce a list of unique strings:\n\n::\n\n    from strgen import StringGenerator\n    StringGenerator(<template>).render_list(<length>,unique=True)\n\nExample:\n\n::\n\n    >>> from strgen import StringGenerator\n    >>> StringGenerator('[\\l\\d]{4:18}&[\\d]&[\\p]').render()\n    u'Cde90uC{X6lWbOueT'\n\nThe ``template`` is a string that is a sequence of one or more of the\nfollowing:\n\n-  *Literal text* (for example: ``UID``)\n-  *Character class* (for example: ``[a-z\\s]``)\n-  *Group*, a combination of literals and character classes, possibly\n   separated by operators and using parentheses where appropriate (for\n   example: ``(UID[\\d]{4}&[\\w]{4})``)\n\nIn more detail:\n\nLiteral: <any string>\n---------------------\n\nAny literal string.\n\nExample:\n\n::\n\n    orderno\n\nSpecial characters need to be escaped with backslash ``\\``.\n\nCharacter class: [<class specification>]\n----------------------------------------\n\nMuch like in regular expressions, it uses strings of characters and\nhyphen for defining a class of characters.\n\nExample:\n\n::\n\n    [a-zA-Z0-9_]\n\nThe generator will randomly choose characters from the set of lower case\nletters, digits and the underscore. The number of characters generated\nwill be exactly one in this case. For more, use a quantifier:\n\n::\n\n    [a-zA-Z0-9_]{8}\n\nAs a shortcut for commonly used character sets, a character set code may\nbe used. The following will render in exactly the same way:\n\n::\n\n    [\\w]{8}\n\nCharacter Set Codes\n-------------------\n\n-  ``\\W``: whitespace + punctuation\n-  ``\\a``: ascii_letters\n-  ``\\c``: lowercase\n-  ``\\d``: digits\n-  ``\\h``: hexdigits\n-  ``\\l``: letters\n-  ``\\o``: octdigits\n-  ``\\p``: punctuation\n-  ``\\r``: printable\n-  ``\\s``: whitespace\n-  ``\\u``: uppercase\n-  ``\\w``: ``_`` + letters + digits\n\nQuantifier: {x:y}\n-----------------\n\nWhere x is lower bound and y is upper bound. This construct must always\nfollow immediately a class with no intervening whitespace. It is\npossible to write {:y} as a shorthand for {0:y} or {y} to indicate a\nfixed length.\n\nExample:\n\n::\n\n    [a-z]{0:8}\n\nGenerates a string from zero to 8 in length composed of lower case\nalphabetic characters.\n\n::\n\n    [a-z]{4}|[0-9]{4}\n\nGenerates a string with either four lower case alphabetic characters or\na string of digits that is four in length.\n\nUsing a character class and no quantifier will result in a quantifier of\n1. Thus:\n\n::\n\n      [abc]\n\nwill result always in either ``a``, ``b``, or ``c``.\n\nVariable Substitution\n---------------------\n\nWe provide the ``${varname}`` syntax to enable any value to be returned.\n``varname`` must be provided as a keyword argument to the ``render()``\nor ``render_list()`` methods. You can use a list, function, generator.\nHere\u2019s an example using a list:\n\n::\n\n    StringGenerator('William of ${names}').render(names=['Orange', 'Normandy', 'Ockham'])\n\nOr use a range converted to a list:\n\n::\n\n    StringGenerator('You have ${chances} chances').render(chances=list(range(1000)))\n\nNote that in Python 2.x ``range()`` returns a list. In Python 3,\n``range()`` returns a ``range`` type.\n\nOr using a function:\n\n::\n\n    StringGenerator('William of ${names}').render(names=lambda: random.choice(['Orange', 'Normandy', 'Ockham']))\n\nYou can obviously pass any callable or generator that might, for\ninstance, randomly choose a value from a database, if that is what you\nwant.\n\nNote there is a difference in handling between a callable and list type.\nIf you use a ``list``, StringGenerator picks an item from the list for\nyou, randomly. If you use a callable, StringGenerator takes and inserts\nwhatever is returned by the callable. The callable is required to do any\nrandomisation if that is what the user wants. So, if you pass a function\nthat returns a list, the entire list will be inserted as a string.\n\nGroup: (<group specification>)\n------------------------------\n\nA group specification is a collection of literals, character classes or\nother groups divided by the OR operator ``|`` or the shuffle operator\n``&``.\n\nOR Operator\n-----------\n\nThe binary ``|`` operator can be used in a group to cause one of the\noperands to be returned and the other to be ignored with an even chance.\n\nShuffle Operator\n----------------\n\nThe binary ``&`` operator causes its operands to be combined and\nshuffled. This addresses the use case for many password requirements,\nsuch as, \u201cat least 6 characters where 2 or more are digits\u201d. For\ninstance:\n\n::\n\n    [\\l]{6:10}&[\\d]{2}\n\nIf a literal or a group is an operand of the shuffle operator, it will\nhave its character sequence shuffled with the other operand.\n\n::\n\n    foo&bar\n\nwill produce strings like:\n\n::\n\n    orbfao\n\nConcatenation and Operators\n---------------------------\n\nClasses, literals and groups in sequence are concatenated in the order\nthey occur. Use of the ``|`` or ``&`` operators always binds the\noperands immediately to the left and right:\n\n::\n\n    [\\d]{8}xxx&yyy\n\nproduces something like:\n\n::\n\n     00488926xyyxxy\n\nIn other words, the digits occur first in sequence as expected. This is\nequivalent to this:\n\n::\n\n    [\\d]{8}(xxx&yyy)\n\nSpecial Characters, Escaping and Errors\n---------------------------------------\n\nThere are fewer special characters than regular expressions:\n\n::\n\n    []{}()|&$\\-\n\nThey can be used as literals by escaping with backslash. All other\ncharacters are treated as literals. The hyphen is only special in a\ncharacter class, when it appears within square brackets.\n\nOne special case is the escape character itself, backslash \u2019'. To escape\nthis, you will need at least two backslashes to escape it. So, three\nalltogether: one for Python\u2019s string interpretation and one for\nStringGenerator\u2019s escaping. If for some exotic reason you want two\nliteral backslashes in a row, you need a total of eight backslashes. The\nforegoing presupposes the template is a string in a file. If you are\nusing the template in a shell command line or shell script, you\u2019ll need\nto make any changes required by your specific shell.\n\nThe template parser tries to raise exceptions when syntax errors are\nmade, but not every error will be caught, like having space between a\nclass and quantifier.\n\nSpaces\n------\n\nDo not use any spaces in the template unless you intend to use them as\ncharacters in the output:\n\n::\n\n    >>> SG('(zzz & yyy)').render()\n    u'zzyz y y'\n\nCharacter Classes and Quantifiers\n---------------------------------\n\nUse a colon in the curly braces to indicate a range. There are sensible\ndefaults:\n\n::\n\n    [\\w]       # randomly choose a single word character\n    [\\w]{0:8}  # generate word characters from 0-8 in length \n    [\\w]{:8}   # a synonym for the above\n    [\\w]{8}    # generate word characters of exactly 8 in length\n    [a-z0-9]   # generate a-z and digits, just one as there is no quantifier\n    [a-z0-9_!@]  # you can combine ranges with individual characters\n\nAs of version 0.1.7, quantifier ranges can alternatively be specified\nwith a hyphen:\n\n::\n\n    [\\w]{4-8}\n\nHere\u2019s an example of generating a syntactically valid but, hopefully,\nspurious email address:\n\n::\n\n    [\\c]{10}(.|_)[\\c]{5:10}@[\\c]{3:12}.(com|net|org)\n\nThe first name will be exactly 10 lower case characters; the last name\nwill be 5-10 characters of lower case letters, each separated by either\na dot or underscore. The domain name without domain class will be 3 - 12\nlower case characters and the domain type will be one of\n\u2018.com\u2019,\u2018.net\u2019,\u2018.org\u2019.\n\nThe following will produce strings that tend to have more letters,\nbecause the set of letters (52) is larger than the set of digits (10):\n\n::\n\n    [\\l\\d]\n\nUsing multiple character set codes repeatedly will increase the\nprobability of a character from that set occuring in the result string:\n\n::\n\n    [\\l\\d\\d\\d\\d]\n\nThis will provide a string that is three times more likely to contain a\ndigit than the previous example.\n\nUniqueness\n----------\n\nWhen using the ``unique=True`` flag in the ``render_list()`` method,\nit\u2019s possible the generator cannot possibly produce the required number\nof unique strings. For instance:\n\n::\n\n     StringGenerator(\"[0-1]\").render_list(100, unique=True)\n\nThis will generate an exception but not before attempting to generate\nthe strings.\n\nThe number of times the generator needs to render new strings to satisfy\nthe list length and uniqueness is not determined at parse time. The\nmaximum number of times it will try is by default n x 10 where n is the\nrequested length of the list. Therefore, taking the above example, the\ngenerator will attempt to generate the unique list of 0\u2019s and 1\u2019s 100 x\n10 = 1000 times before giving up.\n\nProgress\n--------\n\nWhen using the ``progress_callback`` parameter of the ``render_list()``\nmethod, it\u2019s possible to inform others about the progress of string\ngeneration. This is especially useful when generating a large number of\nstrings.\n\nThe callback function obtains two int parameters: ``(current, total)``,\nwhich define the current progress and the total amount of requested\nstrings.\n\nBy using that, callers of ``render_list()`` are able to implement a\nprogress indicator suitable for informing end users about the progress\nof string generation.\n\nUnicode\n-------\n\nUnicode is supported for both the template and output.\n\nCharacter Sets\n--------------\n\nCharacter sets used for backslashed character codes are exactly the\nPython character sets from the string package. While the module is\ndesigned to work on pre- Python 3, we use only those member variables\nfrom the ``string`` module that are present in Python 3. This avoids the\nlocale-dependent sets of characters in Python 2.x.\n\nRandomness Methods\n------------------\n\nThe generator tries to use ``random.SystemRandom()`` for ``randint``,\n``shuffle``, etc. It falls back to ``random.randint`` and associated\nmethods if it can\u2019t use ``SystemRandom``.\n\nDebugging\n---------\n\nCall the dump() method on the class instance to get useful information:\n\n-  Version of strgen module\n-  Version of Python\n-  The class name used for random methods\n-  The parse tree\n-  The output from one invocation of the render() method\n\nThe output looks something like the following:\n\n::\n\n    >>> SG('[\\w]{8}&xyz|(zzz&yyy)').dump()\n    StringGenerator version: 1.1.2\n    Python version: 2.7.3 |EPD_free 7.3-2 (32-bit)| (default, Apr 12 2012, 11:28:34)\n    [GCC 4.0.1 (Apple Inc. build 5493)]\n    Random method provider class: SystemRandom\n    sequence:\n    OR\n         AND\n             -1:8:_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\n             xyz\n        sequence:\n             AND\n                  zzz\n                  yyy\n    u'zMXGPwyxE9a'\n                                                                        \n\nRationale and Design Goals\n--------------------------\n\nIn Python, the need to generate random strings comes up frequently and\nis accomplished usually (though not always) via something like the\nfollowing code snippet:\n\n::\n\n      import random\n      import string\n      mykey = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(10))\n\nThis generates a string that is 10 characters made of uppercase letters\nand digits. Unfortunately, this solution becomes cumbersome when\nreal-world requirements are added. Take for example, the typical\nrequirement to generate a password: \u201ca password shall have 6 - 20\ncharacters of which at least one must be a digit and at least one must\nbe a special character\u201d. The above solution then becomes much more\ncomplicated and changing the requirements is an error-prone and\nunnecessarily complex task.\n\nThe equivalent using the strgen package:\n\n::\n\n    from strgen import StringGenerator as SG\n    SG('[\\u\\d]{10}').render()\n\n``strgen`` is far more compact, flexible and feature-rich than using the\nstandard solution:\n\n-  It tries to use a better entropy mechanism and falls back gracefully\n   if this is not available on the host OS.\n\n-  The user can easily modify the specification (template) with minimal\n   effort without the fear of introducing hard-to-test code paths.\n\n-  It covers a broader set of use cases: unique ids, persistent unique\n   filenames, test data, etc.\n\n-  The template syntax is easy to learn for anyone familiar with regular\n   expressions while being much simpler.\n\n-  It supports unicode.\n\n-  It works on Python 2.6, 2.7 and 3.x.\n\n-  It proposes a standard way of expressing common requirements, like \u201ca\n   password shall have 6 - 20 characters of which at least one must be a\n   digit and at least one must be a special character\u201d:\n\n   ::\n\n          [\\l\\d]{4:18}&[\\d]&[\\p]\n\nThis package is designed with the following goals in mind:\n\n-  Provide an abstract template language that does not depend on a\n   specific implementation language.\n\n-  Reduce dependencies on other packages.\n\n-  Keep syntax as simple as possible while being useful.\n\n-  Provide an implementation design with associated behaviour that\n   strikes the right balance between ease-of-implementation and\n   ease-of-use.\n\n-  Superficially similar to regular expressions to enable developers to\n   quickly pick up the template syntax.\n\n-  Support non-ASCII languages (unicode).\n\nTesting\n-------\n\nFor running the unit tests, you might want to try:\n\n::\n\n    pip install pytest\n    pytest strgen/test.py --verbose\n\nLicense\n-------\n\nReleased under the BSD license.\n\nAcknowledgements\n----------------\n\nThanks to Robert LeBlanc who caught some important errors in escaping\nspecial characters. Thanks to Andreas Motl for the progress counter.\n\nOriginal Author: paul.wolf@yewleaf.com\n\n.. |Build Status| image:: https://travis-ci.org/paul-wolf/strgen.svg?branch=master\n   :target: https://travis-ci.org/paul-wolf/strgen",
        "description_content_type": "",
        "docs_url": null,
        "download_url": "",
        "downloads": {
            "last_day": -1,
            "last_month": -1,
            "last_week": -1
        },
        "home_page": "https://github.com/paul-wolf/strgen",
        "keywords": "",
        "license": "BSD",
        "maintainer": "",
        "maintainer_email": "",
        "name": "StringGenerator",
        "package_url": "https://pypi.org/project/StringGenerator/",
        "platform": "",
        "project_url": "https://pypi.org/project/StringGenerator/",
        "project_urls": {
            "Homepage": "https://github.com/paul-wolf/strgen"
        },
        "release_url": "https://pypi.org/project/StringGenerator/0.3.3/",
        "requires_dist": null,
        "requires_python": "",
        "summary": "Generate randomized strings of characters using a template",
        "version": "0.3.3"
    },
    "last_serial": 5266154,
    "releases": {
        "0.1": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "d5f5222597ae0ea6a5a92de32112421a",
                    "sha256": "871cfc1a4926adca09831993bbe73ed9e72c798a0daa4f55b9950f7cebb117e4"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.1.tar.gz",
                "has_sig": false,
                "md5_digest": "d5f5222597ae0ea6a5a92de32112421a",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 4884,
                "upload_time": "2014-01-04T13:14:01",
                "url": "https://files.pythonhosted.org/packages/12/ac/9d1b8d7f0c3dd1458e5f31a9aba7e47d28589529448ce6e92b7ab2c87a61/StringGenerator-0.1.tar.gz"
            }
        ],
        "0.1.1": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "e6aa489ebe25f4ac0a0c342c978ed37f",
                    "sha256": "3d06dd0578f6ba17938e1093a645b82f89d2cde165e045702501810aa240f6f8"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.1.1.tar.gz",
                "has_sig": false,
                "md5_digest": "e6aa489ebe25f4ac0a0c342c978ed37f",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 9275,
                "upload_time": "2014-01-04T16:56:23",
                "url": "https://files.pythonhosted.org/packages/52/57/63b0a600f6a06b6089ce9c2a3fb0525c7450a4611c6709a39e90949b8632/StringGenerator-0.1.1.tar.gz"
            }
        ],
        "0.1.2": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "262049f956b036347a58efcd9b8b73ba",
                    "sha256": "8b47218cd03c12b19fbf9d8a57902c1a400350eb21a3f0007ef481d261697f88"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.1.2.tar.gz",
                "has_sig": false,
                "md5_digest": "262049f956b036347a58efcd9b8b73ba",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 9349,
                "upload_time": "2014-01-04T20:38:50",
                "url": "https://files.pythonhosted.org/packages/12/f3/6caf797489a6cfa22d14389516c63142042a2a58de08ab1e562fb59e65d5/StringGenerator-0.1.2.tar.gz"
            }
        ],
        "0.1.3": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "6220d59e82ab77a8cf29a185a6e4212c",
                    "sha256": "7b12472f55a2c84e91d4efcfc8081da26dc3d4adea857eaa865aa948cf74657a"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.1.3.tar.gz",
                "has_sig": false,
                "md5_digest": "6220d59e82ab77a8cf29a185a6e4212c",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 10416,
                "upload_time": "2014-01-07T11:07:48",
                "url": "https://files.pythonhosted.org/packages/0a/e8/ee91ca62bdac27073552363308e7be58774980ff00415bb475c343a06375/StringGenerator-0.1.3.tar.gz"
            }
        ],
        "0.1.4": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "63cf0ca9a955b5ceddc6afceabfab527",
                    "sha256": "7f4f3b6944199b5d9c93537342724b9fbbdfd8314078228db96fa746aad89cde"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.1.4.tar.gz",
                "has_sig": false,
                "md5_digest": "63cf0ca9a955b5ceddc6afceabfab527",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 10615,
                "upload_time": "2015-03-01T15:43:52",
                "url": "https://files.pythonhosted.org/packages/01/84/9728535e140737025be96fe47b654c72174ed7b1ff2008237af2f950e832/StringGenerator-0.1.4.tar.gz"
            }
        ],
        "0.1.5": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "616ae4a21beec29921109dfe3aa2df85",
                    "sha256": "3a56b07b2cd500cb42daf2ac4bb57c8b1cc4bd1265df45aa8560e0ec5c26a138"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.1.5.tar.gz",
                "has_sig": false,
                "md5_digest": "616ae4a21beec29921109dfe3aa2df85",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 10617,
                "upload_time": "2015-03-01T15:59:33",
                "url": "https://files.pythonhosted.org/packages/c3/74/a725f10ae50ac5a83a2affe5c28ba6c23cf1954d363644125a0d7b4eef46/StringGenerator-0.1.5.tar.gz"
            }
        ],
        "0.1.6": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "3545573f33694c38df4192a4b0ef071a",
                    "sha256": "cfea8387b375409c123af5bf08cb04bd28c24c02efe1318590f80abd2d65d92e"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.1.6.tar.gz",
                "has_sig": false,
                "md5_digest": "3545573f33694c38df4192a4b0ef071a",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 11142,
                "upload_time": "2015-06-23T08:00:31",
                "url": "https://files.pythonhosted.org/packages/56/aa/fb7f3b13d04e3337790f7c36350961de22314cf11960e4934ac5356b1045/StringGenerator-0.1.6.tar.gz"
            }
        ],
        "0.1.7": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "15741cf05f46133e50c34a4439930842",
                    "sha256": "97c7132ae9f536e1f1c5d88fd5ae30103f78ee07b5e212dbd9b036070e9703ab"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.1.7.tar.gz",
                "has_sig": false,
                "md5_digest": "15741cf05f46133e50c34a4439930842",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 11793,
                "upload_time": "2015-08-06T21:07:03",
                "url": "https://files.pythonhosted.org/packages/4d/ae/0715be52d98d961df9ab263c51e9e477b14834092b9aa080f21772295215/StringGenerator-0.1.7.tar.gz"
            }
        ],
        "0.1.8": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "1a73a2267782118efa7e163f0ec05785",
                    "sha256": "8c5daa5de66d5523f3913a088efaf97b59476eb5811f426a8f03dfb0427a3518"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.1.8.tar.gz",
                "has_sig": false,
                "md5_digest": "1a73a2267782118efa7e163f0ec05785",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 12474,
                "upload_time": "2015-08-07T19:16:44",
                "url": "https://files.pythonhosted.org/packages/14/d1/42487f2048120194ebdcd17035e0a5cd5bb8e303594f7f0a32072bcfff88/StringGenerator-0.1.8.tar.gz"
            }
        ],
        "0.1.9": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "3d41d27e113c289c74c00b05909e2f1e",
                    "sha256": "c1bc43adf0bc44d1cd1438b05b1d93071c7f07fb9ff310b802e9f291dd31f315"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.1.9.tar.gz",
                "has_sig": false,
                "md5_digest": "3d41d27e113c289c74c00b05909e2f1e",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 12518,
                "upload_time": "2015-11-09T23:28:20",
                "url": "https://files.pythonhosted.org/packages/ee/df/603ee1b37e5349d76180d02134bca9aded4ec4f4d97f7233b1993734e3ac/StringGenerator-0.1.9.tar.gz"
            }
        ],
        "0.2.0": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "3e24162610d9ebf82bf44683d76cdb75",
                    "sha256": "6174caa43ce7449ccd9d8b5577459948ca65143ad1de1d3cc62c15982e656fbc"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.2.0.tar.gz",
                "has_sig": false,
                "md5_digest": "3e24162610d9ebf82bf44683d76cdb75",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 12678,
                "upload_time": "2017-01-30T21:13:17",
                "url": "https://files.pythonhosted.org/packages/bd/c3/ae8b6783cb1aa1fedc843b82b05d89c81f4fff35d3f0c44f6761666fce41/StringGenerator-0.2.0.tar.gz"
            }
        ],
        "0.2.1": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "866f40d99ff3cdac02e1307eca7f9e68",
                    "sha256": "ef0b2bced84c884b689bbb3d1b4493589fa3a95f610ac43f70f8d5d09363fb90"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.2.1.tar.gz",
                "has_sig": false,
                "md5_digest": "866f40d99ff3cdac02e1307eca7f9e68",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 17143,
                "upload_time": "2017-12-08T09:30:47",
                "url": "https://files.pythonhosted.org/packages/1a/6c/f681c0e1d0be078f177898117943b362e8df472432d59a7ef9a6d0beb036/StringGenerator-0.2.1.tar.gz"
            }
        ],
        "0.3.0": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "c58f389e613d117a7d91367972fb0c7c",
                    "sha256": "2723794a136f2f46bc62c522c80c3ad3029deb4f13f61eb4baef5cced312704a"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.3.0.tar.gz",
                "has_sig": false,
                "md5_digest": "c58f389e613d117a7d91367972fb0c7c",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 20305,
                "upload_time": "2018-03-27T08:48:12",
                "url": "https://files.pythonhosted.org/packages/71/31/97eeae37a7d1322d9bd12f73406afa522dfb1e6303e3f6504717e6c2f528/StringGenerator-0.3.0.tar.gz"
            }
        ],
        "0.3.1": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "0938c7bddd434917c54ee737548e9a8d",
                    "sha256": "6cb1e7c5e782099eb07d17e861875f173e6eaea8ed3618710bb5e3701e72255f"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.3.1.tar.gz",
                "has_sig": false,
                "md5_digest": "0938c7bddd434917c54ee737548e9a8d",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 20270,
                "upload_time": "2018-05-30T09:49:09",
                "url": "https://files.pythonhosted.org/packages/a0/9d/1d2ae86da01d8c7a9ed6c3d6566bea84885cfe1f56a22bec653b8c70cb1c/StringGenerator-0.3.1.tar.gz"
            }
        ],
        "0.3.2": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "8920dcfb88fc2bdf089e7183da57853e",
                    "sha256": "ca95bdb5945ad1e5398455006539caab17e495fcc835fecf8926a912eb7c45ea"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.3.2.tar.gz",
                "has_sig": false,
                "md5_digest": "8920dcfb88fc2bdf089e7183da57853e",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 15868,
                "upload_time": "2019-05-12T15:22:50",
                "url": "https://files.pythonhosted.org/packages/46/ed/4538369939ea2e95f69f3763dbc9efcf027b0614cd1e1caf33adaa062c61/StringGenerator-0.3.2.tar.gz"
            }
        ],
        "0.3.3": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "5ce3845198523967eb5fa4f784425510",
                    "sha256": "87e653724e0a8f41f8481fa724630c1906adc348b2d62b7fe114f9ecc88c00a4"
                },
                "downloads": -1,
                "filename": "StringGenerator-0.3.3.tar.gz",
                "has_sig": false,
                "md5_digest": "5ce3845198523967eb5fa4f784425510",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 15881,
                "upload_time": "2019-05-14T07:55:52",
                "url": "https://files.pythonhosted.org/packages/55/11/2a8a4497c249a7d19e32bbd9035390a77775cd065ad46ea4b24676da4574/StringGenerator-0.3.3.tar.gz"
            }
        ]
    },
    "urls": [
        {
            "comment_text": "",
            "digests": {
                "md5": "5ce3845198523967eb5fa4f784425510",
                "sha256": "87e653724e0a8f41f8481fa724630c1906adc348b2d62b7fe114f9ecc88c00a4"
            },
            "downloads": -1,
            "filename": "StringGenerator-0.3.3.tar.gz",
            "has_sig": false,
            "md5_digest": "5ce3845198523967eb5fa4f784425510",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": null,
            "size": 15881,
            "upload_time": "2019-05-14T07:55:52",
            "url": "https://files.pythonhosted.org/packages/55/11/2a8a4497c249a7d19e32bbd9035390a77775cd065ad46ea4b24676da4574/StringGenerator-0.3.3.tar.gz"
        }
    ]
}