{ "info": { "author": "gk", "author_email": "gk@axiros.com", "bugtrack_url": null, "classifiers": [ "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "License :: OSI Approved :: BSD License", "Operating System :: POSIX", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Topic :: Software Development :: Code Generators", "Topic :: Software Development :: Pre-processors", "Topic :: Text Editors :: Text Processing" ], "description": "---\n\nauthor: gk\nversion: 190523\n\n---\n\n\n# pycond: Lightweight Declarative Condition Expressions\n\n[![Build Status](https://travis-ci.org/axiros/pycond.svg?branch=master)](https://travis-ci.org/axiros/pycond) [![codecov](https://codecov.io/gh/axiros/pycond/branch/master/graph/badge.svg)](https://codecov.io/gh/axiros/pycond)[![PyPI version][pypisvg]][pypi] [![][blacksvg]][black]\n\n[blacksvg]: https://img.shields.io/badge/code%20style-black-000000.svg\n[black]: https://github.com/ambv/black\n[pypisvg]: https://img.shields.io/pypi/v/pycond.svg\n[pypi]: https://badge.fury.io/py/pycond\n\n\n\n\n\n\n# Table Of Contents\n\n- [What](#what)\n- [Why](#why)\n - [Alternatives](#alternatives)\n- [Mechanics](#mechanics)\n - [Parsing](#parsing)\n - [Building](#building)\n - [Structured Conditions](#structured-conditions)\n - [Evaluation](#evaluation)\n - [Default Lookup](#default-lookup)\n - [Passing Custom State](#passing-custom-state)\n - [Deep Lookup / Nested State](#deep-lookup-nested-state)\n - [Custom Lookup And Value Passing](#custom-lookup-and-value-passing)\n - [Lazy Evaluation](#lazy-evaluation)\n - [Building Conditions From Text](#building-conditions-from-text)\n - [Grammar](#grammar)\n - [Atomic Conditions](#atomic-conditions)\n - [Condition Operators](#condition-operators)\n - [Using Symbolic Operators](#using-symbolic-operators)\n - [Extending Condition Operators](#extending-condition-operators)\n - [Negation `not`](#negation-not)\n - [Reversal `rev`](#reversal-rev)\n - [Wrapping Condition Operators](#wrapping-condition-operators)\n - [Global Wrapping](#global-wrapping)\n - [Condition Local Wrapping](#condition-local-wrapping)\n - [Combining Operations](#combining-operations)\n - [Nesting](#nesting)\n - [Tokenizing Details](#tokenizing-details)\n - [Functioning](#functioning)\n - [Separator `sep`](#separator-sep)\n - [Apostrophes](#apostrophes)\n - [Escaping](#escaping)\n - [Building](#building)\n - [Autoconv: Casting of values into python simple types](#autoconv-casting-of-values-into-python-simple-types)\n- [Context On Demand And Lazy Evaluation](#context-on-demand-and-lazy-evaluation)\n\n\n\n\n# What\n\nYou have a bunch of data, possibly streaming...\n\n```csv\nid,first_name,last_name,email,gender,ip_address\n1,Rufe,Morstatt,rmorstatt0@newsvine.de,Male,216.70.69.120\n2,Kaela,Scott,scott@opera.com,Female,73.248.145.44,2\n(...)\n```\n\n... and you need to filter. For now lets say we have them already as list of dicts.\n\nYou can do it imperatively:\n\n```python\nfoo_users = [ u for u in users\n if ([u['gender'] == 'Male' or u['last_name'] == 'Scott') and\n '@' in u['email']) ]\n```\n\nor you have this module assemble a condition function from a declaration like:\n\n```python\nfrom pycond import parse_cond\ncond = 'email contains .de and gender eq Male or last_name eq Scott'\nis_foo = parse_cond(cond)\n```\n\nand then apply as often as you need, against varying state / facts / models (...):\n\n```\nfoo_users = [ u for u in users if is_foo(state=u) ]\n```\n\nwith roughly the same performance (factor 2-3) than the handcrafted python.\n\n> In real life performance is often **better** then using imperative code, due to\n`pycond's` [lazy evaluation](#lazy-evaluation) feature. \n\n# Why\n\nWhen the developer can decide upon the filters to apply on data he'll certainly\nuse Python's excellent expressive possibilities directly, e.g. as shown above\nthrough list comprehensions. \nBut what if the filtering conditions are based on decisions outside of the program's\ncontrol? I.e. from an end user, hitting the program via the network, in a somehow serialized form, which is rarely directly evaluatable Python.\n\nThis is the main use case for this module. \n\n## Alternatives\n\nBut why yet another tool for such a standard job? \n\nThere is a list of great tools and frameworks where condition parsing is a (small) part of them, e.g. [pyke](http://pyke.sourceforge.net/) or [durable](https://pypi.python.org/pypi/durable_rules) and many in the django world or from SQL statement parsers.\n\n\n`1.` I just needed a very **slim** tool for only the parsing into functions - but this pretty transparent and customizable\n\npycond allows to customize\n- the list of condition operators\n- the list of combination operators\n- the general behavior of condition operators via global or condition local wrappers\n- their names\n- the tokenizer\n- the value lookup function\n\nand ships as zero dependency single module.\n\nAll evaluation is done via [partials](https://stackoverflow.com/a/3252425/4583360) and not lambdas, i.e. operations can be introspected and debugged very simply, through breakpoints or custom logging operator or lookup wrappers.\n\n`2.` Simplicity of the grammar: Easy to type directly, readable by non\nprogrammers but also synthesisable from structured data, e.g. from a web framework.\n\n\n`3.` Performance: Good enough to have \"pyconditions\" used within [stream filters](https://github.com/ReactiveX/RxPY).\nWith the current feature set we are sometimes a factor 2-3 worse but (due to lazy eval) often better,\ncompared with handcrafted list comprehensions.\n\n\n# Mechanics\n\n\n\n\n\n## Parsing\npycond parses the condition expressions according to a set of constraints given to the parser in the `tokenizer` function.\nThe result of the tokenizer is given to the builder.\n\n\n```python\nimport pycond as pc\n\ncond = '[a eq b and [c lt 42 or foo eq bar]]'\ncond = pc.to_struct(pc.tokenize(cond, sep=' ', brkts='[]'))\nprint(cond)\nreturn cond\n```\nOutput:\n\n```\n[['a', 'eq', 'b', 'and', ['c', 'lt', '42', 'or', 'foo', 'eq', 'bar']]]\n```\n\n\n\n\n## Building\nAfter parsing the builder is assembling a nested set of operator functions, combined via combining operators.\nThe functions are partials, i.e. not yet evaluated but information about the necessary keys is already\navailable:\n\n\n```python\nf, meta = pc.parse_cond('foo eq bar')\nassert meta['keys'] == ['foo']\n```\n\n## Structured Conditions\n\nOther processes may deliver condition structures via serializable formats (e.g. json).\nIf you hand such already tokenized constructs to pycond, then the tokenizer is bypassed:\n\n\n```python\ncond = [['a', 'eq', 'b'], 'or', ['c', 'in', ['foo', 'bar']]]\nassert pc.pycond(cond)(state={'a': 'b'}) == True\n```\n\n## Evaluation\n\nThe result of the builder is a 'pycondition', which can be run many times against a varying state of the system.\nHow state is evaluated is customizable at build and run time.\n\n## Default Lookup\nThe default is to get lookup keys within expressions from an initially empty `State` dict within the module.\n\n\n```python\nf = pc.pycond('foo eq bar')\nassert f() == False\npc.State['foo'] = 'bar'\nassert f() == True\n```\n\n\n(`pycond` is a shortcut for `parse_cond`, when meta infos are not required).\n\n\n## Passing Custom State\n\nUse the state argument at evaluation: \n\n```python\nassert pc.pycond('a gt 2')(state={'a': 42}) == True\nassert pc.pycond('a gt 2')(state={'a': -2}) == False\n```\n\n## Deep Lookup / Nested State\n\nYou may supply a path seperator for diving into nested structures like so:\n\n\n```python\nm = {'a': {'b': [{'c': 1}]}}\nassert (\n pc.pycond([('a', 'b', 0, 'c'), 'eq', 1], deep='.')(state=m)\n == True\n)\n\nassert pc.pycond('a.b.0.c', deep='.')(state=m) == True\nassert pc.pycond('a.b.1.c', deep='.')(state=m) == False\nassert pc.pycond('a.b.0.c eq 1', deep='.')(state=m) == True\n# convencience argument for string conditions:\nassert pc.pycond('deep: a.b.0.c')(state=m) == True\n```\n\n\n## Custom Lookup And Value Passing\n\nYou can supply your own function for value acquisition.\n- Signature: See example.\n- Returns: The value for the key from the current state plus the\n compare value for the operator function. \n\n```python\n# must return a (key, value) tuple:\nmodel = {'eve': {'last_host': 'somehost'}}\n\ndef my_lu(k, v, req, user, model=model):\n print('user check. locals:', dict(locals()))\n return (model.get(user) or {}).get(k), req[v]\n\nf = pc.pycond('last_host eq host', lookup=my_lu)\n\nreq = {'host': 'somehost'}\nassert f(req=req, user='joe') == False\nassert f(req=req, user='eve') == True\n```\nOutput:\n\n```\nuser check. locals: {'k': 'last_host', 'v': 'host', 'req': {'host': 'somehost'}, 'user': 'joe', 'model': {'eve': {'last_host': 'somehost'}}}\nuser check. locals: {'k': 'last_host', 'v': 'host', 'req': {'host': 'somehost'}, 'user': 'eve', 'model': {'eve': {'last_host': 'somehost'}}}\n```\n\n> as you can see in the example, the state parameter is just a convention\nfor `pyconds'` [title: default lookup function,fmatch=pycond.py,lmatch:def state_get\nfunction.\n\n## Lazy Evaluation\n\nThis is avoiding unnecessary calculations in many cases:\n\nWhen an evaluation branch contains an \"and\" or \"and_not\" combinator, then\nat runtime we evaluate the first expression - and stop if it is already\nFalse. That way expensive deep branch evaluations are omitted or, when\nthe lookup is done lazy, the values won't be even fetched:\n\n\n```python\nevaluated = []\n\ndef myget(key, val, cfg, state=None, **kw):\n evaluated.append(key)\n # lets say we are false - always:\n return False, True\n\nf = pc.pycond(\n '[a eq b] or foo eq bar and baz eq bar', lookup=myget\n)\nf()\n# the value for \"baz\" is not even fetched and the whole (possibly\n# deep) branch after the last and is ignored:\nassert evaluated == ['a', 'foo']\nprint(evaluated)\n```\nOutput:\n\n```\n['a', 'foo']\n```\n\n## Building Conditions From Text\n\nCondition functions are created internally from structured expressions -\nbut those are [hard to type](#lazy-dynamic-context-assembly),\ninvolving many apostropies.\n\nThe text based condition syntax is intended for situations when end users\ntype them into text boxes directly.\n\n### Grammar\n\nCombine atomic conditions with boolean operators and nesting brackets like:\n\n```\n[ ] [ [ ....\n```\n\n### Atomic Conditions\n\n```\n[not] [ [rev] [not] ]\n```\n- When just `lookup_key` is given, then `co` is set to the `truthy` function:\n```python\ndef truthy(key, val=None):\n return operatur.truth(k)\n```\n\nso such an expression is valid and True:\n\n\n```python\npc.State.update({'foo': 1, 'bar': 'a', 'baz': []})\nassert pc.pycond('[ foo and bar and not baz]')() == True\n```\n\n- When `not lookup_key` is given, then `co` is set to the `falsy`\n function:\n\n\n```python\nm = {'x': 'y', 'falsy_val': {}}\n# normal way\nassert pc.pycond(['foo', 'eq', None])(state=m) == True\n# using \"not\" as prefix:\nassert pc.pycond('not foo')(state=m) == True\nassert pc.pycond(['not', 'foo'])(state=m) == True\nassert pc.pycond('not falsy_val')(state=m) == True\nassert pc.pycond('x and not foo')(state=m) == True\nassert pc.pycond('y and not falsy_val')(state=m) == False\n```\n\n## Condition Operators\n\nAll boolean [standardlib operators](https://docs.python.org/2/library/operator.html)\nare available by default:\n\n\n```python\nfrom pytest2md import html_table as tbl # just a table gen.\nfrom pycond import get_ops\n\nfor k in 'nr', 'str':\n s = 'Default supported ' + k + ' operators...(click to extend)'\n print(tbl(get_ops()[k], [k + ' operator', 'alias'], summary=s))\n```\n\n
\n Default supported nr operators...(click to extend)\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
nr operatoralias
add+
and_&
eq==
floordiv//
ge>=
gt>
iadd+=
iand&=
ifloordiv//=
ilshift<<=
imod%=
imul*=
ior|=
ipow**=
irshift>>=
is_is
is_notis
isub-=
itruediv/=
ixor^=
le<=
lshift<<
lt<
mod%
mul*
ne!=
or_|
pow**
rshift>>
sub-
truediv/
xor^
itemgetter
length_hint
\n
\n\n\n\n
\n Default supported str operators...(click to extend)\n \n\n\n\n\n\n\n\n\n
str operatoralias
attrgetter
concat+
contains
countOf
iconcat+=
indexOf
methodcaller
\n
\n\n\n\n\n### Using Symbolic Operators\n\nBy default pycond uses text style operators.\n\n- `ops_use_symbolic` switches processwide to symbolic style only.\n- `ops_use_symbolic_and_txt` switches processwide to both notations allowed.\n\n\n```python\npc.ops_use_symbolic()\npc.State['foo'] = 'bar'\nassert pc.pycond('foo == bar')() == True\ntry:\n # this raises now, text ops not known anymore:\n pc.pycond('foo eq bar')\nexcept:\n pc.ops_use_symbolic_and_txt(allow_single_eq=True)\n assert pc.pycond('foo = bar')() == True\n assert pc.pycond('foo == bar')() == True\n assert pc.pycond('foo eq bar')() == True\n assert pc.pycond('foo != baz')() == True\n```\n\n\n> Operator namespace(s) should be assigned at process start, they are global.\n\n\n### Extending Condition Operators\n\n\n```python\npc.OPS['maybe'] = lambda a, b: int(time.time()) % 2\n# valid expression now:\nassert pc.pycond('a maybe b')() in (True, False)\n```\n\n\n### Negation `not`\n\nNegates the result of the condition operator:\n\n\n```python\npc.State['foo'] = 'abc'\nassert pc.pycond('foo eq abc')() == True\nassert pc.pycond('foo not eq abc')() == False\n```\n\n\n### Reversal `rev`\n\nReverses the arguments before calling the operator \n\n```python\npc.State['foo'] = 'abc'\nassert pc.pycond('foo contains a')() == True\nassert pc.pycond('foo rev contains abc')() == True\n```\n\n\n> `rev` and `not` can be combined in any order.\n\n### Wrapping Condition Operators\n\n#### Global Wrapping\nYou may globally wrap all evaluation time condition operations through a custom function:\n\n\n\n```python\nl = []\n\ndef hk(f_op, a, b, l=l):\n l.append((getattr(f_op, '__name__', ''), a, b))\n return f_op(a, b)\n\npc.run_all_ops_thru(hk) # globally wrap the operators\n\npc.State.update({'a': 1, 'b': 2, 'c': 3})\nf = pc.pycond('a gt 0 and b lt 3 and not c gt 4')\nassert l == []\nf()\nexpected_log = [('gt', 1, 0.0), ('lt', 2, 3.0), ('gt', 3, 4.0)]\nassert l == expected_log\npc.ops_use_symbolic_and_txt()\n```\n\n\nYou may compose such wrappers via repeated application of the `run_all_ops_thru` API function.\n\n#### Condition Local Wrapping\n\nThis is done through the `ops_thru` parameter as shown:\n\n\n```python\ndef myhk(f_op, a, b):\n return True\n\npc.State['a'] = 1\nf = pc.pycond('a eq 2')\nassert f() == False\nf = pc.pycond('a eq 2', ops_thru=myhk)\nassert f() == True\n```\n\n\n> Using `ops_thru` is a good way to debug unexpected results, since you\n> can add breakpoints or loggers there.\n\n\n## Combining Operations\n\nYou can combine single conditions with\n- `and`\n- `and not`\n- `or`\n- `or not`\n- `xor` by default.\n\nThe combining functions are stored in `pycond.COMB_OPS` dict and may be extended.\n\n> Do not use spaces for the names of combining operators. The user may use them but they are replaced at before tokenizing time, like `and not` -> `and_not`.\n\n### Nesting\n\nCombined conditions may be arbitrarily nested using brackets \"[\" and \"]\".\n\n> Via the `brkts` config parameter you may change those to other separators at build time.\n\n\n## Tokenizing Details\n\n\n> Brackets as strings in this flat list form, e.g. `['[', 'a', 'and' 'b', ']'...]`\n\n### Functioning\n\nThe tokenizers job is to take apart expression strings for the builder.\n\n### Separator `sep`\n\nSeparates the different parts of an expression. Default is ' '.\n\n\n```python\npc.State['a'] = 42\nassert pc.pycond('a.eq.42', sep='.')() == True\n```\n\n> sep can be a any single character including binary.\n\nBracket characters do not need to be separated, the tokenizer will do:\n\n\n```python\n# equal:\nassert (\n pc.pycond('[[a eq 42] and b]')()\n == pc.pycond('[ [ a eq 42 ] and b ]')()\n)\n```\n\n> The condition functions themselves do not evaluate equal - those\n> had been assembled two times.\n\n### Apostrophes\n\nBy putting strings into Apostrophes you can tell the tokenizer to not further inspect them, e.g. for the seperator:\n\n\n```python\npc.State['a'] = 'Hello World'\nassert pc.pycond('a eq \"Hello World\"')() == True\n```\n\n\n\n\n### Escaping\n\nTell the tokenizer to not interpret the next character:\n\n\n```python\npc.State['b'] = 'Hello World'\nassert pc.pycond('b eq Hello\\ World')() == True\n```\n\n\n\n### Building\n\n### Autoconv: Casting of values into python simple types\n\nExpression string values are automatically cast into bools and numbers via the public `pycond.py_type` function.\n\nThis can be prevented by setting the `autoconv` parameter to `False` or by using Apostrophes:\n\n\n```python\npc.State['a'] = '42'\nassert pc.pycond('a eq 42')() == False\n# compared as string now\nassert pc.pycond('a eq \"42\"')() == True\n# compared as string now\nassert pc.pycond('a eq 42', autoconv=False)() == True\n```\n\n\nIf you do not want to provide a custom lookup function (where you can do what you want)\nbut want to have looked up keys autoconverted then use:\n\n\n```python\nfor id in '1', 1:\n pc.State['id'] = id\n assert pc.pycond('id lt 42', autoconv_lookups=True)\n```\n\n\n# Context On Demand And Lazy Evaluation\n\nOften the conditions are in user space, applied on data streams under\nthe developer's control only at development time.\n\nThe end user might pick only a few keys from many offered within an API.\n\npycond's `ctx_builder` allows to only calculate those keys at runtime,\nthe user decided to base conditions upon:\nAt condition build time hand over a namespace for *all* functions which\nare available to build the ctx.\n\n`pycon` will return a context builder function for you, calling only those functions\nwhich the condition actually requires.\n\n\n```python\npc.ops_use_symbolic_and_txt(allow_single_eq=True)\n\n# Condition the end user configured, e.g. at program run time:\ncond = [\n ['group_type', 'in', ['lab', 'first1k', 'friendly', 'auto']],\n 'and',\n [\n [\n [\n [\n ['cur_q', '<', 0.5],\n 'and',\n ['delta_q', '>=', 0.15],\n ],\n 'and',\n ['dt_last_enforce', '>', 28800],\n ],\n 'and',\n ['cur_hour', 'in', [3, 4, 5]],\n ],\n 'or',\n [\n [\n [\n ['cur_q', '<', 0.5],\n 'and',\n ['delta_q', '>=', 0.15],\n ],\n 'and',\n ['dt_last_enforce', '>', 28800],\n ],\n 'and',\n ['clients', '=', 0],\n ],\n ],\n]\n\n# Getters for API keys offered to the user, involving potentially\n# expensive to fetch context delivery functions:\n# Signature must provide minimum a positional for the current\n# state:\nclass ApiCtxFuncs:\n def expensive_but_not_needed_here(ctx):\n raise Exception(\"Won't run with cond. from above\")\n\n def group_type(ctx):\n raise Exception(\n \"Won't run since contained in example data\"\n )\n\n def cur_q(ctx):\n print('Calculating cur_q')\n return 0.1\n\n def cur_hour(ctx):\n print('Calculating cur_hour')\n return 4\n\n def dt_last_enforce(ctx):\n print('Calculating dt_last_enforce')\n return 10000000\n\n def delta_q(ctx):\n print('Calculating (expensive) delta_q')\n time.sleep(0.1)\n return 1\n\n def clients(ctx):\n print('Calculating clients')\n return 0\n\nif sys.version_info[0] < 3:\n # we don't think it is a good idea to make the getter API stateful:\n p2m.convert_to_staticmethods(ApiCtxFuncs)\n\nf, nfos = pc.parse_cond(cond, ctx_provider=ApiCtxFuncs)\n# this key stores the context builder function\nmake_ctx = nfos['complete_ctx']\n\n# now we get (incomplete) data..\ndata1 = {'group_type': 'xxx'}, False\ndata2 = {'group_type': 'lab'}, True\n\nt0 = time.time()\nfor event, expected in data1, data2:\n assert pc.pycond(cond)(state=make_ctx(event)) == expected\n\nprint('Calc.Time', round(time.time() - t0, 4))\nreturn cond, ApiCtxFuncs\n```\nOutput:\n\n```\nCalculating clients\nCalculating cur_hour\nCalculating cur_q\nCalculating (expensive) delta_q\nCalculating dt_last_enforce\nCalculating clients\nCalculating cur_hour\nCalculating cur_q\nCalculating (expensive) delta_q\nCalculating dt_last_enforce\nCalc.Time 0.206\n```\n\n\nBut we can do better - we still calculated values for keys which might be\nonly needed in dead ends of a lazily evaluated condition.\n\nLets avoid calculating these values, remembering the\n[custom lookup function](#custom-lookup-and-value-passing) feature.\n\n\n> pycond does generate such a custom lookup function readily for you,\n> if you pass a getter namespace as `lookup_provider`:\n\n\n```python\n# we let pycond generate the lookup function now:\nf = pc.pycond(cond, lookup_provider=ApiCtxFuncs)\n\n# Same events as above:\ndata1 = {'group_type': 'xxx'}, False\ndata2 = {'group_type': 'lab'}, True\n\nt0 = time.time()\nfor event, expected in data1, data2:\n # we will lookup only once:\n assert f(state=event) == expected\n\nprint(\n 'Calc.Time (only one expensive calculation):',\n round(time.time() - t0, 4),\n)\n```\nOutput:\n\n```\nCalculating cur_q\nCalculating (expensive) delta_q\nCalculating dt_last_enforce\nCalculating cur_hour\nCalculating clients\nCalc.Time (only one expensive calculation): 0.1005\n```\n\nThe output demonstrates that we did not even call the value provider functions for the dead branches of the condition. \n\n\n*Auto generated by [pytest2md](https://github.com/axiros/pytest2md), running [test_tutorial.py][test_tutorial.py]*\n\n\n\n\n\n[test_tutorial.py]: https://github.com/axiros/pycond/blob/b5e39519d6da61922a9fd2253f6b0ff49d48e2da/tests/test_tutorial.py\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/axiros/pycond", "keywords": "conditions,expression,serialization,rxpy,reactivex", "license": "BSD", "maintainer": "", "maintainer_email": "", "name": "pycond", "package_url": "https://pypi.org/project/pycond/", "platform": "", "project_url": "https://pypi.org/project/pycond/", "project_urls": { "Homepage": "https://github.com/axiros/pycond" }, "release_url": "https://pypi.org/project/pycond/190523/", "requires_dist": null, "requires_python": "", "summary": "Lightweight Condition Parsing and Building of Evaluation Expressions", "version": "190523" }, "last_serial": 5276350, "releases": { "190427": [ { "comment_text": "", "digests": { "md5": "37d77d934b0bd334af009a6f16c74dc1", "sha256": "b689b5c18b33d684b207ba58c1bb4cb666fd79c613507cf2064741cb55b26c68" }, "downloads": -1, "filename": "pycond-190427-py3-none-any.whl", "has_sig": false, "md5_digest": "37d77d934b0bd334af009a6f16c74dc1", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": null, "size": 15227, "upload_time": "2019-04-22T10:37:41", "url": "https://files.pythonhosted.org/packages/c5/03/ef787e006dd3d4ee739df17c38684ee4e890c7e1b655c42fa74638e445b0/pycond-190427-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "61d36810919a9b3cb71ad145a62bd8e2", "sha256": "44730eea2af2246a192e16caa95aa0f5d87101adb76b5642eed790db1912763a" }, "downloads": -1, "filename": "pycond-190427.tar.gz", "has_sig": false, "md5_digest": "61d36810919a9b3cb71ad145a62bd8e2", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 20238, "upload_time": "2019-04-22T10:37:43", "url": "https://files.pythonhosted.org/packages/45/b7/f6ddc9f8f85fec2beeabc5f38f005f383e51f1f5609aacbd9b71073a704a/pycond-190427.tar.gz" } ], "190519": [ { "comment_text": "", "digests": { "md5": "abf541e8ee70e07d92fe7772b02a3472", "sha256": "012386c54afadaa3cc45cd5d3f2cb40e1c296a4af6e1fe6c63e9ab9e038d6ca5" }, "downloads": -1, "filename": "pycond-190519-py3-none-any.whl", "has_sig": false, "md5_digest": "abf541e8ee70e07d92fe7772b02a3472", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": null, "size": 15754, "upload_time": "2019-05-16T00:20:04", "url": "https://files.pythonhosted.org/packages/e8/2e/fca2949d8851422d5b3d850f22f684df48cd664ede20e5c960fdc160d4d2/pycond-190519-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "cba1efaf0d79cae3822f359305955294", "sha256": "dfa61829c2e5aaa68138af02b8f4f467cfe732a4b4dd6d62997615cfa4150fc7" }, "downloads": -1, "filename": "pycond-190519.tar.gz", "has_sig": false, "md5_digest": "cba1efaf0d79cae3822f359305955294", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 20906, "upload_time": "2019-05-16T00:20:07", "url": "https://files.pythonhosted.org/packages/26/46/136fe1b42dcca2129440b0e2bb5218b874dd7feb7d14f8cb74bc87045cbf/pycond-190519.tar.gz" } ], "190520": [ { "comment_text": "", "digests": { "md5": "7e26fbbe912cbd02cb9177992e6cf7fe", "sha256": "3ec62ff436b4f1c98a3e4098d28bb8663b9704a065cd6be990422fc3bef26fad" }, "downloads": -1, "filename": "pycond-190520-py3-none-any.whl", "has_sig": false, "md5_digest": "7e26fbbe912cbd02cb9177992e6cf7fe", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": null, "size": 15806, "upload_time": "2019-05-16T00:47:49", "url": "https://files.pythonhosted.org/packages/5f/fc/c715d2e58d85b839ee1028057740843cd99c95ab4b7fa42c24d74ca81f1c/pycond-190520-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "1217816e4e3802e5214e344f6fa3f49a", "sha256": "0b780389a45b2d810557c602f284eacdf1c3b1acb81935183fd4d5b718f79266" }, "downloads": -1, "filename": "pycond-190520.tar.gz", "has_sig": false, "md5_digest": "1217816e4e3802e5214e344f6fa3f49a", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 21041, "upload_time": "2019-05-16T00:47:53", "url": "https://files.pythonhosted.org/packages/5b/f1/c3b921d8e39a198e21b5167c7852f25ec344514b4685c1d1a600dc2a4966/pycond-190520.tar.gz" } ], "190521": [ { "comment_text": "", "digests": { "md5": "654a5ffffdbfe684403ca3665309aae9", "sha256": "65578bdf507c5807f822ec50d6e457b72ae3b8e5ce571809ffbc2f3155db9076" }, "downloads": -1, "filename": "pycond-190521-py3-none-any.whl", "has_sig": false, "md5_digest": "654a5ffffdbfe684403ca3665309aae9", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": null, "size": 15806, "upload_time": "2019-05-16T00:50:30", "url": "https://files.pythonhosted.org/packages/13/ac/6b58addce6592311c75f04571c0b463bea68f5264a34c18caa1920f44e9c/pycond-190521-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "9f14368b424dffa3447dd64cc137fa8d", "sha256": "a1e3206227ce93f48de59c34ed3c54518d6f3f853220067b30e058fac853c8bd" }, "downloads": -1, "filename": "pycond-190521.tar.gz", "has_sig": false, "md5_digest": "9f14368b424dffa3447dd64cc137fa8d", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 21044, "upload_time": "2019-05-16T00:50:32", "url": "https://files.pythonhosted.org/packages/6b/a2/a89a8b565f3c7469a0eea22d4d45f90f0f7e9260f4f2b962612242fffa05/pycond-190521.tar.gz" } ], "190522": [ { "comment_text": "", "digests": { "md5": "d05c150f20eb62823483107cac29880a", "sha256": "eb66ccac57dbe95af2690c8b2a74a324189a80a87a5b2e1b7ab7a27478e65d92" }, "downloads": -1, "filename": "pycond-190522-py3-none-any.whl", "has_sig": false, "md5_digest": "d05c150f20eb62823483107cac29880a", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": null, "size": 15862, "upload_time": "2019-05-16T08:41:39", "url": "https://files.pythonhosted.org/packages/47/45/9ebad489d3fd126442245710fd60d7f75a4de9a2e2028fc57dc65189c35c/pycond-190522-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "f6e6744d8f41c75e0dd2264e82b3f63c", "sha256": "043e65234c72d750a6300b6d759497a23fd2b92b7e12371e940f20b749e00d7f" }, "downloads": -1, "filename": "pycond-190522.tar.gz", "has_sig": false, "md5_digest": "f6e6744d8f41c75e0dd2264e82b3f63c", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 21121, "upload_time": "2019-05-16T08:41:41", "url": "https://files.pythonhosted.org/packages/a4/64/05c61213eb6941371b1385c5fc1710175bd332b8bae071b53b9e1e46ab19/pycond-190522.tar.gz" } ], "190523": [ { "comment_text": "", "digests": { "md5": "82948e122b5f1bc62a7a78be5a844d94", "sha256": "8435ff4ac521af6bcc6e9fc64d9b7a2c474c187f6e42af067cd2e7e0dfcbae09" }, "downloads": -1, "filename": "pycond-190523-py3-none-any.whl", "has_sig": false, "md5_digest": "82948e122b5f1bc62a7a78be5a844d94", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": null, "size": 15838, "upload_time": "2019-05-16T08:47:55", "url": "https://files.pythonhosted.org/packages/f1/2f/c55abd315fdce6393d4cafdd66ad51ac085781537587a311d2343b64262b/pycond-190523-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "9321650bece558992d4d188e7a8ef18c", "sha256": "6e058cf73e8d9b5b8dbf700b99052ab7788f3a2ad859b86bd228e2f163d2d589" }, "downloads": -1, "filename": "pycond-190523.tar.gz", "has_sig": false, "md5_digest": "9321650bece558992d4d188e7a8ef18c", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 21100, "upload_time": "2019-05-16T08:47:57", "url": "https://files.pythonhosted.org/packages/6d/1a/e9671c0961538a2fa2f616c2033be81055b5f8ab60a7fafdaaf32aa4c958/pycond-190523.tar.gz" } ] }, "urls": [ { "comment_text": "", "digests": { "md5": "82948e122b5f1bc62a7a78be5a844d94", "sha256": "8435ff4ac521af6bcc6e9fc64d9b7a2c474c187f6e42af067cd2e7e0dfcbae09" }, "downloads": -1, "filename": "pycond-190523-py3-none-any.whl", "has_sig": false, "md5_digest": "82948e122b5f1bc62a7a78be5a844d94", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": null, "size": 15838, "upload_time": "2019-05-16T08:47:55", "url": "https://files.pythonhosted.org/packages/f1/2f/c55abd315fdce6393d4cafdd66ad51ac085781537587a311d2343b64262b/pycond-190523-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "9321650bece558992d4d188e7a8ef18c", "sha256": "6e058cf73e8d9b5b8dbf700b99052ab7788f3a2ad859b86bd228e2f163d2d589" }, "downloads": -1, "filename": "pycond-190523.tar.gz", "has_sig": false, "md5_digest": "9321650bece558992d4d188e7a8ef18c", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 21100, "upload_time": "2019-05-16T08:47:57", "url": "https://files.pythonhosted.org/packages/6d/1a/e9671c0961538a2fa2f616c2033be81055b5f8ab60a7fafdaaf32aa4c958/pycond-190523.tar.gz" } ] }