{ "info": { "author": "Martin H\u00e4cker", "author_email": "mhaecker@mac.com", "bugtrack_url": null, "classifiers": [ "Development Status :: 5 - Production/Stable", "Environment :: Console", "Intended Audience :: Developers", "License :: OSI Approved :: ISC License (ISCL)", "Programming Language :: Python :: 3", "Topic :: Software Development :: Libraries", "Topic :: Utilities" ], "description": "# fluentpy - The fluent Python library\n\nFluentpy provides fluent interfaces to existing APIs such as the standard library, allowing you to use them in an object oriented and fluent style.\n\nFluentpy is inspired by JavaScript's `jQuery` and `underscore` / `lodash` and takes some inspiration from the collections API in Ruby and SmallTalk.\n\nPlease note: **This library is based on an agressive wrapper**, that wraps anything it comes in contact with. See the section **Caveats** below for details.\n\nSee [Fowler](https://www.martinfowler.com/bliki/FluentInterface.html), [Wikipedia](https://de.wikipedia.org/wiki/Fluent_Interface) for definitions of fluent interfaces.\n\n[![Documentation Status](https://readthedocs.org/projects/fluentpy/badge/?version=latest)](https://fluentpy.readthedocs.io/en/latest/?badge=latest)\n\n## Motivation: Why use `fluentpy`?\n\nMany of the most useful standard library methods such as `map`, `zip`, `filter` and `join` are either free functions or available on the wrong type or module. This prevents fluent method chaining.\n\nLet's consider this example:\n\n >>> list(map(str.upper, sorted(\"ba,dc\".split(\",\"), reverse=True)))\n ['DC', 'BA']\n\nTo understand this code, I have to start in the middle at `\"ba,dc\".split(\",\")`, then backtrack to `sorted(\u2026, reverse=True)`, then to `list(map(str.upper, \u2026))`. All the while making sure that the parentheses all match up.\n\nWouldn't it be nice if we could think and write code in the same order? Something like how you would write this in other languages?\n\n >>> _(\"ba,dc\").split(\",\").sorted(reverse=True).map(str.upper)._\n ['DC', 'BA']\n\n\"Why no, but python has list comprehensions for that\", you might say? Let's see:\n\n >>> [each.upper() for each in sorted(\"ba,dc\".split(\",\"), reverse=True)]\n ['DC', 'BA']\n\nThis is clearly better: To read it, I have to skip back and forth less. It still leaves room for improvement though. Also, adding filtering to list comprehensions doesn't help:\n\n >>> [each.upper() for each in sorted(\"ba,dc\".split(\",\"), reverse=True) if each.upper().startswith('D')]\n ['DC']\n\nThe backtracking problem persists. Additionally, if the filtering has to be done on the processed version (on `each.upper().startswith()`), then the operation has to be applied twice - which sucks because you write it twice and compute it twice.\n\nThe solution? Nest them!\n\n >>> [each for each in \n (inner.upper() for inner in sorted(\"ba,dc\".split(\",\"), reverse=True))\n if each.startswith('D')]\n ['DC']\n\nWhich gets us back to all the initial problems with nested statements and manually having to check closing parentheses.\n\nCompare it to this:\n\n >>> processed = []\n >>> parts = \"ba,dc\".split(\",\")\n >>> for item in sorted(parts, reverse=True):\n >>> uppercases = item.upper()\n >>> if uppercased.startswith('D')\n >>> processed.append(uppercased)\n\nWith basic Python, this is as close as it gets for code to read in execution order. So that is usually what I end up doing.\n\nBut it has a huge drawback: It's not an expression - it's a bunch of statements. That makes it hard to combine and abstract over it with higher order methods or generators. To write it you are forced to invent names for intermediate variables that serve no documentation purpose, but force you to remember them while reading.\n\nPlus (drumroll): parsing this still requires some backtracking and especially build up of mental state to read.\n\nOh well.\n\nSo let's return to this:\n\n >>> (\n _(\"ba,dc\")\n .split(\",\")\n .sorted(reverse=True)\n .map(str.upper)\n .filter(_.each.startswith('D')._)\n ._\n )\n ('DC',)\n\nSure you are not used to this at first, but consider the advantages. The intermediate variable names are abstracted away - the data flows through the methods completely naturally. No jumping back and forth to parse this at all. It just reads and writes exactly in the order it is computed. As a bonus, there's no parentheses stack to keep track of. And it is shorter too!\n\nSo what is the essence of all of this?\n\nPython is an object oriented language - but it doesn't really use what object orientation has taught us about how we can work with collections and higher order methods in the languages that came before it (I think of SmallTalk here, but more recently also Ruby). Why can't I make those beautiful fluent call chains that SmallTalk could do 30 years ago in Python?\n\nWell, now I can and you can too.\n\n## Features\n\n### Importing the library\n\nIt is recommended to rename the library on import:\n\n >>> import fluentpy as _\n\nor\n\n >>> import fluentpy as _f\n\nI prefer `_` for small projects and `_f` for larger projects where `gettext` is used.\n\n### Aggressive (specialized) wrapping\n\n`_` is actually the function `wrap` in the `fluentpy` module, which is a factory function that returns a subclass of Wrapper, the basic and main object of this library.\n\nThis does two things: First it ensures that every attribute access, item access or method call off of the wrapped object will also return a wrapped object. This means, once you wrap something, unless you unwrap it explicitly via `._` or `.unwrap` or `.to(a_type)` it stays wrapped - pretty much no matter what you do with it. The second thing this does is that it returns a subclass of Wrapper that has a specialized set of methods, depending on the type of what is wrapped. I envision this to expand in the future, but right now the most useful wrappers are: `IterableWrapper`, where we add all the Python collection functions (map, filter, zip, reduce, \u2026), as well as a good batch of methods from `itertools` and a few extras for good measure. CallableWrapper, where we add `.curry()` and `.compose()` and TextWrapper, where most of the regex methods are added. \n\nSome exaples:\n\n # View documentation on a symbol without having to wrap the whole line it in parantheses\n >>> _([]).append.help()\n Help on built-in function append:\n\n append(object, /) method of builtins.list instance\n Append object to the end of the list.\n\n # Introspect objects without awkward wrapping stuff in parantheses\n >>> _(_).dir()\n fluentpy.wrap(['CallableWrapper', 'EachWrapper', 'IterableWrapper', 'MappingWrapper', 'ModuleWrapper', 'SetWrapper', 'TextWrapper', 'Wrapper', \n '_', '_0', '_1', '_2', '_3', '_4', '_5', '_6', '_7', '_8', '_9', \n \u2026\n , '_args', 'each', 'lib', 'module', 'wrap'])\n >>> _(_).IterableWrapper.dir()\n fluentpy.wrap(['_', \n \u2026, \n 'accumulate', 'all', 'any', 'call', 'combinations', 'combinations_with_replacement', 'delattr', \n 'dir', 'dropwhile', 'each', 'enumerate', 'filter', 'filterfalse', 'flatten', 'freeze', 'get', \n 'getattr', 'groupby', 'grouped', 'hasattr', 'help', 'iaccumulate', 'icombinations', '\n icombinations_with_replacement', 'icycle', 'idropwhile', 'ieach', 'ienumerate', 'ifilter', \n 'ifilterfalse', 'iflatten', 'igroupby', 'igrouped', 'imap', 'ipermutations', 'iproduct', 'ireshape', \n 'ireversed', 'isinstance', 'islice', 'isorted', 'issubclass', 'istar_map', 'istarmap', 'itee', \n 'iter', 'izip', 'join', 'len', 'map', 'max', 'min', 'permutations', 'pprint', 'previous', 'print', \n 'product', 'proxy', 'reduce', 'repr', 'reshape', 'reversed', 'self', 'setattr', 'slice', 'sorted', \n 'star_call', 'star_map', 'starmap', 'str', 'sum', 'to', 'type', 'unwrap', 'vars', 'zip'])\n\n # Did I mention that I hate wrapping everything in parantheses?\n >>> _([1,2,3]).len()\n 3\n >>> _([1,2,3]).print()\n [1,2,3]\n\n # map over iterables and easily curry functions to adapt their signatures\n >>> _(range(3)).map(_(dict).curry(id=_, delay=0)._)._\n ({'id': 0, 'delay': 0}, {'id': 1, 'delay': 0}, {'id': 2, 'delay': 0})\n >>> _(range(10)).map(_.each * 3).filter(_.each < 10)._\n (0, 3, 6, 9)\n >>> _([3,2,1]).sorted().filter(_.each<=2)._\n [1,2]\n\n # Directly work with regex methods on strings\n >>> _(\"foo, bar, baz\").split(r\",\\s*\")._\n ['foo', 'bar', 'baz']\n >>> _(\"foo, bar, baz\").findall(r'\\w{3}')._\n ['foo', 'bar', 'baz']\n\nAnd much more. [Explore the method documentation for what you can do](https://fluentpy.readthedocs.io/en/latest/fluentpy/fluentpy.html)).\n\n### Imports as expressions\n\nImport statements are (ahem) statements in Python. This is fine, but can be really annoying at times.\n\nThe `_.lib` object, which is a wrapper around the Python import machinery, allows to import anything that is accessible by import to be imported as an expression for inline use.\n\nSo instead of\n\n >>> import sys\n >>> input = sys.stdin.read()\n\nYou can do\n\n >>> lines = _.lib.sys.stdin.readlines()._\n\nAs a bonus, everything imported via lib is already pre-wrapped, so you can chain off of it immediately.\n\n### Generating lambdas from expressions\n\n`lambda` is great - it's often exactly what the doctor ordered. But it can also be annoying if you have to write it down every time you just want to get an attribute or call a method on every object in a collection. For Example:\n\n >>> _([{'fnord':'foo'}, {'fnord':'bar'}]).map(lambda each: each['fnord'])._\n ('foo', 'bar')\n\n >>> class Foo(object):\n >>> attr = 'attrvalue'\n >>> def method(self, arg): return 'method+'+arg\n >>> _([Foo(), Foo()]).map(lambda each: each.attr)._\n ('attrvalue', 'attrvalue')\n\n >>> _([Foo(), Foo()]).map(lambda each: each.method('arg'))._\n ('method+arg', 'method+arg')\n\nSure it works, but wouldn't it be nice if we could save a variable and do this a bit shorter?\n\nPython does have `attrgetter`, `itemgetter` and `methodcaller` - they are just a bit inconvenient to use:\n\n >>> from operator import itemgetter, attrgetter, methodcaller\n >>> __([{'fnord':'foo'}, {'fnord':'bar'}]).map(itemgetter('fnord'))._\n ('foo', 'bar')\n >>> _([Foo(), Foo()]).map(attrgetter('attr'))._\n ('attrvalue', 'attrvalue')\n\n >>> _([Foo(), Foo()]).map(methodcaller('method', 'arg'))._\n ('method+arg', 'method+arg')\n\n _([Foo(), Foo()]).map(methodcaller('method', 'arg')).map(str.upper)._\n ('METHOD+ARG', 'METHOD+ARG')\n\nTo ease this, `_.each` is provided. `each` exposes a bit of syntactic sugar for these (and the other operators). Basically, everything you do to `_.each` it will record and later 'play back' when you generate a callable from it by either unwrapping it, or applying an operator like `+ - * / <', which automatically call unwrap.\n\n >>> _([1,2,3]).map(_.each + 3)._\n (4, 5, 6)\n\n >>> _([1,2,3]).filter(_.each < 3)._\n (1, 2)\n\n >>> _([1,2,3]).map(- _.each)._\n (-1, -2, -3)\n\n >>> _([dict(fnord='foo'), dict(fnord='bar')]).map(_.each['fnord']._)._\n ('foo', 'bar')\n\n >>> _([Foo(), Foo()]).map(_.each.attr._)._\n ('attrvalue', 'attrvalue')\n\n >>> _([Foo(), Foo()]).map(_.each.method('arg')._)._\n ('method+arg', 'method+arg')\n\n >>> _([Foo(), Foo()]).map(_.each.method('arg').upper()._)._\n ('METHOD+ARG', 'METHOD+ARG')\n # Note that there is no second map needed to call `.upper()` here!\n\n\nThe rule is that you have to unwrap `._` the each object to generate a callable that you can then hand off to `.map()`, `.filter()` or wherever you would like to use it.\n\n### Chaining off of methods that return None\n\nA major nuisance for using fluent interfaces are methods that return None. Sadly, many methods in Python return None, if they mostly exhibit a side effect on the object. Consider for example `list.sort()`. But also all methods that don't have a `return` statement return None. While this is way better than e.g. Ruby where that will just return the value of the last expression - which means objects constantly leak internals - it is very annoying if you want to chain off of one of these method calls.\n\nFear not though, Fluentpy has you covered. :)\n\nFluent wrapped objects will have a `self` property, that allows you to continue chaining off of the previous 'self' object.\n\n >>> _([3,2,1]).sort().self.reverse().self.call(print)\n\nEven though both `sort()` and `reverse()` return `None`.\n\nOf course, if you unwrap at any point with `.unwrap` or `._` you will get the true return value of `None`.\n\n\n### Easy Shell Filtering with Python\n\nIt could often be super easy to achieve something on the shell, with a bit of Python. But, the backtracking (while writing) as well as the tendency of Python commands to span many lines (imports, function definitions, ...), makes this often just impractical enough that you won't do it.\n\nThat's why `fluentpy` is an executable module, so that you can use it on the shell like this:\n\n $ echo 'HELLO, WORLD!' \\\n | python3 -m fluentpy \"lib.sys.stdin.readlines().map(str.lower).map(print)\"\n hello, world!\n\n\nIn this mode, the variables `lib`, `_` and `each` are injected into the namespace of of the `python` commands given as the first positional argument.\n\nConsider this shell text filter, that I used to extract data from my beloved but sadly pretty legacy del.icio.us account. The format looks like this:\n\n $ tail -n 200 delicious.html|head\n
IntenseDebate comments enhance and encourage conversation on your blog or website\n
Comments on static websites\n
Social Graph API - Google Code\n
API to try to find metadata about who is a friend of who.\n
The TWiT Netcast Network with Leo Laporte\n
Podcast about how SUN sees the society evolve from a hub and spoke to a mesh society and how SUN thinks it can provide value and profit from that.\n
XMind - Social Brainstorming and Mind Mapping\n
What.jpg 480\u00d7640 pixels\n
What_happens_to_your_body_if_you_stop_smoking_right_now.gif 800\u00d7591 pixels\n
Norman G. Finkelstein\n\n $ cat delicious.html | grep hosting \\ :(\n | python3 -c 'import sys,re; \\\n print(\"\\n\".join(re.findall(r\"HREF=\\\"([^\\\"]+)\\\"\", sys.stdin.read())))'\n https://uberspace.de/\n https://gitlab.com/gitlab-org/gitlab-ce\n https://www.docker.io/\n\nSure it works, but with all the backtracking problems I talked about already. Using `fluentpy` this could be much nicer to write and read:\n\n $ cat delicious.html | grep hosting \\\n | python3 -m fluentpy 'lib.sys.stdin.read().findall(r\"HREF=\\\"([^\\\"]+)\\\"\").map(print)' \n https://uberspace.de/\n https://gitlab.com/gitlab-org/gitlab-ce\n https://www.docker.io/\n\n## Caveats and lessons learned\n\n### Start and end Fluentpy expressions on each line\n\nIf you do not end each fluent statement with a `._`, `.unwrap` or `.to(a_type)` operation to get a normal Python object back, the wrapper will spread in your runtime image like a virus, 'infecting' more and more objects causing strange side effects. So remember: Always religiously unwrap your objects at the end of a fluent statement, when using `fluentpy` in bigger projects.\n\n >>> _('foo').uppercase().match('(foo)').group(0)._\n\nI have found that it is usually a bad idea to commit wrapped objects to variables. Just unwrap instead. This is especially sensible, since fluent chains have references to all intermediate values, so unwrapping chains give the garbage collector the permission to release all those objects.\n\nForgetting to unwrap an expression generated from `_.each` may be a bit surprising, as every call on them just causes more expression generation instead of triggering their effect.\n\nThat being said, `str()` and `repr()` output of fluent wrapped objects is clearly marked, so this is easy to debug. \n\nAlso, not having to unwrap may be perfect for short scripts and especially 'one-off' shell commands. However: Use Fluentpys power wisely!\n\n### Split expression chains into multiple lines\n\nLonger fluent call chains are best written on multiple lines. This helps readability and eases commenting on lines (as your code can become very terse this way).\n\nFor short chains one line might be fine.\n\n _(open('day1-input.txt')).read().replace('\\n','').call(eval)._\n\nFor longer chains multiple lines are much cleaner.\n\n day1_input = (\n _(open('day1-input.txt'))\n .readlines()\n .imap(eval)\n ._\n )\n\n seen = set()\n def havent_seen(number):\n if number in seen:\n return False\n seen.add(number)\n return True\n\n (\n _(day1_input)\n .icycle()\n .iaccumulate()\n .idropwhile(havent_seen)\n .get(0)\n .print()\n )\n\n### Consider the performance implications of Fluentpy\n\nThis library works by creating another instance of its wrapper object for every attribute access, item get or method call you make on an object. Also those objects retain a history chain to all previous wrappers in the chain (to cope with functions that return `None`).\n\nThis means that in tight inner loops, where even allocating one more object would harshly impact the performance of your code, you probably don't want to use `fluentpy`.\n\nAlso (again) this means that you don't want to commit fluent objects to long lived variables, as that could be the source of a major memory leak.\n\nAnd for everywhere else: go to town! Coding Python in a fluent way can be so much fun!\n\n## Famous Last Words\n\nThis library tries to do a little of what libraries like `underscore` or `lodash` or `jQuery` do for Javascript. Just provide the missing glue to make the standard library nicer and easier to use. Have fun!\n\nI envision this library to be especially useful in short Python scripts and shell one liners or shell filters, where Python was previously just that little bit too hard to use and prevented you from doing so.\n\nI also really like its use in notebooks or in a python shell to smoothly explore some library, code or concept.\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/dwt/fluent", "keywords": "wrapper,smalltalk,ruby,fluent,interface,functional", "license": "ISC", "maintainer": "", "maintainer_email": "", "name": "fluentpy", "package_url": "https://pypi.org/project/fluentpy/", "platform": "", "project_url": "https://pypi.org/project/fluentpy/", "project_urls": { "Documentation": "https://fluentpy.readthedocs.io/", "Homepage": "https://github.com/dwt/fluent" }, "release_url": "https://pypi.org/project/fluentpy/2.0/", "requires_dist": [ "twine ; extra == 'dev'", "sphinx (>=1.8.3) ; extra == 'docs'", "sphinx-rtd-theme (>=0.4.2) ; extra == 'docs'", "autoapi (>=1.3.1) ; extra == 'docs'", "recommonmark (>=0.5.0) ; extra == 'docs'", "pyexpect ; extra == 'tests'", "pytest ; extra == 'tests'" ], "requires_python": ">=3.6", "summary": "Python wrapper for stdlib (and your) objects to give them a fluent interface.", "version": "2.0" }, "last_serial": 4809474, "releases": { "1.0.0": [], "1.0.1": [ { "comment_text": "", "digests": { "md5": "18ace8abb56ebd8e2dbf5132efa28e86", "sha256": "a9e8a36c17488d4c5e3cc78741e07366daef529fd52af83d120f78254e551e62" }, "downloads": -1, "filename": "fluentpy-1.0.1-py3-none-any.whl", "has_sig": false, "md5_digest": "18ace8abb56ebd8e2dbf5132efa28e86", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": ">=3.5", "size": 26777, "upload_time": "2017-10-12T16:54:54", "url": "https://files.pythonhosted.org/packages/34/41/075cbce4d63412bd44ffa82fbe117685ab4a77092623d6b8cd7817437a98/fluentpy-1.0.1-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "decfd0978198b28adc6e51a8bb8ade1b", "sha256": "8c58708e41c13f83b4af664753b6223e4e9b96eedec7454e2fb5e1891162ddd3" }, "downloads": -1, "filename": "fluentpy-1.0.1.tar.gz", "has_sig": false, "md5_digest": "decfd0978198b28adc6e51a8bb8ade1b", "packagetype": "sdist", "python_version": "source", "requires_python": ">=3.5", "size": 22195, "upload_time": "2017-10-12T16:54:56", "url": "https://files.pythonhosted.org/packages/28/0e/bd568d5dd1835bf9f37acfa2ccb6a3a9104df207c665055af7c6fac7ae37/fluentpy-1.0.1.tar.gz" } ], "2.0": [ { "comment_text": "", "digests": { "md5": "a99ce2aa688432213cce2e980282fed5", "sha256": "9623ea7d2f23d0143f80d2b49716b3ebd09c3195f77486b7ab4d7de2055ce1da" }, "downloads": -1, "filename": "fluentpy-2.0-py3-none-any.whl", "has_sig": false, "md5_digest": "a99ce2aa688432213cce2e980282fed5", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": ">=3.6", "size": 21228, "upload_time": "2019-02-12T07:17:00", "url": "https://files.pythonhosted.org/packages/83/a0/e396fb32dd95641a837c8cb8282b80f77494f1e83298bb879f16ece6e648/fluentpy-2.0-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "20f530bb14dd2240b5d156acf5907ee7", "sha256": "a77a5ac7c765bd7a21620e232933d022b9ecfe424ddf30d5c3f9be732875b2d0" }, "downloads": -1, "filename": "fluentpy-2.0.tar.gz", "has_sig": false, "md5_digest": "20f530bb14dd2240b5d156acf5907ee7", "packagetype": "sdist", "python_version": "source", "requires_python": ">=3.6", "size": 31087, "upload_time": "2019-02-12T07:17:01", "url": "https://files.pythonhosted.org/packages/d5/d5/d94b53d37977f18aa577ab0dd8ff08b15d96be5bf866fad4eba58fed23b1/fluentpy-2.0.tar.gz" } ], "2.0b1": [ { "comment_text": "", "digests": { "md5": "67e5e3dbe7a86c669b5f197ed970de41", "sha256": "a9abb1447e4c91d3ab6b74ec08a62720921553daf25c4f5241796e78707de417" }, "downloads": -1, "filename": "fluentpy-2.0b1-py3-none-any.whl", "has_sig": false, "md5_digest": "67e5e3dbe7a86c669b5f197ed970de41", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": ">=3.6", "size": 19627, "upload_time": "2019-01-18T19:56:23", "url": "https://files.pythonhosted.org/packages/a3/49/1b746a6db76db440ff29c2249efae3e7399e145210c13992f0576bef2a92/fluentpy-2.0b1-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "7f86aabea27b874437e8e61d3852d47e", "sha256": "f2c44f4b7303f6648e1deeba2aee8cc3082e266dd4c9e43171d929a5677f8050" }, "downloads": -1, "filename": "fluentpy-2.0b1.tar.gz", "has_sig": false, "md5_digest": "7f86aabea27b874437e8e61d3852d47e", "packagetype": "sdist", "python_version": "source", "requires_python": ">=3.6", "size": 27691, "upload_time": "2019-01-18T19:56:25", "url": "https://files.pythonhosted.org/packages/b3/81/4ad44597988419fce6b7dafacd484aec418021684c83291eb8549a1f8800/fluentpy-2.0b1.tar.gz" } ] }, "urls": [ { "comment_text": "", "digests": { "md5": "a99ce2aa688432213cce2e980282fed5", "sha256": "9623ea7d2f23d0143f80d2b49716b3ebd09c3195f77486b7ab4d7de2055ce1da" }, "downloads": -1, "filename": "fluentpy-2.0-py3-none-any.whl", "has_sig": false, "md5_digest": "a99ce2aa688432213cce2e980282fed5", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": ">=3.6", "size": 21228, "upload_time": "2019-02-12T07:17:00", "url": "https://files.pythonhosted.org/packages/83/a0/e396fb32dd95641a837c8cb8282b80f77494f1e83298bb879f16ece6e648/fluentpy-2.0-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "20f530bb14dd2240b5d156acf5907ee7", "sha256": "a77a5ac7c765bd7a21620e232933d022b9ecfe424ddf30d5c3f9be732875b2d0" }, "downloads": -1, "filename": "fluentpy-2.0.tar.gz", "has_sig": false, "md5_digest": "20f530bb14dd2240b5d156acf5907ee7", "packagetype": "sdist", "python_version": "source", "requires_python": ">=3.6", "size": 31087, "upload_time": "2019-02-12T07:17:01", "url": "https://files.pythonhosted.org/packages/d5/d5/d94b53d37977f18aa577ab0dd8ff08b15d96be5bf866fad4eba58fed23b1/fluentpy-2.0.tar.gz" } ] }