| Name | lupa JSON |
| Version |
2.1
JSON |
| download |
| home_page | https://github.com/scoder/lupa |
| Summary | Python wrapper around Lua and LuaJIT |
| upload_time | 2024-03-24 19:37:09 |
| maintainer | Lupa-dev mailing list |
| docs_url | None |
| author | Stefan Behnel |
| requires_python | None |
| license | MIT style |
| keywords |
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
Lupa
====
.. image:: logo/logo-220x200.png
Lupa integrates the runtimes of Lua_ or LuaJIT2_ into CPython.
It is a partial rewrite of LunaticPython_ in Cython_ with some
additional features such as proper coroutine support.
.. _Lua: http://lua.org/
.. _LuaJIT2: http://luajit.org/
.. _LunaticPython: http://labix.org/lunatic-python
.. _Cython: http://cython.org
For questions not answered here, please contact the `Lupa mailing list`_.
.. _`Lupa mailing list`: http://www.freelists.org/list/lupa-dev
.. contents:: :local:
Major features
--------------
* separate Lua runtime states through a ``LuaRuntime`` class
* Python coroutine wrapper for Lua coroutines
* iteration support for Python objects in Lua and Lua objects in
Python
* proper encoding and decoding of strings (configurable per runtime,
UTF-8 by default)
* frees the GIL and supports threading in separate runtimes when
calling into Lua
* tested with Python 2.7/3.6 and later
* ships with Lua 5.1, 5.2, 5.3 and 5.4
as well as LuaJIT 2.0 and 2.1 on systems that support it.
* easy to hack on and extend as it is written in Cython, not C
Why the name?
-------------
In Latin, "lupa" is a female wolf, as elegant and wild as it sounds.
If you don't like this kind of straight forward allegory to an
endangered species, you may also happily assume it's just an
amalgamation of the phonetic sounds that start the words "Lua" and
"Python", two from each to keep the balance.
Why use it?
-----------
It complements Python very well. Lua is a language as dynamic as
Python, but LuaJIT compiles it to very fast machine code, sometimes
faster than many statically compiled languages for computational code.
The language runtime is very small and carefully designed for
embedding. The complete binary module of Lupa, including a statically
linked LuaJIT2 runtime, only weighs some 800KB on a 64 bit machine.
With standard Lua 5.2, it's less than 600KB.
However, the Lua ecosystem lacks many of the batteries that Python
readily includes, either directly in its standard library or as third
party packages. This makes real-world Lua applications harder to write
than equivalent Python applications. Lua is therefore not commonly
used as primary language for large applications, but it makes for a
fast, high-level and resource-friendly backup language inside of
Python when raw speed is required and the edit-compile-run cycle of
binary extension modules is too heavy and too static for agile
development or hot-deployment.
Lupa is a very fast and thin wrapper around Lua or LuaJIT. It makes it
easy to write dynamic Lua code that accompanies dynamic Python code by
switching between the two languages at runtime, based on the tradeoff
between simplicity and speed.
Which Lua version?
------------------
The binary wheels include different Lua versions as well as LuaJIT, if supported.
By default, ``import lupa`` uses the latest Lua version, but you can choose
a specific one via import:
.. code:: python
try:
import lupa.luajit21 as lupa
except ImportError:
try:
import lupa.lua54 as lupa
except ImportError:
try:
import lupa.lua53 as lupa
except ImportError:
import lupa
print(f"Using {lupa.LuaRuntime().lua_implementation} (compiled with {lupa.LUA_VERSION})")
Examples
--------
..
>>> import lupa.lua54 as lupa
## doctest helpers:
>>> try: _ = sorted
... except NameError:
... def sorted(seq):
... l = list(seq)
... l.sort()
... return l
.. code:: python
>>> from lupa.lua54 import LuaRuntime
>>> lua = LuaRuntime(unpack_returned_tuples=True)
>>> lua.eval('1+1')
2
>>> lua_func = lua.eval('function(f, n) return f(n) end')
>>> def py_add1(n): return n+1
>>> lua_func(py_add1, 2)
3
>>> lua.eval('python.eval(" 2 ** 2 ")') == 4
True
>>> lua.eval('python.builtins.str(4)') == '4'
True
The function ``lua_type(obj)`` can be used to find out the type of a
wrapped Lua object in Python code, as provided by Lua's ``type()``
function:
.. code:: python
>>> lupa.lua_type(lua_func)
'function'
>>> lupa.lua_type(lua.eval('{}'))
'table'
To help in distinguishing between wrapped Lua objects and normal
Python objects, it returns ``None`` for the latter:
.. code:: python
>>> lupa.lua_type(123) is None
True
>>> lupa.lua_type('abc') is None
True
>>> lupa.lua_type({}) is None
True
Note the flag ``unpack_returned_tuples=True`` that is passed to create
the Lua runtime. It is new in Lupa 0.21 and changes the behaviour of
tuples that get returned by Python functions. With this flag, they
explode into separate Lua values:
.. code:: python
>>> lua.execute('a,b,c = python.eval("(1,2)")')
>>> g = lua.globals()
>>> g.a
1
>>> g.b
2
>>> g.c is None
True
When set to False, functions that return a tuple pass it through to the
Lua code:
.. code:: python
>>> non_explode_lua = lupa.LuaRuntime(unpack_returned_tuples=False)
>>> non_explode_lua.execute('a,b,c = python.eval("(1,2)")')
>>> g = non_explode_lua.globals()
>>> g.a
(1, 2)
>>> g.b is None
True
>>> g.c is None
True
Since the default behaviour (to not explode tuples) might change in a
later version of Lupa, it is best to always pass this flag explicitly.
Python objects in Lua
---------------------
Python objects are either converted when passed into Lua (e.g.
numbers and strings) or passed as wrapped object references.
.. code:: python
>>> wrapped_type = lua.globals().type # Lua's own type() function
>>> wrapped_type(1) == 'number'
True
>>> wrapped_type('abc') == 'string'
True
Wrapped Lua objects get unwrapped when they are passed back into Lua,
and arbitrary Python objects get wrapped in different ways:
.. code:: python
>>> wrapped_type(wrapped_type) == 'function' # unwrapped Lua function
True
>>> wrapped_type(len) == 'userdata' # wrapped Python function
True
>>> wrapped_type([]) == 'userdata' # wrapped Python object
True
Lua supports two main protocols on objects: calling and indexing. It
does not distinguish between attribute access and item access like
Python does, so the Lua operations ``obj[x]`` and ``obj.x`` both map
to indexing. To decide which Python protocol to use for Lua wrapped
objects, Lupa employs a simple heuristic.
Pratically all Python objects allow attribute access, so if the object
also has a ``__getitem__`` method, it is preferred when turning it
into an indexable Lua object. Otherwise, it becomes a simple object
that uses attribute access for indexing from inside Lua.
Obviously, this heuristic will fail to provide the required behaviour
in many cases, e.g. when attribute access is required to an object
that happens to support item access. To be explicit about the
protocol that should be used, Lupa provides the helper functions
``as_attrgetter()`` and ``as_itemgetter()`` that restrict the view on
an object to a certain protocol, both from Python and from inside
Lua:
.. code:: python
>>> lua_func = lua.eval('function(obj) return obj["get"] end')
>>> d = {'get' : 'value'}
>>> value = lua_func(d)
>>> value == d['get'] == 'value'
True
>>> value = lua_func( lupa.as_itemgetter(d) )
>>> value == d['get'] == 'value'
True
>>> dict_get = lua_func( lupa.as_attrgetter(d) )
>>> dict_get == d.get
True
>>> dict_get('get') == d.get('get') == 'value'
True
>>> lua_func = lua.eval(
... 'function(obj) return python.as_attrgetter(obj)["get"] end')
>>> dict_get = lua_func(d)
>>> dict_get('get') == d.get('get') == 'value'
True
Note that unlike Lua function objects, callable Python objects support
indexing in Lua:
.. code:: python
>>> def py_func(): pass
>>> py_func.ATTR = 2
>>> lua_func = lua.eval('function(obj) return obj.ATTR end')
>>> lua_func(py_func)
2
>>> lua_func = lua.eval(
... 'function(obj) return python.as_attrgetter(obj).ATTR end')
>>> lua_func(py_func)
2
>>> lua_func = lua.eval(
... 'function(obj) return python.as_attrgetter(obj)["ATTR"] end')
>>> lua_func(py_func)
2
Iteration in Lua
----------------
Iteration over Python objects from Lua's for-loop is fully supported.
However, Python iterables need to be converted using one of the
utility functions which are described here. This is similar to the
functions like ``pairs()`` in Lua.
To iterate over a plain Python iterable, use the ``python.iter()``
function. For example, you can manually copy a Python list into a Lua
table like this:
.. code:: python
>>> lua_copy = lua.eval('''
... function(L)
... local t, i = {}, 1
... for item in python.iter(L) do
... t[i] = item
... i = i + 1
... end
... return t
... end
... ''')
>>> table = lua_copy([1,2,3,4])
>>> len(table)
4
>>> table[1] # Lua indexing
1
Python's ``enumerate()`` function is also supported, so the above
could be simplified to:
.. code:: python
>>> lua_copy = lua.eval('''
... function(L)
... local t = {}
... for index, item in python.enumerate(L) do
... t[ index+1 ] = item
... end
... return t
... end
... ''')
>>> table = lua_copy([1,2,3,4])
>>> len(table)
4
>>> table[1] # Lua indexing
1
For iterators that return tuples, such as ``dict.iteritems()``, it is
convenient to use the special ``python.iterex()`` function that
automatically explodes the tuple items into separate Lua arguments:
.. code:: python
>>> lua_copy = lua.eval('''
... function(d)
... local t = {}
... for key, value in python.iterex(d.items()) do
... t[key] = value
... end
... return t
... end
... ''')
>>> d = dict(a=1, b=2, c=3)
>>> table = lua_copy( lupa.as_attrgetter(d) )
>>> table['b']
2
Note that accessing the ``d.items`` method from Lua requires passing
the dict as ``attrgetter``. Otherwise, attribute access in Lua would
use the ``getitem`` protocol of Python dicts and look up ``d['items']``
instead.
None vs. nil
------------
While ``None`` in Python and ``nil`` in Lua differ in their semantics, they
usually just mean the same thing: no value. Lupa therefore tries to map one
directly to the other whenever possible:
.. code:: python
>>> lua.eval('nil') is None
True
>>> is_nil = lua.eval('function(x) return x == nil end')
>>> is_nil(None)
True
The only place where this cannot work is during iteration, because Lua
considers a ``nil`` value the termination marker of iterators. Therefore,
Lupa special cases ``None`` values here and replaces them by a constant
``python.none`` instead of returning ``nil``:
.. code:: python
>>> _ = lua.require("table")
>>> func = lua.eval('''
... function(items)
... local t = {}
... for value in python.iter(items) do
... table.insert(t, value == python.none)
... end
... return t
... end
... ''')
>>> items = [1, None ,2]
>>> list(func(items).values())
[False, True, False]
Lupa avoids this value escaping whenever it's obviously not necessary.
Thus, when unpacking tuples during iteration, only the first value will
be subject to ``python.none`` replacement, as Lua does not look at the
other items for loop termination anymore. And on ``enumerate()``
iteration, the first value is known to be always a number and never None,
so no replacement is needed.
.. code:: python
>>> func = lua.eval('''
... function(items)
... for a, b, c, d in python.iterex(items) do
... return {a == python.none, a == nil, --> a == python.none
... b == python.none, b == nil, --> b == nil
... c == python.none, c == nil, --> c == nil
... d == python.none, d == nil} --> d == nil ...
... end
... end
... ''')
>>> items = [(None, None, None, None)]
>>> list(func(items).values())
[True, False, False, True, False, True, False, True]
>>> items = [(None, None)] # note: no values for c/d => nil in Lua
>>> list(func(items).values())
[True, False, False, True, False, True, False, True]
Note that this behaviour changed in Lupa 1.0. Previously, the ``python.none``
replacement was done in more places, which made it not always very predictable.
Lua Tables
----------
Lua tables mimic Python's mapping protocol. For the special case of
array tables, Lua automatically inserts integer indices as keys into
the table. Therefore, indexing starts from 1 as in Lua instead of 0
as in Python. For the same reason, negative indexing does not work.
It is best to think of Lua tables as mappings rather than arrays, even
for plain array tables.
.. code:: python
>>> table = lua.eval('{10,20,30,40}')
>>> table[1]
10
>>> table[4]
40
>>> list(table)
[1, 2, 3, 4]
>>> dict(table)
{1: 10, 2: 20, 3: 30, 4: 40}
>>> list(table.values())
[10, 20, 30, 40]
>>> len(table)
4
>>> mapping = lua.eval('{ [1] = -1 }')
>>> list(mapping)
[1]
>>> mapping = lua.eval('{ [20] = -20; [3] = -3 }')
>>> mapping[20]
-20
>>> mapping[3]
-3
>>> sorted(mapping.values())
[-20, -3]
>>> sorted(mapping.items())
[(3, -3), (20, -20)]
>>> mapping[-3] = 3 # -3 used as key, not index!
>>> mapping[-3]
3
>>> sorted(mapping)
[-3, 3, 20]
>>> sorted(mapping.items())
[(-3, 3), (3, -3), (20, -20)]
To simplify the table creation from Python, the ``LuaRuntime`` comes with
a helper method that creates a Lua table from Python arguments:
.. code:: python
>>> t = lua.table(10, 20, 30, 40)
>>> lupa.lua_type(t)
'table'
>>> list(t)
[1, 2, 3, 4]
>>> list(t.values())
[10, 20, 30, 40]
>>> t = lua.table(10, 20, 30, 40, a=1, b=2)
>>> t[3]
30
>>> t['b']
2
A second helper method, ``.table_from()``, was added in Lupa 1.1 and accepts
any number of mappings and sequences/iterables as arguments. It collects
all values and key-value pairs and builds a single Lua table from them.
Any keys that appear in multiple mappings get overwritten with their last
value (going from left to right).
.. code:: python
>>> t = lua.table_from([10, 20, 30], {'a': 11, 'b': 22}, (40, 50), {'b': 42})
>>> t['a']
11
>>> t['b']
42
>>> t[5]
50
>>> sorted(t.values())
[10, 11, 20, 30, 40, 42, 50]
Since Lupa 2.1, passing ``recursive=True`` will map data structures recursively
to Lua tables.
.. code:: python
>>> t = lua.table_from(
... [
... # t1:
... [
... [10, 20, 30],
... {'a': 11, 'b': 22}
... ],
... # t2:
... [
... (40, 50),
... {'b': 42}
... ]
... ],
... recursive=True
... )
>>> t1, t2 = t.values()
>>> list(t1[1].values())
[10, 20, 30]
>>> t1[2]['a']
11
>>> t1[2]['b']
22
>>> t2[2]['b']
42
>>> list(t1[1].values())
[10, 20, 30]
>>> list(t2[1].values())
[40, 50]
A lookup of non-existing keys or indices returns None (actually ``nil``
inside of Lua). A lookup is therefore more similar to the ``.get()``
method of Python dicts than to a mapping lookup in Python.
.. code:: python
>>> table = lua.table(10, 20, 30, 40)
>>> table[1000000] is None
True
>>> table['no such key'] is None
True
>>> mapping = lua.eval('{ [20] = -20; [3] = -3 }')
>>> mapping['no such key'] is None
True
Note that ``len()`` does the right thing for array tables but does not
work on mappings:
.. code:: python
>>> len(table)
4
>>> len(mapping)
0
This is because ``len()`` is based on the ``#`` (length) operator in
Lua and because of the way Lua defines the length of a table.
Remember that unset table indices always return ``nil``, including
indices outside of the table size. Thus, Lua basically looks for an
index that returns ``nil`` and returns the index before that. This
works well for array tables that do not contain ``nil`` values, gives
barely predictable results for tables with 'holes' and does not work
at all for mapping tables. For tables with both sequential and
mapping content, this ignores the mapping part completely.
Note that it is best not to rely on the behaviour of len() for
mappings. It might change in a later version of Lupa.
Similar to the table interface provided by Lua, Lupa also supports
attribute access to table members:
.. code:: python
>>> table = lua.eval('{ a=1, b=2 }')
>>> table.a, table.b
(1, 2)
>>> table.a == table['a']
True
This enables access to Lua 'methods' that are associated with a table,
as used by the standard library modules:
.. code:: python
>>> string = lua.eval('string') # get the 'string' library table
>>> print( string.lower('A') )
a
Python Callables
----------------
As discussed earlier, Lupa allows Lua scripts to call Python functions
and methods:
.. code:: python
>>> def add_one(num):
... return num + 1
>>> lua_func = lua.eval('function(num, py_func) return py_func(num) end')
>>> lua_func(48, add_one)
49
>>> class MyClass():
... def my_method(self):
... return 345
>>> obj = MyClass()
>>> lua_func = lua.eval('function(py_obj) return py_obj:my_method() end')
>>> lua_func(obj)
345
Lua doesn't have a dedicated syntax for named arguments, so by default
Python callables can only be called using positional arguments.
A common pattern for implementing named arguments in Lua is passing them
in a table as the first and only function argument. See
http://lua-users.org/wiki/NamedParameters for more details. Lupa supports
this pattern by providing two decorators: ``lupa.unpacks_lua_table``
for Python functions and ``lupa.unpacks_lua_table_method`` for methods
of Python objects.
Python functions/methods wrapped in these decorators can be called from
Lua code as ``func(foo, bar)``, ``func{foo=foo, bar=bar}``
or ``func{foo, bar=bar}``. Example:
.. code:: python
>>> @lupa.unpacks_lua_table
... def add(a, b):
... return a + b
>>> lua_func = lua.eval('function(a, b, py_func) return py_func{a=a, b=b} end')
>>> lua_func(5, 6, add)
11
>>> lua_func = lua.eval('function(a, b, py_func) return py_func{a, b=b} end')
>>> lua_func(5, 6, add)
11
If you do not control the function implementation, you can also just
manually wrap a callable object when passing it into Lupa:
.. code:: python
>>> import operator
>>> wrapped_py_add = lupa.unpacks_lua_table(operator.add)
>>> lua_func = lua.eval('function(a, b, py_func) return py_func{a, b} end')
>>> lua_func(5, 6, wrapped_py_add)
11
There are some limitations:
1. Avoid using ``lupa.unpacks_lua_table`` and ``lupa.unpacks_lua_table_method``
for functions where the first argument can be a Lua table. In this case
``py_func{foo=bar}`` (which is the same as ``py_func({foo=bar})`` in Lua)
becomes ambiguous: it could mean either "call ``py_func`` with a named
``foo`` argument" or "call ``py_func`` with a positional ``{foo=bar}``
argument".
2. One should be careful with passing ``nil`` values to callables wrapped in
``lupa.unpacks_lua_table`` or ``lupa.unpacks_lua_table_method`` decorators.
Depending on the context, passing ``nil`` as a parameter can mean either
"omit a parameter" or "pass None". This even depends on the Lua version.
It is possible to use ``python.none`` instead of ``nil`` to pass None values
robustly. Arguments with ``nil`` values are also fine when standard braces
``func(a, b, c)`` syntax is used.
Because of these limitations lupa doesn't enable named arguments for all
Python callables automatically. Decorators allow to enable named arguments
on a per-callable basis.
Lua Coroutines
--------------
The next is an example of Lua coroutines. A wrapped Lua coroutine
behaves exactly like a Python coroutine. It needs to get created at
the beginning, either by using the ``.coroutine()`` method of a
function or by creating it in Lua code. Then, values can be sent into
it using the ``.send()`` method or it can be iterated over. Note that
the ``.throw()`` method is not supported, though.
.. code:: python
>>> lua_code = '''\
... function(N)
... for i=0,N do
... coroutine.yield( i%2 )
... end
... end
... '''
>>> lua = LuaRuntime()
>>> f = lua.eval(lua_code)
>>> gen = f.coroutine(4)
>>> list(enumerate(gen))
[(0, 0), (1, 1), (2, 0), (3, 1), (4, 0)]
An example where values are passed into the coroutine using its
``.send()`` method:
.. code:: python
>>> lua_code = '''\
... function()
... local t,i = {},0
... local value = coroutine.yield()
... while value do
... t[i] = value
... i = i + 1
... value = coroutine.yield()
... end
... return t
... end
... '''
>>> f = lua.eval(lua_code)
>>> co = f.coroutine() # create coroutine
>>> co.send(None) # start coroutine (stops at first yield)
>>> for i in range(3):
... co.send(i*2)
>>> mapping = co.send(None) # loop termination signal
>>> sorted(mapping.items())
[(0, 0), (1, 2), (2, 4)]
It also works to create coroutines in Lua and to pass them back into
Python space:
.. code:: python
>>> lua_code = '''\
... function f(N)
... for i=0,N do
... coroutine.yield( i%2 )
... end
... end ;
... co1 = coroutine.create(f) ;
... co2 = coroutine.create(f) ;
...
... status, first_result = coroutine.resume(co2, 2) ; -- starting!
...
... return f, co1, co2, status, first_result
... '''
>>> lua = LuaRuntime()
>>> f, co, lua_gen, status, first_result = lua.execute(lua_code)
>>> # a running coroutine:
>>> status
True
>>> first_result
0
>>> list(lua_gen)
[1, 0]
>>> list(lua_gen)
[]
>>> # an uninitialised coroutine:
>>> gen = co(4)
>>> list(enumerate(gen))
[(0, 0), (1, 1), (2, 0), (3, 1), (4, 0)]
>>> gen = co(2)
>>> list(enumerate(gen))
[(0, 0), (1, 1), (2, 0)]
>>> # a plain function:
>>> gen = f.coroutine(4)
>>> list(enumerate(gen))
[(0, 0), (1, 1), (2, 0), (3, 1), (4, 0)]
Threading
---------
The following example calculates a mandelbrot image in parallel
threads and displays the result in PIL. It is based on a `benchmark
implementation`_ for the `Computer Language Benchmarks Game`_.
.. _`Computer Language Benchmarks Game`: http://shootout.alioth.debian.org/u64/benchmark.php?test=all&lang=luajit&lang2=python3
.. _`benchmark implementation`: http://shootout.alioth.debian.org/u64/program.php?test=mandelbrot&lang=luajit&id=1
.. code:: python
lua_code = '''\
function(N, i, total)
local char, unpack = string.char, table.unpack
local result = ""
local M, ba, bb, buf = 2/N, 2^(N%8+1)-1, 2^(8-N%8), {}
local start_line, end_line = N/total * (i-1), N/total * i - 1
for y=start_line,end_line do
local Ci, b, p = y*M-1, 1, 0
for x=0,N-1 do
local Cr = x*M-1.5
local Zr, Zi, Zrq, Ziq = Cr, Ci, Cr*Cr, Ci*Ci
b = b + b
for i=1,49 do
Zi = Zr*Zi*2 + Ci
Zr = Zrq-Ziq + Cr
Ziq = Zi*Zi
Zrq = Zr*Zr
if Zrq+Ziq > 4.0 then b = b + 1; break; end
end
if b >= 256 then p = p + 1; buf[p] = 511 - b; b = 1; end
end
if b ~= 1 then p = p + 1; buf[p] = (ba-b)*bb; end
result = result .. char(unpack(buf, 1, p))
end
return result
end
'''
image_size = 1280 # == 1280 x 1280
thread_count = 8
from lupa import LuaRuntime
lua_funcs = [ LuaRuntime(encoding=None).eval(lua_code)
for _ in range(thread_count) ]
results = [None] * thread_count
def mandelbrot(i, lua_func):
results[i] = lua_func(image_size, i+1, thread_count)
import threading
threads = [ threading.Thread(target=mandelbrot, args=(i,lua_func))
for i, lua_func in enumerate(lua_funcs) ]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
result_buffer = b''.join(results)
# use Pillow to display the image
from PIL import Image
image = Image.frombytes('1', (image_size, image_size), result_buffer)
image.show()
Note how the example creates a separate ``LuaRuntime`` for each thread
to enable parallel execution. Each ``LuaRuntime`` is protected by a
global lock that prevents concurrent access to it. The low memory
footprint of Lua makes it reasonable to use multiple runtimes, but
this setup also means that values cannot easily be exchanged between
threads inside of Lua. They must either get copied through Python
space (passing table references will not work, either) or use some Lua
mechanism for explicit communication, such as a pipe or some kind of
shared memory setup.
Restricting Lua access to Python objects
----------------------------------------
..
>>> try: unicode = unicode
... except NameError: unicode = str
Lupa provides a simple mechanism to control access to Python objects.
Each attribute access can be passed through a filter function as
follows:
.. code:: python
>>> def filter_attribute_access(obj, attr_name, is_setting):
... if isinstance(attr_name, unicode):
... if not attr_name.startswith('_'):
... return attr_name
... raise AttributeError('access denied')
>>> lua = lupa.LuaRuntime(
... register_eval=False,
... attribute_filter=filter_attribute_access)
>>> func = lua.eval('function(x) return x.__class__ end')
>>> func(lua)
Traceback (most recent call last):
...
AttributeError: access denied
The ``is_setting`` flag indicates whether the attribute is being read
or set.
Note that the attributes of Python functions provide access to the
current ``globals()`` and therefore to the builtins etc. If you want
to safely restrict access to a known set of Python objects, it is best
to work with a whitelist of safe attribute names. One way to do that
could be to use a well selected list of dedicated API objects that you
provide to Lua code, and to only allow Python attribute access to the
set of public attribute/method names of these objects.
Since Lupa 1.0, you can alternatively provide dedicated getter and
setter function implementations for a ``LuaRuntime``:
.. code:: python
>>> def getter(obj, attr_name):
... if attr_name == 'yes':
... return getattr(obj, attr_name)
... raise AttributeError(
... 'not allowed to read attribute "%s"' % attr_name)
>>> def setter(obj, attr_name, value):
... if attr_name == 'put':
... setattr(obj, attr_name, value)
... return
... raise AttributeError(
... 'not allowed to write attribute "%s"' % attr_name)
>>> class X(object):
... yes = 123
... put = 'abc'
... noway = 2.1
>>> x = X()
>>> lua = lupa.LuaRuntime(attribute_handlers=(getter, setter))
>>> func = lua.eval('function(x) return x.yes end')
>>> func(x) # getting 'yes'
123
>>> func = lua.eval('function(x) x.put = "ABC"; end')
>>> func(x) # setting 'put'
>>> print(x.put)
ABC
>>> func = lua.eval('function(x) x.noway = 42; end')
>>> func(x) # setting 'noway'
Traceback (most recent call last):
...
AttributeError: not allowed to write attribute "noway"
Restricting Lua Memory Usage
----------------------------
Lupa provides a simple mechanism to control the maximum memory
usage of the Lua Runtime since version 2.0.
By default Lupa does not interfere with Lua's memory allocation, to opt-in
you must set the ``max_memory`` when creating the LuaRuntime.
The ``LuaRuntime`` provides three methods for controlling and reading the
memory usage:
1. ``get_memory_used(total=False)`` to get the current memory
usage of the LuaRuntime.
2. ``get_max_memory(total=False)`` to get the current memory limit.
``0`` means there is no memory limitation.
3. ``set_max_memory(max_memory, total=False)`` to change the memory limit.
Values below or equal to 0 mean no limit.
There is always some memory used by the LuaRuntime itself (around ~20KiB,
depending on your lua version and other factors) which is excluded from all
calculations unless you specify ``total=True``.
.. code:: python
>>> from lupa import lua52
>>> lua = lua52.LuaRuntime(max_memory=0) # 0 for unlimited, default is None
>>> lua.get_memory_used() # memory used by your code
0
>>> total_lua_memory = lua.get_memory_used(total=True) # includes memory used by the runtime itself
>>> assert total_lua_memory > 0 # exact amount depends on your lua version and other factors
Lua code hitting the memory limit will receive memory errors:
.. code:: python
>>> lua.set_max_memory(100)
>>> lua.eval("string.rep('a', 1000)") # doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
lupa.LuaMemoryError: not enough memory
``LuaMemoryError`` inherits from ``LuaError`` and ``MemoryError``.
Importing Lua binary modules
----------------------------
**This will usually work as is**, but here are the details, in case
anything goes wrong for you.
To use binary modules in Lua, you need to compile them against the
header files of the LuaJIT sources that you used to build Lupa, but do
not link them against the LuaJIT library.
Furthermore, CPython needs to enable global symbol visibility for
shared libraries before loading the Lupa module. This can be done by
calling ``sys.setdlopenflags(flag_values)``. Importing the ``lupa``
module will automatically try to set up the correct ``dlopen`` flags
if it can find the platform specific ``DLFCN`` Python module that
defines the necessary flag constants. In that case, using binary
modules in Lua should work out of the box.
If this setup fails, however, you have to set the flags manually.
When using the above configuration call, the argument ``flag_values``
must represent the sum of your system's values for ``RTLD_NEW`` and
``RTLD_GLOBAL``. If ``RTLD_NEW`` is 2 and ``RTLD_GLOBAL`` is 256, you
need to call ``sys.setdlopenflags(258)``.
Assuming that the Lua luaposix_ (``posix``) module is available, the
following should work on a Linux system:
.. code:: python
>>> import sys
>>> orig_dlflags = sys.getdlopenflags()
>>> sys.setdlopenflags(258)
>>> import lupa
>>> sys.setdlopenflags(orig_dlflags)
>>> lua = lupa.LuaRuntime()
>>> posix_module = lua.require('posix') # doctest: +SKIP
.. _luaposix: http://git.alpinelinux.org/cgit/luaposix
Building with different Lua versions
------------------------------------
The build is configured to automatically search for an installed version
of first LuaJIT and then Lua, and failing to find either, to use the bundled
LuaJIT or Lua version.
If you wish to build Lupa with a specific version of Lua, you can
configure the following options on setup:
.. list-table::
:widths: 20 35
:header-rows: 1
* - Option
- Description
* - ``--lua-lib <libfile>``
- Lua library file path, e.g. ``--lua-lib /usr/local/lib/lualib.a``
* - ``--lua-includes <incdir>``
- Lua include directory, e.g. ``--lua-includes /usr/local/include``
* - ``--use-bundle``
- Use bundled LuaJIT or Lua instead of searching for an installed version.
* - ``--no-bundle``
- Don't use the bundled LuaJIT/Lua, search for an installed version of LuaJIT or Lua,
e.g. using ``pkg-config``.
* - ``--no-lua-jit``
- Don't use or search for LuaJIT, only use or search Lua instead.
Installing lupa
===============
Building with LuaJIT2
---------------------
#) Download and unpack lupa
http://pypi.python.org/pypi/lupa
#) Download LuaJIT2
http://luajit.org/download.html
#) Unpack the archive into the lupa base directory, e.g.::
.../lupa-0.1/LuaJIT-2.0.2
#) Build LuaJIT::
cd LuaJIT-2.0.2
make
cd ..
If you need specific C compiler flags, pass them to ``make`` as follows::
make CFLAGS="..."
For trickier target platforms like Windows and MacOS-X, please see
the official `installation instructions for LuaJIT`_.
NOTE: When building on Windows, make sure that lua51.lib is made in addition
to lua51.dll. The MSVC build produces this file, MinGW does NOT.
#) Build lupa::
python setup.py build_ext -i
Or any other distutils target of your choice, such as ``build``
or one of the ``bdist`` targets. See the `distutils
documentation`_ for help, also the `hints on building extension
modules`_.
Note that on 64bit MacOS-X installations, the following additional
compiler flags are reportedly required due to the embedded LuaJIT::
-pagezero_size 10000 -image_base 100000000
You can find additional installation hints for MacOS-X in this
`somewhat unclear blog post`_, which may or may not tell you at
which point in the installation process to provide these flags.
Also, on 64bit MacOS-X, you will typically have to set the
environment variable ``ARCHFLAGS`` to make sure it only builds
for your system instead of trying to generate a fat binary with
both 32bit and 64bit support::
export ARCHFLAGS="-arch x86_64"
Note that this applies to both LuaJIT and Lupa, so make sure
you try a clean build of everything if you forgot to set it
initially.
.. _`installation instructions for LuaJIT`: http://luajit.org/install.html
.. _`somewhat unclear blog post`: http://t-p-j.blogspot.com/2010/11/lupa-on-os-x-with-macports-python-26.html
.. _`distutils documentation`: http://docs.python.org/install/index.html#install-index
.. _`hints on building extension modules`: http://docs.python.org/install/index.html#building-extensions-tips-and-tricks
Building with Lua 5.x
---------------------
It also works to use Lupa with the standard (non-JIT) Lua
runtime. The easiest way is to use the bundled lua submodule:
#) Clone the submodule::
$ git submodule update --init third-party/lua
#) Build Lupa::
$ python3 setup.py bdist_wheel --use-bundle --with-cython
You can also build it by installing a Lua 5.x package, including
any development packages (header files etc.). On systems that
use the "pkg-config" configuration mechanism, Lupa's
setup.py will pick up either LuaJIT2 or Lua automatically, with a
preference for LuaJIT2 if it is found. Pass the ``--no-luajit`` option
to the setup.py script if you have both installed but do not want to
use LuaJIT2.
On other systems, you may have to supply the build parameters
externally, e.g. using environment variables or by changing the
setup.py script manually. Pass the ``--no-luajit`` option to the
setup.py script in order to ignore the failure you get when neither
LuaJIT2 nor Lua are found automatically.
For further information, read this mailing list post:
https://www.freelists.org/post/lupa-dev/Lupa-with-normal-Lua-interpreter-Lua-51,2
Installing lupa from packages
=============================
Debian/Ubuntu + Lua 5.2
-----------------------
#) Install Lua 5.2 development package::
$ apt-get install liblua5.2-dev
#) Install lupa::
$ pip install lupa
Debian/Ubuntu + LuaJIT2
-----------------------
#) Install LuaJIT2 development package::
$ apt-get install libluajit-5.1-dev
#) Install lupa::
$ pip install lupa
Depending on OS version, you might get an older LuaJIT2 version.
OS X + Lua 5.2 + Homebrew
-------------------------
#) Install Lua::
$ brew install lua
#) Install pkg-config::
$ brew install pkg-config
#) Install lupa::
$ pip install lupa
Lupa change log
===============
2.1 (2024-03-24)
----------------
* GH#199: The ``table_from()`` method gained a new keyword argument ``recursive=False``.
If true, Python data structures will be recursively mapped to Lua tables,
taking care of loops and duplicates via identity de-duplication.
* GH#248: The LuaRuntime methods "eval", "execute" and "compile" gained new
keyword options ``mode`` and ``name`` that allow constraining the input type
and modifying the (chunk) name shown in error messages, following similar
arguments in the Lua ``load()`` function.
See https://www.lua.org/manual/5.4/manual.html#pdf-load
* GH#246: Loading Lua modules did not work for the version specific Lua modules
introduced in Lupa 2.0. It turned out that it can only be enabled for
one of them in a given Python run, so it is now left to users to enable it
explicitly at need.
(original patch by Richard Connon)
* GH#234: The bundled Lua 5.1 was updated to 5.1.5 and Lua 5.2 to 5.2.4.
(patch by xxyzz)
* The bundled Lua 5.4 was updated to 5.4.6.
* The bundled LuaJIT versions were updated to the latest git branches.
* Built with Cython 3.0.9 for improved support of Python 3.12/13.
2.0 (2023-04-03)
----------------
* GH#217: Lua stack traces in Python exception messages are now reversed to
match the order of Python stack traces.
* GH#196: Lupa now ships separate extension modules built with Lua 5.3,
Lua 5.4, LuaJIT 2.0 and LuaJIT 2.1 beta. Note that this is build specific
and may depend on the platform. A normal Python import cascade can be used.
* GH#211: A new option `max_memory` allows to limit the memory usage of Lua code.
(patch by Leo Developer)
* GH#171: Python references in Lua are now more safely reference counted
to prevent garbage collection glitches.
(patch by Guilherme Dantas)
* GH#146: Lua integers in Lua 5.3+ are converted from and to Python integers.
(patch by Guilherme Dantas)
* GH#180: The ``python.enumerate()`` function now returns indices as integers
if supported by Lua.
(patch by Guilherme Dantas)
* GH#178: The Lua integer limits can be read from the module as
``LUA_MAXINTEGER`` and ``LUA_MININTEGER``.
(patch by Guilherme Dantas)
* GH#174: Failures while calling the ``__index`` method in Lua during a
table index lookup from Python could crash Python.
(patch by Guilherme Dantas)
* GH#137: Passing ``None`` as a dict key into ``table_from()`` crashed.
(patch by Leo Developer)
* GH#176: A new function ``python.args(*args, **kwargs)`` was added
to help with building Python argument tuples and keyword argument dicts
for Python function calls from Lua code.
* GH#177: Tables that are not sequences raise ``IndexError`` when unpacking
them. Previously, non-sequential items were simply ignored.
* GH#179: Resolve some C compiler warnings about signed/unsigned comparisons.
(patch by Guilherme Dantas)
* Built with Cython 0.29.34.
1.14.1 (2022-11-16)
-------------------
* Rebuild with Cython 0.29.32 to support Python 3.11.
1.13 (2022-03-01)
-----------------
* Bundled Lua source files were missing in the source distribution.
1.12 (2022-02-24)
-----------------
* GH#197: Some binary wheels in the last releases were not correctly linked with Lua.
* GH#194: An absolute file path appeared in the ``SOURCES.txt`` metadata
of the source distribution.
1.11 (2022-02-23)
-----------------
* Use Lua 5.4.4 in binary wheels and as bundled Lua.
* Built with Cython 0.29.28 to support Python 3.10/11.
1.10 (2021-09-02)
-----------------
* GH#147: Lua 5.4 is supported.
(patch by Russel Davis)
* The runtime version of the Lua library as a tuple (e.g. ``(5,3)``)
is provided via ``lupa.LUA_VERSION`` and ``LuaRuntime.lua_version``.
* The Lua implementation name and version string is provided as
``LuaRuntime.lua_implementation``.
* ``setup.py`` accepts new command line arguments ``--lua-lib`` and ``--lua-includes``
to specify the
* Use Lua 5.4.3 in binary wheels and as bundled Lua.
* Built with Cython 0.29.24 to support Python 3.9.
1.9 (2019-12-21)
----------------
* Build against Lua 5.3 if available.
* Use Lua 5.3.5 in binary wheels and as bundled Lua.
* GH#129: Fix Lua module loading in Python 3.x.
* GH#126: Fix build on Linux systems that install Lua as "lua52" package.
* Built with Cython 0.29.14 for better Py3.8 compatibility.
1.8 (2019-02-01)
----------------
* GH#107: Fix a deprecated import in Py3.
* Built with Cython 0.29.3 for better Py3.7 compatibility.
1.7 (2018-08-06)
----------------
* GH#103: Provide wheels for MS Windows and fix MSVC build on Py2.7.
1.6 (2017-12-15)
----------------
* GH#95: Improved compatibility with Lua 5.3.
(patch by TitanSnow)
1.5 (2017-09-16)
----------------
* GH#93: New method ``LuaRuntime.compile()`` to compile Lua code
without executing it.
(patch by TitanSnow)
* GH#91: Lua 5.3 is bundled in the source distribution to simplify
one-shot installs.
(patch by TitanSnow)
* GH#87: Lua stack trace is included in output in debug mode.
(patch by aaiyer)
* GH#78: Allow Lua code to intercept Python exceptions.
(patch by Sergey Dobrov)
* Built with Cython 0.26.1.
1.4 (2016-12-10)
----------------
* GH#82: Lua coroutines were using the wrong runtime state
(patch by Sergey Dobrov)
* GH#81: copy locally provided Lua DLL into installed package on Windows
(patch by Gareth Coles)
* built with Cython 0.25.2
1.3 (2016-04-12)
----------------
* GH#70: ``eval()`` and ``execute()`` accept optional positional arguments
(patch by John Vandenberg)
* GH#65: calling ``str()`` on a Python object from Lua could fail if the
``LuaRuntime`` is set up without auto-encoding (patch by Mikhail Korobov)
* GH#63: attribute/keyword names were not properly encoded if the
``LuaRuntime`` is set up without auto-encoding (patch by Mikhail Korobov)
* built with Cython 0.24
1.2 (2015-10-10)
----------------
* callbacks returned from Lua coroutines were incorrectly mixing
coroutine state with global Lua state (patch by Mikhail Korobov)
* availability of ``python.builtins`` in Lua can be disabled via
``LuaRuntime`` option.
* built with Cython 0.23.4
1.1 (2014-11-21)
----------------
* new module function ``lupa.lua_type()`` that returns the Lua type of
a wrapped object as string, or ``None`` for normal Python objects
* new helper method ``LuaRuntime.table_from(...)`` that creates a Lua
table from one or more Python mappings and/or sequences
* new ``lupa.unpacks_lua_table`` and ``lupa.unpacks_lua_table_method``
decorators to allow calling Python functions from Lua using named
arguments
* fix a hang on shutdown where the LuaRuntime failed to deallocate due
to reference cycles
* Lupa now plays more nicely with other Lua extensions that create
userdata objects
1.0.1 (2014-10-11)
------------------
* fix a crash when requesting attributes of wrapped Lua coroutine objects
* looking up attributes on Lua objects that do not support it now always
raises an AttributeError instead of sometimes raising a TypeError depending
on the attribute name
1.0 (2014-09-28)
----------------
* NOTE: this release includes the major backwards incompatible changes listed
below. It is believed that they simplify the interaction between Python code
and Lua code by more strongly following idiomatic Lua on the Lua side.
* Instead of passing a wrapped ``python.none`` object into Lua, ``None``
return values are now mapped to ``nil``, making them more straight forward
to handle in Lua code. This makes the behaviour more consistent, as it
was previously somewhat arbitrary where ``none`` could appear and where a
``nil`` value was used. The only remaining exception is during iteration,
where the first returned value must not be ``nil`` in Lua, or otherwise
the loop terminates prematurely. To prevent this, any ``None`` value
that the iterator returns, or any first item in exploded tuples that is
``None``, is still mapped to ``python.none``. Any further values
returned in the same iteration will be mapped to ``nil`` if they are
``None``, not to ``none``. This means that only the first argument
needs to be manually checked for this special case. For the
``enumerate()`` iterator, the counter is never ``None`` and thus the
following unpacked items will never be mapped to ``python.none``.
* When ``unpack_returned_tuples=True``, iteration now also unpacks tuple
values, including ``enumerate()`` iteration, which yields a flat sequence
of counter and unpacked values.
* When calling bound Python methods from Lua as "obj:meth()", Lupa now
prevents Python from prepending the self argument a second time, so that
the Python method is now called as "obj.meth()". Previously, it was called
as "obj.meth(obj)". Note that this can be undesired when the object itself
is explicitly passed as first argument from Lua, e.g. when calling
"func(obj)" where "func" is "obj.meth", but these constellations should be
rare. As a work-around for this case, user code can wrap the bound method
in another function so that the final call comes from Python.
* garbage collection works for reference cycles that span both runtimes,
Python and Lua
* calling from Python into Lua and back into Python did not clean up the
Lua call arguments before the innermost call, so that they could leak
into the nested Python call or its return arguments
* support for Lua 5.2 (in addition to Lua 5.1 and LuaJIT 2.0)
* Lua tables support Python's "del" statement for item deletion
(patch by Jason Fried)
* Attribute lookup can use a more fine-grained control mechanism by
implementing explicit getter and setter functions for a LuaRuntime
(``attribute_handlers`` argument). Patch by Brian Moe.
* item assignments/lookups on Lua objects from Python no longer
special case double underscore names (as opposed to attribute lookups)
0.21 (2014-02-12)
-----------------
* some garbage collection issues were cleaned up using new Cython features
* new ``LuaRuntime`` option ``unpack_returned_tuples`` which automatically
unpacks tuples returned from Python functions into separate Lua objects
(instead of returning a single Python tuple object)
* some internal wrapper classes were removed from the module API
* Windows build fixes
* Py3.x build fixes
* support for building with Lua 5.1 instead of LuaJIT (setup.py --no-luajit)
* no longer uses Cython by default when building from released sources (pass
``--with-cython`` to explicitly request a rebuild)
* requires Cython 0.20+ when building from unreleased sources
* built with Cython 0.20.1
0.20 (2011-05-22)
-----------------
* fix "deallocating None" crash while iterating over Lua tables in
Python code
* support for filtering attribute access to Python objects for Lua
code
* fix: setting source encoding for Lua code was broken
0.19 (2011-03-06)
-----------------
* fix serious resource leak when creating multiple LuaRuntime instances
* portability fix for binary module importing
0.18 (2010-11-06)
-----------------
* fix iteration by returning ``Py_None`` object for ``None`` instead
of ``nil``, which would terminate the iteration
* when converting Python values to Lua, represent ``None`` as a
``Py_None`` object in places where ``nil`` has a special meaning,
but leave it as ``nil`` where it doesn't hurt
* support for counter start value in ``python.enumerate()``
* native implementation for ``python.enumerate()`` that is several
times faster
* much faster Lua iteration over Python objects
0.17 (2010-11-05)
-----------------
* new helper function ``python.enumerate()`` in Lua that returns a Lua
iterator for a Python object and adds the 0-based index to each
item.
* new helper function ``python.iterex()`` in Lua that returns a Lua
iterator for a Python object and unpacks any tuples that the
iterator yields.
* new helper function ``python.iter()`` in Lua that returns a Lua
iterator for a Python object.
* reestablished the ``python.as_function()`` helper function for Lua
code as it can be needed in cases where Lua cannot determine how to
run a Python function.
0.16 (2010-09-03)
-----------------
* dropped ``python.as_function()`` helper function for Lua as all
Python objects are callable from Lua now (potentially raising a
``TypeError`` at call time if they are not callable)
* fix regression in 0.13 and later where ordinary Lua functions failed
to print due to an accidentally used meta table
* fix crash when calling ``str()`` on wrapped Lua objects without
metatable
0.15 (2010-09-02)
-----------------
* support for loading binary Lua modules on systems that support it
0.14 (2010-08-31)
-----------------
* relicensed to the MIT license used by LuaJIT2 to simplify licensing
considerations
0.13.1 (2010-08-30)
-------------------
* fix Cython generated C file using Cython 0.13
0.13 (2010-08-29)
-----------------
* fixed undefined behaviour on ``str(lua_object)`` when the object's
``__tostring()`` meta method fails
* removed redundant "error:" prefix from ``LuaError`` messages
* access to Python's ``python.builtins`` from Lua code
* more generic wrapping rules for Python objects based on supported
protocols (callable, getitem, getattr)
* new helper functions ``as_attrgetter()`` and ``as_itemgetter()`` to
specify the Python object protocol used by Lua indexing when
wrapping Python objects in Python code
* new helper functions ``python.as_attrgetter()``,
``python.as_itemgetter()`` and ``python.as_function()`` to specify
the Python object protocol used by Lua indexing of Python objects in
Lua code
* item and attribute access for Python objects from Lua code
0.12 (2010-08-16)
-----------------
* fix Lua stack leak during table iteration
* fix lost Lua object reference after iteration
0.11 (2010-08-07)
-----------------
* error reporting on Lua syntax errors failed to clean up the stack so
that errors could leak into the next Lua run
* Lua error messages were not properly decoded
0.10 (2010-07-27)
-----------------
* much faster locking of the LuaRuntime, especially in the single
threaded case (see
http://code.activestate.com/recipes/577336-fast-re-entrant-optimistic-lock-implemented-in-cyt/)
* fixed several error handling problems when executing Python code
inside of Lua
0.9 (2010-07-23)
----------------
* fixed Python special double-underscore method access on LuaObject
instances
* Lua coroutine support through dedicated wrapper classes, including
Python iteration support. In Python space, Lua coroutines behave
exactly like Python generators.
0.8 (2010-07-21)
----------------
* support for returning multiple values from Lua evaluation
* ``repr()`` support for Lua objects
* ``LuaRuntime.table()`` method for creating Lua tables from Python
space
* encoding fix for ``str(LuaObject)``
0.7 (2010-07-18)
----------------
* ``LuaRuntime.require()`` and ``LuaRuntime.globals()`` methods
* renamed ``LuaRuntime.run()`` to ``LuaRuntime.execute()``
* support for ``len()``, ``setattr()`` and subscripting of Lua objects
* provide all built-in Lua libraries in ``LuaRuntime``, including
support for library loading
* fixed a thread locking issue
* fix passing Lua objects back into the runtime from Python space
0.6 (2010-07-18)
----------------
* Python iteration support for Lua objects (e.g. tables)
* threading fixes
* fix compile warnings
0.5 (2010-07-14)
----------------
* explicit encoding options per LuaRuntime instance to decode/encode
strings and Lua code
0.4 (2010-07-14)
----------------
* attribute read access on Lua objects, e.g. to read Lua table values
from Python
* str() on Lua objects
* include .hg repository in source downloads
* added missing files to source distribution
0.3 (2010-07-13)
----------------
* fix several threading issues
* safely free the GIL when calling into Lua
0.2 (2010-07-13)
----------------
* propagate Python exceptions through Lua calls
0.1 (2010-07-12)
----------------
* first public release
License
=======
Lupa
----
Copyright (c) 2010-2017 Stefan Behnel. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
Lua
---
(See https://www.lua.org/license.html)
Copyright © 1994–2017 Lua.org, PUC-Rio.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
Raw data
{
"_id": null,
"home_page": "https://github.com/scoder/lupa",
"name": "lupa",
"maintainer": "Lupa-dev mailing list",
"docs_url": null,
"requires_python": null,
"maintainer_email": "lupa-dev@freelists.org",
"keywords": null,
"author": "Stefan Behnel",
"author_email": "stefan_ml@behnel.de",
"download_url": "https://files.pythonhosted.org/packages/fe/78/1483589b3e7114e0e63cde35a42781a73e1b976702009766e9b0e38667eb/lupa-2.1.tar.gz",
"platform": null,
"description": "Lupa\n====\n\n.. image:: logo/logo-220x200.png\n\nLupa integrates the runtimes of Lua_ or LuaJIT2_ into CPython.\nIt is a partial rewrite of LunaticPython_ in Cython_ with some\nadditional features such as proper coroutine support.\n\n.. _Lua: http://lua.org/\n.. _LuaJIT2: http://luajit.org/\n.. _LunaticPython: http://labix.org/lunatic-python\n.. _Cython: http://cython.org\n\nFor questions not answered here, please contact the `Lupa mailing list`_.\n\n.. _`Lupa mailing list`: http://www.freelists.org/list/lupa-dev\n\n.. contents:: :local:\n\n\nMajor features\n--------------\n\n* separate Lua runtime states through a ``LuaRuntime`` class\n\n* Python coroutine wrapper for Lua coroutines\n\n* iteration support for Python objects in Lua and Lua objects in\n Python\n\n* proper encoding and decoding of strings (configurable per runtime,\n UTF-8 by default)\n\n* frees the GIL and supports threading in separate runtimes when\n calling into Lua\n\n* tested with Python 2.7/3.6 and later\n\n* ships with Lua 5.1, 5.2, 5.3 and 5.4\n as well as LuaJIT 2.0 and 2.1 on systems that support it.\n\n* easy to hack on and extend as it is written in Cython, not C\n\n\nWhy the name?\n-------------\n\nIn Latin, \"lupa\" is a female wolf, as elegant and wild as it sounds.\nIf you don't like this kind of straight forward allegory to an\nendangered species, you may also happily assume it's just an\namalgamation of the phonetic sounds that start the words \"Lua\" and\n\"Python\", two from each to keep the balance.\n\n\nWhy use it?\n-----------\n\nIt complements Python very well. Lua is a language as dynamic as\nPython, but LuaJIT compiles it to very fast machine code, sometimes\nfaster than many statically compiled languages for computational code.\nThe language runtime is very small and carefully designed for\nembedding. The complete binary module of Lupa, including a statically\nlinked LuaJIT2 runtime, only weighs some 800KB on a 64 bit machine.\nWith standard Lua 5.2, it's less than 600KB.\n\nHowever, the Lua ecosystem lacks many of the batteries that Python\nreadily includes, either directly in its standard library or as third\nparty packages. This makes real-world Lua applications harder to write\nthan equivalent Python applications. Lua is therefore not commonly\nused as primary language for large applications, but it makes for a\nfast, high-level and resource-friendly backup language inside of\nPython when raw speed is required and the edit-compile-run cycle of\nbinary extension modules is too heavy and too static for agile\ndevelopment or hot-deployment.\n\nLupa is a very fast and thin wrapper around Lua or LuaJIT. It makes it\neasy to write dynamic Lua code that accompanies dynamic Python code by\nswitching between the two languages at runtime, based on the tradeoff\nbetween simplicity and speed.\n\n\nWhich Lua version?\n------------------\n\nThe binary wheels include different Lua versions as well as LuaJIT, if supported.\nBy default, ``import lupa`` uses the latest Lua version, but you can choose\na specific one via import:\n\n.. code:: python\n\n try:\n import lupa.luajit21 as lupa\n except ImportError:\n try:\n import lupa.lua54 as lupa\n except ImportError:\n try:\n import lupa.lua53 as lupa\n except ImportError:\n import lupa\n\n print(f\"Using {lupa.LuaRuntime().lua_implementation} (compiled with {lupa.LUA_VERSION})\")\n\n\nExamples\n--------\n\n..\n >>> import lupa.lua54 as lupa\n\n ## doctest helpers:\n >>> try: _ = sorted\n ... except NameError:\n ... def sorted(seq):\n ... l = list(seq)\n ... l.sort()\n ... return l\n\n.. code:: python\n\n >>> from lupa.lua54 import LuaRuntime\n >>> lua = LuaRuntime(unpack_returned_tuples=True)\n\n >>> lua.eval('1+1')\n 2\n\n >>> lua_func = lua.eval('function(f, n) return f(n) end')\n\n >>> def py_add1(n): return n+1\n >>> lua_func(py_add1, 2)\n 3\n\n >>> lua.eval('python.eval(\" 2 ** 2 \")') == 4\n True\n >>> lua.eval('python.builtins.str(4)') == '4'\n True\n\nThe function ``lua_type(obj)`` can be used to find out the type of a\nwrapped Lua object in Python code, as provided by Lua's ``type()``\nfunction:\n\n.. code:: python\n\n >>> lupa.lua_type(lua_func)\n 'function'\n >>> lupa.lua_type(lua.eval('{}'))\n 'table'\n\nTo help in distinguishing between wrapped Lua objects and normal\nPython objects, it returns ``None`` for the latter:\n\n.. code:: python\n\n >>> lupa.lua_type(123) is None\n True\n >>> lupa.lua_type('abc') is None\n True\n >>> lupa.lua_type({}) is None\n True\n\nNote the flag ``unpack_returned_tuples=True`` that is passed to create\nthe Lua runtime. It is new in Lupa 0.21 and changes the behaviour of\ntuples that get returned by Python functions. With this flag, they\nexplode into separate Lua values:\n\n.. code:: python\n\n >>> lua.execute('a,b,c = python.eval(\"(1,2)\")')\n >>> g = lua.globals()\n >>> g.a\n 1\n >>> g.b\n 2\n >>> g.c is None\n True\n\nWhen set to False, functions that return a tuple pass it through to the\nLua code:\n\n.. code:: python\n\n >>> non_explode_lua = lupa.LuaRuntime(unpack_returned_tuples=False)\n >>> non_explode_lua.execute('a,b,c = python.eval(\"(1,2)\")')\n >>> g = non_explode_lua.globals()\n >>> g.a\n (1, 2)\n >>> g.b is None\n True\n >>> g.c is None\n True\n\nSince the default behaviour (to not explode tuples) might change in a\nlater version of Lupa, it is best to always pass this flag explicitly.\n\n\nPython objects in Lua\n---------------------\n\nPython objects are either converted when passed into Lua (e.g.\nnumbers and strings) or passed as wrapped object references.\n\n.. code:: python\n\n >>> wrapped_type = lua.globals().type # Lua's own type() function\n >>> wrapped_type(1) == 'number'\n True\n >>> wrapped_type('abc') == 'string'\n True\n\nWrapped Lua objects get unwrapped when they are passed back into Lua,\nand arbitrary Python objects get wrapped in different ways:\n\n.. code:: python\n\n >>> wrapped_type(wrapped_type) == 'function' # unwrapped Lua function\n True\n >>> wrapped_type(len) == 'userdata' # wrapped Python function\n True\n >>> wrapped_type([]) == 'userdata' # wrapped Python object\n True\n\nLua supports two main protocols on objects: calling and indexing. It\ndoes not distinguish between attribute access and item access like\nPython does, so the Lua operations ``obj[x]`` and ``obj.x`` both map\nto indexing. To decide which Python protocol to use for Lua wrapped\nobjects, Lupa employs a simple heuristic.\n\nPratically all Python objects allow attribute access, so if the object\nalso has a ``__getitem__`` method, it is preferred when turning it\ninto an indexable Lua object. Otherwise, it becomes a simple object\nthat uses attribute access for indexing from inside Lua.\n\nObviously, this heuristic will fail to provide the required behaviour\nin many cases, e.g. when attribute access is required to an object\nthat happens to support item access. To be explicit about the\nprotocol that should be used, Lupa provides the helper functions\n``as_attrgetter()`` and ``as_itemgetter()`` that restrict the view on\nan object to a certain protocol, both from Python and from inside\nLua:\n\n.. code:: python\n\n >>> lua_func = lua.eval('function(obj) return obj[\"get\"] end')\n >>> d = {'get' : 'value'}\n\n >>> value = lua_func(d)\n >>> value == d['get'] == 'value'\n True\n\n >>> value = lua_func( lupa.as_itemgetter(d) )\n >>> value == d['get'] == 'value'\n True\n\n >>> dict_get = lua_func( lupa.as_attrgetter(d) )\n >>> dict_get == d.get\n True\n >>> dict_get('get') == d.get('get') == 'value'\n True\n\n >>> lua_func = lua.eval(\n ... 'function(obj) return python.as_attrgetter(obj)[\"get\"] end')\n >>> dict_get = lua_func(d)\n >>> dict_get('get') == d.get('get') == 'value'\n True\n\nNote that unlike Lua function objects, callable Python objects support\nindexing in Lua:\n\n.. code:: python\n\n >>> def py_func(): pass\n >>> py_func.ATTR = 2\n\n >>> lua_func = lua.eval('function(obj) return obj.ATTR end')\n >>> lua_func(py_func)\n 2\n >>> lua_func = lua.eval(\n ... 'function(obj) return python.as_attrgetter(obj).ATTR end')\n >>> lua_func(py_func)\n 2\n >>> lua_func = lua.eval(\n ... 'function(obj) return python.as_attrgetter(obj)[\"ATTR\"] end')\n >>> lua_func(py_func)\n 2\n\n\nIteration in Lua\n----------------\n\nIteration over Python objects from Lua's for-loop is fully supported.\nHowever, Python iterables need to be converted using one of the\nutility functions which are described here. This is similar to the\nfunctions like ``pairs()`` in Lua.\n\nTo iterate over a plain Python iterable, use the ``python.iter()``\nfunction. For example, you can manually copy a Python list into a Lua\ntable like this:\n\n.. code:: python\n\n >>> lua_copy = lua.eval('''\n ... function(L)\n ... local t, i = {}, 1\n ... for item in python.iter(L) do\n ... t[i] = item\n ... i = i + 1\n ... end\n ... return t\n ... end\n ... ''')\n\n >>> table = lua_copy([1,2,3,4])\n >>> len(table)\n 4\n >>> table[1] # Lua indexing\n 1\n\nPython's ``enumerate()`` function is also supported, so the above\ncould be simplified to:\n\n.. code:: python\n\n >>> lua_copy = lua.eval('''\n ... function(L)\n ... local t = {}\n ... for index, item in python.enumerate(L) do\n ... t[ index+1 ] = item\n ... end\n ... return t\n ... end\n ... ''')\n\n >>> table = lua_copy([1,2,3,4])\n >>> len(table)\n 4\n >>> table[1] # Lua indexing\n 1\n\nFor iterators that return tuples, such as ``dict.iteritems()``, it is\nconvenient to use the special ``python.iterex()`` function that\nautomatically explodes the tuple items into separate Lua arguments:\n\n.. code:: python\n\n >>> lua_copy = lua.eval('''\n ... function(d)\n ... local t = {}\n ... for key, value in python.iterex(d.items()) do\n ... t[key] = value\n ... end\n ... return t\n ... end\n ... ''')\n\n >>> d = dict(a=1, b=2, c=3)\n >>> table = lua_copy( lupa.as_attrgetter(d) )\n >>> table['b']\n 2\n\nNote that accessing the ``d.items`` method from Lua requires passing\nthe dict as ``attrgetter``. Otherwise, attribute access in Lua would\nuse the ``getitem`` protocol of Python dicts and look up ``d['items']``\ninstead.\n\n\nNone vs. nil\n------------\n\nWhile ``None`` in Python and ``nil`` in Lua differ in their semantics, they\nusually just mean the same thing: no value. Lupa therefore tries to map one\ndirectly to the other whenever possible:\n\n.. code:: python\n\n >>> lua.eval('nil') is None\n True\n >>> is_nil = lua.eval('function(x) return x == nil end')\n >>> is_nil(None)\n True\n\nThe only place where this cannot work is during iteration, because Lua\nconsiders a ``nil`` value the termination marker of iterators. Therefore,\nLupa special cases ``None`` values here and replaces them by a constant\n``python.none`` instead of returning ``nil``:\n\n.. code:: python\n\n >>> _ = lua.require(\"table\")\n >>> func = lua.eval('''\n ... function(items)\n ... local t = {}\n ... for value in python.iter(items) do\n ... table.insert(t, value == python.none)\n ... end\n ... return t\n ... end\n ... ''')\n\n >>> items = [1, None ,2]\n >>> list(func(items).values())\n [False, True, False]\n\nLupa avoids this value escaping whenever it's obviously not necessary.\nThus, when unpacking tuples during iteration, only the first value will\nbe subject to ``python.none`` replacement, as Lua does not look at the\nother items for loop termination anymore. And on ``enumerate()``\niteration, the first value is known to be always a number and never None,\nso no replacement is needed.\n\n.. code:: python\n\n >>> func = lua.eval('''\n ... function(items)\n ... for a, b, c, d in python.iterex(items) do\n ... return {a == python.none, a == nil, --> a == python.none\n ... b == python.none, b == nil, --> b == nil\n ... c == python.none, c == nil, --> c == nil\n ... d == python.none, d == nil} --> d == nil ...\n ... end\n ... end\n ... ''')\n\n >>> items = [(None, None, None, None)]\n >>> list(func(items).values())\n [True, False, False, True, False, True, False, True]\n\n >>> items = [(None, None)] # note: no values for c/d => nil in Lua\n >>> list(func(items).values())\n [True, False, False, True, False, True, False, True]\n\n\nNote that this behaviour changed in Lupa 1.0. Previously, the ``python.none``\nreplacement was done in more places, which made it not always very predictable.\n\n\nLua Tables\n----------\n\nLua tables mimic Python's mapping protocol. For the special case of\narray tables, Lua automatically inserts integer indices as keys into\nthe table. Therefore, indexing starts from 1 as in Lua instead of 0\nas in Python. For the same reason, negative indexing does not work.\nIt is best to think of Lua tables as mappings rather than arrays, even\nfor plain array tables.\n\n.. code:: python\n\n >>> table = lua.eval('{10,20,30,40}')\n >>> table[1]\n 10\n >>> table[4]\n 40\n >>> list(table)\n [1, 2, 3, 4]\n >>> dict(table)\n {1: 10, 2: 20, 3: 30, 4: 40}\n >>> list(table.values())\n [10, 20, 30, 40]\n >>> len(table)\n 4\n\n >>> mapping = lua.eval('{ [1] = -1 }')\n >>> list(mapping)\n [1]\n\n >>> mapping = lua.eval('{ [20] = -20; [3] = -3 }')\n >>> mapping[20]\n -20\n >>> mapping[3]\n -3\n >>> sorted(mapping.values())\n [-20, -3]\n >>> sorted(mapping.items())\n [(3, -3), (20, -20)]\n\n >>> mapping[-3] = 3 # -3 used as key, not index!\n >>> mapping[-3]\n 3\n >>> sorted(mapping)\n [-3, 3, 20]\n >>> sorted(mapping.items())\n [(-3, 3), (3, -3), (20, -20)]\n\nTo simplify the table creation from Python, the ``LuaRuntime`` comes with\na helper method that creates a Lua table from Python arguments:\n\n.. code:: python\n\n >>> t = lua.table(10, 20, 30, 40)\n >>> lupa.lua_type(t)\n 'table'\n >>> list(t)\n [1, 2, 3, 4]\n >>> list(t.values())\n [10, 20, 30, 40]\n\n >>> t = lua.table(10, 20, 30, 40, a=1, b=2)\n >>> t[3]\n 30\n >>> t['b']\n 2\n\nA second helper method, ``.table_from()``, was added in Lupa 1.1 and accepts\nany number of mappings and sequences/iterables as arguments. It collects\nall values and key-value pairs and builds a single Lua table from them.\nAny keys that appear in multiple mappings get overwritten with their last\nvalue (going from left to right).\n\n.. code:: python\n\n >>> t = lua.table_from([10, 20, 30], {'a': 11, 'b': 22}, (40, 50), {'b': 42})\n >>> t['a']\n 11\n >>> t['b']\n 42\n >>> t[5]\n 50\n >>> sorted(t.values())\n [10, 11, 20, 30, 40, 42, 50]\n\nSince Lupa 2.1, passing ``recursive=True`` will map data structures recursively\nto Lua tables.\n\n.. code:: python\n\n >>> t = lua.table_from(\n ... [\n ... # t1:\n ... [\n ... [10, 20, 30],\n ... {'a': 11, 'b': 22}\n ... ],\n ... # t2:\n ... [\n ... (40, 50),\n ... {'b': 42}\n ... ]\n ... ],\n ... recursive=True\n ... )\n >>> t1, t2 = t.values()\n >>> list(t1[1].values())\n [10, 20, 30]\n >>> t1[2]['a']\n 11\n >>> t1[2]['b']\n 22\n >>> t2[2]['b']\n 42\n >>> list(t1[1].values())\n [10, 20, 30]\n >>> list(t2[1].values())\n [40, 50]\n\nA lookup of non-existing keys or indices returns None (actually ``nil``\ninside of Lua). A lookup is therefore more similar to the ``.get()``\nmethod of Python dicts than to a mapping lookup in Python.\n\n.. code:: python\n\n >>> table = lua.table(10, 20, 30, 40)\n >>> table[1000000] is None\n True\n >>> table['no such key'] is None\n True\n\n >>> mapping = lua.eval('{ [20] = -20; [3] = -3 }')\n >>> mapping['no such key'] is None\n True\n\nNote that ``len()`` does the right thing for array tables but does not\nwork on mappings:\n\n.. code:: python\n\n >>> len(table)\n 4\n >>> len(mapping)\n 0\n\nThis is because ``len()`` is based on the ``#`` (length) operator in\nLua and because of the way Lua defines the length of a table.\nRemember that unset table indices always return ``nil``, including\nindices outside of the table size. Thus, Lua basically looks for an\nindex that returns ``nil`` and returns the index before that. This\nworks well for array tables that do not contain ``nil`` values, gives\nbarely predictable results for tables with 'holes' and does not work\nat all for mapping tables. For tables with both sequential and\nmapping content, this ignores the mapping part completely.\n\nNote that it is best not to rely on the behaviour of len() for\nmappings. It might change in a later version of Lupa.\n\nSimilar to the table interface provided by Lua, Lupa also supports\nattribute access to table members:\n\n.. code:: python\n\n >>> table = lua.eval('{ a=1, b=2 }')\n >>> table.a, table.b\n (1, 2)\n >>> table.a == table['a']\n True\n\nThis enables access to Lua 'methods' that are associated with a table,\nas used by the standard library modules:\n\n.. code:: python\n\n >>> string = lua.eval('string') # get the 'string' library table\n >>> print( string.lower('A') )\n a\n\n\nPython Callables\n----------------\n\nAs discussed earlier, Lupa allows Lua scripts to call Python functions\nand methods:\n\n.. code:: python\n\n >>> def add_one(num):\n ... return num + 1\n >>> lua_func = lua.eval('function(num, py_func) return py_func(num) end')\n >>> lua_func(48, add_one)\n 49\n\n >>> class MyClass():\n ... def my_method(self):\n ... return 345\n >>> obj = MyClass()\n >>> lua_func = lua.eval('function(py_obj) return py_obj:my_method() end')\n >>> lua_func(obj)\n 345\n\nLua doesn't have a dedicated syntax for named arguments, so by default\nPython callables can only be called using positional arguments.\n\nA common pattern for implementing named arguments in Lua is passing them\nin a table as the first and only function argument. See\nhttp://lua-users.org/wiki/NamedParameters for more details. Lupa supports\nthis pattern by providing two decorators: ``lupa.unpacks_lua_table``\nfor Python functions and ``lupa.unpacks_lua_table_method`` for methods\nof Python objects.\n\nPython functions/methods wrapped in these decorators can be called from\nLua code as ``func(foo, bar)``, ``func{foo=foo, bar=bar}``\nor ``func{foo, bar=bar}``. Example:\n\n.. code:: python\n\n >>> @lupa.unpacks_lua_table\n ... def add(a, b):\n ... return a + b\n >>> lua_func = lua.eval('function(a, b, py_func) return py_func{a=a, b=b} end')\n >>> lua_func(5, 6, add)\n 11\n >>> lua_func = lua.eval('function(a, b, py_func) return py_func{a, b=b} end')\n >>> lua_func(5, 6, add)\n 11\n\nIf you do not control the function implementation, you can also just\nmanually wrap a callable object when passing it into Lupa:\n\n.. code:: python\n\n >>> import operator\n >>> wrapped_py_add = lupa.unpacks_lua_table(operator.add)\n\n >>> lua_func = lua.eval('function(a, b, py_func) return py_func{a, b} end')\n >>> lua_func(5, 6, wrapped_py_add)\n 11\n\nThere are some limitations:\n\n1. Avoid using ``lupa.unpacks_lua_table`` and ``lupa.unpacks_lua_table_method``\n for functions where the first argument can be a Lua table. In this case\n ``py_func{foo=bar}`` (which is the same as ``py_func({foo=bar})`` in Lua)\n becomes ambiguous: it could mean either \"call ``py_func`` with a named\n ``foo`` argument\" or \"call ``py_func`` with a positional ``{foo=bar}``\n argument\".\n\n2. One should be careful with passing ``nil`` values to callables wrapped in\n ``lupa.unpacks_lua_table`` or ``lupa.unpacks_lua_table_method`` decorators.\n Depending on the context, passing ``nil`` as a parameter can mean either\n \"omit a parameter\" or \"pass None\". This even depends on the Lua version.\n\n It is possible to use ``python.none`` instead of ``nil`` to pass None values\n robustly. Arguments with ``nil`` values are also fine when standard braces\n ``func(a, b, c)`` syntax is used.\n\nBecause of these limitations lupa doesn't enable named arguments for all\nPython callables automatically. Decorators allow to enable named arguments\non a per-callable basis.\n\n\nLua Coroutines\n--------------\n\nThe next is an example of Lua coroutines. A wrapped Lua coroutine\nbehaves exactly like a Python coroutine. It needs to get created at\nthe beginning, either by using the ``.coroutine()`` method of a\nfunction or by creating it in Lua code. Then, values can be sent into\nit using the ``.send()`` method or it can be iterated over. Note that\nthe ``.throw()`` method is not supported, though.\n\n.. code:: python\n\n >>> lua_code = '''\\\n ... function(N)\n ... for i=0,N do\n ... coroutine.yield( i%2 )\n ... end\n ... end\n ... '''\n >>> lua = LuaRuntime()\n >>> f = lua.eval(lua_code)\n\n >>> gen = f.coroutine(4)\n >>> list(enumerate(gen))\n [(0, 0), (1, 1), (2, 0), (3, 1), (4, 0)]\n\nAn example where values are passed into the coroutine using its\n``.send()`` method:\n\n.. code:: python\n\n >>> lua_code = '''\\\n ... function()\n ... local t,i = {},0\n ... local value = coroutine.yield()\n ... while value do\n ... t[i] = value\n ... i = i + 1\n ... value = coroutine.yield()\n ... end\n ... return t\n ... end\n ... '''\n >>> f = lua.eval(lua_code)\n\n >>> co = f.coroutine() # create coroutine\n >>> co.send(None) # start coroutine (stops at first yield)\n\n >>> for i in range(3):\n ... co.send(i*2)\n\n >>> mapping = co.send(None) # loop termination signal\n >>> sorted(mapping.items())\n [(0, 0), (1, 2), (2, 4)]\n\nIt also works to create coroutines in Lua and to pass them back into\nPython space:\n\n.. code:: python\n\n >>> lua_code = '''\\\n ... function f(N)\n ... for i=0,N do\n ... coroutine.yield( i%2 )\n ... end\n ... end ;\n ... co1 = coroutine.create(f) ;\n ... co2 = coroutine.create(f) ;\n ...\n ... status, first_result = coroutine.resume(co2, 2) ; -- starting!\n ...\n ... return f, co1, co2, status, first_result\n ... '''\n\n >>> lua = LuaRuntime()\n >>> f, co, lua_gen, status, first_result = lua.execute(lua_code)\n\n >>> # a running coroutine:\n\n >>> status\n True\n >>> first_result\n 0\n >>> list(lua_gen)\n [1, 0]\n >>> list(lua_gen)\n []\n\n >>> # an uninitialised coroutine:\n\n >>> gen = co(4)\n >>> list(enumerate(gen))\n [(0, 0), (1, 1), (2, 0), (3, 1), (4, 0)]\n\n >>> gen = co(2)\n >>> list(enumerate(gen))\n [(0, 0), (1, 1), (2, 0)]\n\n >>> # a plain function:\n\n >>> gen = f.coroutine(4)\n >>> list(enumerate(gen))\n [(0, 0), (1, 1), (2, 0), (3, 1), (4, 0)]\n\n\nThreading\n---------\n\nThe following example calculates a mandelbrot image in parallel\nthreads and displays the result in PIL. It is based on a `benchmark\nimplementation`_ for the `Computer Language Benchmarks Game`_.\n\n.. _`Computer Language Benchmarks Game`: http://shootout.alioth.debian.org/u64/benchmark.php?test=all&lang=luajit&lang2=python3\n.. _`benchmark implementation`: http://shootout.alioth.debian.org/u64/program.php?test=mandelbrot&lang=luajit&id=1\n\n.. code:: python\n\n lua_code = '''\\\n function(N, i, total)\n local char, unpack = string.char, table.unpack\n local result = \"\"\n local M, ba, bb, buf = 2/N, 2^(N%8+1)-1, 2^(8-N%8), {}\n local start_line, end_line = N/total * (i-1), N/total * i - 1\n for y=start_line,end_line do\n local Ci, b, p = y*M-1, 1, 0\n for x=0,N-1 do\n local Cr = x*M-1.5\n local Zr, Zi, Zrq, Ziq = Cr, Ci, Cr*Cr, Ci*Ci\n b = b + b\n for i=1,49 do\n Zi = Zr*Zi*2 + Ci\n Zr = Zrq-Ziq + Cr\n Ziq = Zi*Zi\n Zrq = Zr*Zr\n if Zrq+Ziq > 4.0 then b = b + 1; break; end\n end\n if b >= 256 then p = p + 1; buf[p] = 511 - b; b = 1; end\n end\n if b ~= 1 then p = p + 1; buf[p] = (ba-b)*bb; end\n result = result .. char(unpack(buf, 1, p))\n end\n return result\n end\n '''\n\n image_size = 1280 # == 1280 x 1280\n thread_count = 8\n\n from lupa import LuaRuntime\n lua_funcs = [ LuaRuntime(encoding=None).eval(lua_code)\n for _ in range(thread_count) ]\n\n results = [None] * thread_count\n def mandelbrot(i, lua_func):\n results[i] = lua_func(image_size, i+1, thread_count)\n\n import threading\n threads = [ threading.Thread(target=mandelbrot, args=(i,lua_func))\n for i, lua_func in enumerate(lua_funcs) ]\n for thread in threads:\n thread.start()\n for thread in threads:\n thread.join()\n\n result_buffer = b''.join(results)\n\n # use Pillow to display the image\n from PIL import Image\n image = Image.frombytes('1', (image_size, image_size), result_buffer)\n image.show()\n\nNote how the example creates a separate ``LuaRuntime`` for each thread\nto enable parallel execution. Each ``LuaRuntime`` is protected by a\nglobal lock that prevents concurrent access to it. The low memory\nfootprint of Lua makes it reasonable to use multiple runtimes, but\nthis setup also means that values cannot easily be exchanged between\nthreads inside of Lua. They must either get copied through Python\nspace (passing table references will not work, either) or use some Lua\nmechanism for explicit communication, such as a pipe or some kind of\nshared memory setup.\n\n\nRestricting Lua access to Python objects\n----------------------------------------\n\n..\n >>> try: unicode = unicode\n ... except NameError: unicode = str\n\nLupa provides a simple mechanism to control access to Python objects.\nEach attribute access can be passed through a filter function as\nfollows:\n\n.. code:: python\n\n >>> def filter_attribute_access(obj, attr_name, is_setting):\n ... if isinstance(attr_name, unicode):\n ... if not attr_name.startswith('_'):\n ... return attr_name\n ... raise AttributeError('access denied')\n\n >>> lua = lupa.LuaRuntime(\n ... register_eval=False,\n ... attribute_filter=filter_attribute_access)\n >>> func = lua.eval('function(x) return x.__class__ end')\n >>> func(lua)\n Traceback (most recent call last):\n ...\n AttributeError: access denied\n\nThe ``is_setting`` flag indicates whether the attribute is being read\nor set.\n\nNote that the attributes of Python functions provide access to the\ncurrent ``globals()`` and therefore to the builtins etc. If you want\nto safely restrict access to a known set of Python objects, it is best\nto work with a whitelist of safe attribute names. One way to do that\ncould be to use a well selected list of dedicated API objects that you\nprovide to Lua code, and to only allow Python attribute access to the\nset of public attribute/method names of these objects.\n\nSince Lupa 1.0, you can alternatively provide dedicated getter and\nsetter function implementations for a ``LuaRuntime``:\n\n.. code:: python\n\n >>> def getter(obj, attr_name):\n ... if attr_name == 'yes':\n ... return getattr(obj, attr_name)\n ... raise AttributeError(\n ... 'not allowed to read attribute \"%s\"' % attr_name)\n\n >>> def setter(obj, attr_name, value):\n ... if attr_name == 'put':\n ... setattr(obj, attr_name, value)\n ... return\n ... raise AttributeError(\n ... 'not allowed to write attribute \"%s\"' % attr_name)\n\n >>> class X(object):\n ... yes = 123\n ... put = 'abc'\n ... noway = 2.1\n\n >>> x = X()\n\n >>> lua = lupa.LuaRuntime(attribute_handlers=(getter, setter))\n >>> func = lua.eval('function(x) return x.yes end')\n >>> func(x) # getting 'yes'\n 123\n >>> func = lua.eval('function(x) x.put = \"ABC\"; end')\n >>> func(x) # setting 'put'\n >>> print(x.put)\n ABC\n >>> func = lua.eval('function(x) x.noway = 42; end')\n >>> func(x) # setting 'noway'\n Traceback (most recent call last):\n ...\n AttributeError: not allowed to write attribute \"noway\"\n\n\nRestricting Lua Memory Usage\n----------------------------\n\nLupa provides a simple mechanism to control the maximum memory\nusage of the Lua Runtime since version 2.0.\nBy default Lupa does not interfere with Lua's memory allocation, to opt-in\nyou must set the ``max_memory`` when creating the LuaRuntime.\n\nThe ``LuaRuntime`` provides three methods for controlling and reading the\nmemory usage:\n\n1. ``get_memory_used(total=False)`` to get the current memory\n usage of the LuaRuntime.\n\n2. ``get_max_memory(total=False)`` to get the current memory limit.\n ``0`` means there is no memory limitation.\n\n3. ``set_max_memory(max_memory, total=False)`` to change the memory limit.\n Values below or equal to 0 mean no limit.\n\nThere is always some memory used by the LuaRuntime itself (around ~20KiB,\ndepending on your lua version and other factors) which is excluded from all\ncalculations unless you specify ``total=True``.\n\n.. code:: python\n\n >>> from lupa import lua52\n >>> lua = lua52.LuaRuntime(max_memory=0) # 0 for unlimited, default is None\n >>> lua.get_memory_used() # memory used by your code\n 0\n >>> total_lua_memory = lua.get_memory_used(total=True) # includes memory used by the runtime itself\n >>> assert total_lua_memory > 0 # exact amount depends on your lua version and other factors\n\n\nLua code hitting the memory limit will receive memory errors:\n\n.. code:: python\n\n >>> lua.set_max_memory(100)\n >>> lua.eval(\"string.rep('a', 1000)\") # doctest: +IGNORE_EXCEPTION_DETAIL\n Traceback (most recent call last):\n ...\n lupa.LuaMemoryError: not enough memory\n\n``LuaMemoryError`` inherits from ``LuaError`` and ``MemoryError``.\n\n\nImporting Lua binary modules\n----------------------------\n\n**This will usually work as is**, but here are the details, in case\nanything goes wrong for you.\n\nTo use binary modules in Lua, you need to compile them against the\nheader files of the LuaJIT sources that you used to build Lupa, but do\nnot link them against the LuaJIT library.\n\nFurthermore, CPython needs to enable global symbol visibility for\nshared libraries before loading the Lupa module. This can be done by\ncalling ``sys.setdlopenflags(flag_values)``. Importing the ``lupa``\nmodule will automatically try to set up the correct ``dlopen`` flags\nif it can find the platform specific ``DLFCN`` Python module that\ndefines the necessary flag constants. In that case, using binary\nmodules in Lua should work out of the box.\n\nIf this setup fails, however, you have to set the flags manually.\nWhen using the above configuration call, the argument ``flag_values``\nmust represent the sum of your system's values for ``RTLD_NEW`` and\n``RTLD_GLOBAL``. If ``RTLD_NEW`` is 2 and ``RTLD_GLOBAL`` is 256, you\nneed to call ``sys.setdlopenflags(258)``.\n\nAssuming that the Lua luaposix_ (``posix``) module is available, the\nfollowing should work on a Linux system:\n\n.. code:: python\n\n >>> import sys\n >>> orig_dlflags = sys.getdlopenflags()\n >>> sys.setdlopenflags(258)\n >>> import lupa\n >>> sys.setdlopenflags(orig_dlflags)\n\n >>> lua = lupa.LuaRuntime()\n >>> posix_module = lua.require('posix') # doctest: +SKIP\n\n.. _luaposix: http://git.alpinelinux.org/cgit/luaposix\n\n\nBuilding with different Lua versions\n------------------------------------\n\nThe build is configured to automatically search for an installed version\nof first LuaJIT and then Lua, and failing to find either, to use the bundled\nLuaJIT or Lua version.\n\nIf you wish to build Lupa with a specific version of Lua, you can\nconfigure the following options on setup:\n\n.. list-table::\n :widths: 20 35\n :header-rows: 1\n\n * - Option\n - Description\n * - ``--lua-lib <libfile>``\n - Lua library file path, e.g. ``--lua-lib /usr/local/lib/lualib.a``\n * - ``--lua-includes <incdir>``\n - Lua include directory, e.g. ``--lua-includes /usr/local/include``\n * - ``--use-bundle``\n - Use bundled LuaJIT or Lua instead of searching for an installed version.\n * - ``--no-bundle``\n - Don't use the bundled LuaJIT/Lua, search for an installed version of LuaJIT or Lua,\n e.g. using ``pkg-config``.\n * - ``--no-lua-jit``\n - Don't use or search for LuaJIT, only use or search Lua instead.\n\n\nInstalling lupa\n===============\n\nBuilding with LuaJIT2\n---------------------\n\n#) Download and unpack lupa\n\n http://pypi.python.org/pypi/lupa\n\n#) Download LuaJIT2\n\n http://luajit.org/download.html\n\n#) Unpack the archive into the lupa base directory, e.g.::\n\n .../lupa-0.1/LuaJIT-2.0.2\n\n#) Build LuaJIT::\n\n cd LuaJIT-2.0.2\n make\n cd ..\n\n If you need specific C compiler flags, pass them to ``make`` as follows::\n\n make CFLAGS=\"...\"\n\n For trickier target platforms like Windows and MacOS-X, please see\n the official `installation instructions for LuaJIT`_.\n\n NOTE: When building on Windows, make sure that lua51.lib is made in addition\n to lua51.dll. The MSVC build produces this file, MinGW does NOT.\n\n#) Build lupa::\n\n python setup.py build_ext -i\n\n Or any other distutils target of your choice, such as ``build``\n or one of the ``bdist`` targets. See the `distutils\n documentation`_ for help, also the `hints on building extension\n modules`_.\n\n Note that on 64bit MacOS-X installations, the following additional\n compiler flags are reportedly required due to the embedded LuaJIT::\n\n -pagezero_size 10000 -image_base 100000000\n\n You can find additional installation hints for MacOS-X in this\n `somewhat unclear blog post`_, which may or may not tell you at\n which point in the installation process to provide these flags.\n\n Also, on 64bit MacOS-X, you will typically have to set the\n environment variable ``ARCHFLAGS`` to make sure it only builds\n for your system instead of trying to generate a fat binary with\n both 32bit and 64bit support::\n\n export ARCHFLAGS=\"-arch x86_64\"\n\n Note that this applies to both LuaJIT and Lupa, so make sure\n you try a clean build of everything if you forgot to set it\n initially.\n\n.. _`installation instructions for LuaJIT`: http://luajit.org/install.html\n.. _`somewhat unclear blog post`: http://t-p-j.blogspot.com/2010/11/lupa-on-os-x-with-macports-python-26.html\n.. _`distutils documentation`: http://docs.python.org/install/index.html#install-index\n.. _`hints on building extension modules`: http://docs.python.org/install/index.html#building-extensions-tips-and-tricks\n\n\nBuilding with Lua 5.x\n---------------------\n\nIt also works to use Lupa with the standard (non-JIT) Lua\nruntime. The easiest way is to use the bundled lua submodule:\n\n#) Clone the submodule::\n\n $ git submodule update --init third-party/lua\n\n#) Build Lupa::\n\n $ python3 setup.py bdist_wheel --use-bundle --with-cython\n\nYou can also build it by installing a Lua 5.x package, including\nany development packages (header files etc.). On systems that\nuse the \"pkg-config\" configuration mechanism, Lupa's\nsetup.py will pick up either LuaJIT2 or Lua automatically, with a\npreference for LuaJIT2 if it is found. Pass the ``--no-luajit`` option\nto the setup.py script if you have both installed but do not want to\nuse LuaJIT2.\n\nOn other systems, you may have to supply the build parameters\nexternally, e.g. using environment variables or by changing the\nsetup.py script manually. Pass the ``--no-luajit`` option to the\nsetup.py script in order to ignore the failure you get when neither\nLuaJIT2 nor Lua are found automatically.\n\nFor further information, read this mailing list post:\n\nhttps://www.freelists.org/post/lupa-dev/Lupa-with-normal-Lua-interpreter-Lua-51,2\n\n\nInstalling lupa from packages\n=============================\n\nDebian/Ubuntu + Lua 5.2\n-----------------------\n\n#) Install Lua 5.2 development package::\n\n $ apt-get install liblua5.2-dev\n\n#) Install lupa::\n\n $ pip install lupa\n\nDebian/Ubuntu + LuaJIT2\n-----------------------\n\n#) Install LuaJIT2 development package::\n\n $ apt-get install libluajit-5.1-dev\n\n#) Install lupa::\n\n $ pip install lupa\n\nDepending on OS version, you might get an older LuaJIT2 version.\n\nOS X + Lua 5.2 + Homebrew\n-------------------------\n\n#) Install Lua::\n\n $ brew install lua\n\n#) Install pkg-config::\n\n $ brew install pkg-config\n\n#) Install lupa::\n\n $ pip install lupa\n\n\nLupa change log\n===============\n\n2.1 (2024-03-24)\n----------------\n\n* GH#199: The ``table_from()`` method gained a new keyword argument ``recursive=False``.\n If true, Python data structures will be recursively mapped to Lua tables,\n taking care of loops and duplicates via identity de-duplication.\n\n* GH#248: The LuaRuntime methods \"eval\", \"execute\" and \"compile\" gained new\n keyword options ``mode`` and ``name`` that allow constraining the input type\n and modifying the (chunk) name shown in error messages, following similar\n arguments in the Lua ``load()`` function.\n See https://www.lua.org/manual/5.4/manual.html#pdf-load\n\n* GH#246: Loading Lua modules did not work for the version specific Lua modules\n introduced in Lupa 2.0. It turned out that it can only be enabled for\n one of them in a given Python run, so it is now left to users to enable it\n explicitly at need.\n (original patch by Richard Connon)\n\n* GH#234: The bundled Lua 5.1 was updated to 5.1.5 and Lua 5.2 to 5.2.4.\n (patch by xxyzz)\n\n* The bundled Lua 5.4 was updated to 5.4.6.\n\n* The bundled LuaJIT versions were updated to the latest git branches.\n\n* Built with Cython 3.0.9 for improved support of Python 3.12/13.\n\n\n2.0 (2023-04-03)\n----------------\n\n* GH#217: Lua stack traces in Python exception messages are now reversed to\n match the order of Python stack traces.\n\n* GH#196: Lupa now ships separate extension modules built with Lua 5.3,\n Lua 5.4, LuaJIT 2.0 and LuaJIT 2.1 beta. Note that this is build specific\n and may depend on the platform. A normal Python import cascade can be used.\n\n* GH#211: A new option `max_memory` allows to limit the memory usage of Lua code.\n (patch by Leo Developer)\n\n* GH#171: Python references in Lua are now more safely reference counted\n to prevent garbage collection glitches.\n (patch by Guilherme Dantas)\n\n* GH#146: Lua integers in Lua 5.3+ are converted from and to Python integers.\n (patch by Guilherme Dantas)\n\n* GH#180: The ``python.enumerate()`` function now returns indices as integers\n if supported by Lua.\n (patch by Guilherme Dantas)\n\n* GH#178: The Lua integer limits can be read from the module as\n ``LUA_MAXINTEGER`` and ``LUA_MININTEGER``.\n (patch by Guilherme Dantas)\n\n* GH#174: Failures while calling the ``__index`` method in Lua during a\n table index lookup from Python could crash Python.\n (patch by Guilherme Dantas)\n\n* GH#137: Passing ``None`` as a dict key into ``table_from()`` crashed.\n (patch by Leo Developer)\n\n* GH#176: A new function ``python.args(*args, **kwargs)`` was added\n to help with building Python argument tuples and keyword argument dicts\n for Python function calls from Lua code.\n\n* GH#177: Tables that are not sequences raise ``IndexError`` when unpacking\n them. Previously, non-sequential items were simply ignored.\n\n* GH#179: Resolve some C compiler warnings about signed/unsigned comparisons.\n (patch by Guilherme Dantas)\n\n* Built with Cython 0.29.34.\n\n\n1.14.1 (2022-11-16)\n-------------------\n\n* Rebuild with Cython 0.29.32 to support Python 3.11.\n\n\n1.13 (2022-03-01)\n-----------------\n\n* Bundled Lua source files were missing in the source distribution.\n\n\n1.12 (2022-02-24)\n-----------------\n\n* GH#197: Some binary wheels in the last releases were not correctly linked with Lua.\n\n* GH#194: An absolute file path appeared in the ``SOURCES.txt`` metadata\n of the source distribution.\n\n\n1.11 (2022-02-23)\n-----------------\n\n* Use Lua 5.4.4 in binary wheels and as bundled Lua.\n\n* Built with Cython 0.29.28 to support Python 3.10/11.\n\n\n1.10 (2021-09-02)\n-----------------\n\n* GH#147: Lua 5.4 is supported.\n (patch by Russel Davis)\n\n* The runtime version of the Lua library as a tuple (e.g. ``(5,3)``)\n is provided via ``lupa.LUA_VERSION`` and ``LuaRuntime.lua_version``.\n\n* The Lua implementation name and version string is provided as\n ``LuaRuntime.lua_implementation``.\n\n* ``setup.py`` accepts new command line arguments ``--lua-lib`` and ``--lua-includes``\n to specify the\n\n* Use Lua 5.4.3 in binary wheels and as bundled Lua.\n\n* Built with Cython 0.29.24 to support Python 3.9.\n\n\n1.9 (2019-12-21)\n----------------\n\n* Build against Lua 5.3 if available.\n\n* Use Lua 5.3.5 in binary wheels and as bundled Lua.\n\n* GH#129: Fix Lua module loading in Python 3.x.\n\n* GH#126: Fix build on Linux systems that install Lua as \"lua52\" package.\n\n* Built with Cython 0.29.14 for better Py3.8 compatibility.\n\n\n1.8 (2019-02-01)\n----------------\n\n* GH#107: Fix a deprecated import in Py3.\n\n* Built with Cython 0.29.3 for better Py3.7 compatibility.\n\n\n1.7 (2018-08-06)\n----------------\n\n* GH#103: Provide wheels for MS Windows and fix MSVC build on Py2.7.\n\n\n1.6 (2017-12-15)\n----------------\n\n* GH#95: Improved compatibility with Lua 5.3.\n (patch by TitanSnow)\n\n\n1.5 (2017-09-16)\n----------------\n\n* GH#93: New method ``LuaRuntime.compile()`` to compile Lua code\n without executing it.\n (patch by TitanSnow)\n\n* GH#91: Lua 5.3 is bundled in the source distribution to simplify\n one-shot installs.\n (patch by TitanSnow)\n\n* GH#87: Lua stack trace is included in output in debug mode.\n (patch by aaiyer)\n\n* GH#78: Allow Lua code to intercept Python exceptions.\n (patch by Sergey Dobrov)\n\n* Built with Cython 0.26.1.\n\n\n1.4 (2016-12-10)\n----------------\n\n* GH#82: Lua coroutines were using the wrong runtime state\n (patch by Sergey Dobrov)\n\n* GH#81: copy locally provided Lua DLL into installed package on Windows\n (patch by Gareth Coles)\n\n* built with Cython 0.25.2\n\n\n1.3 (2016-04-12)\n----------------\n\n* GH#70: ``eval()`` and ``execute()`` accept optional positional arguments\n (patch by John Vandenberg)\n\n* GH#65: calling ``str()`` on a Python object from Lua could fail if the\n ``LuaRuntime`` is set up without auto-encoding (patch by Mikhail Korobov)\n\n* GH#63: attribute/keyword names were not properly encoded if the\n ``LuaRuntime`` is set up without auto-encoding (patch by Mikhail Korobov)\n\n* built with Cython 0.24\n\n\n1.2 (2015-10-10)\n----------------\n\n* callbacks returned from Lua coroutines were incorrectly mixing\n coroutine state with global Lua state (patch by Mikhail Korobov)\n\n* availability of ``python.builtins`` in Lua can be disabled via\n ``LuaRuntime`` option.\n\n* built with Cython 0.23.4\n\n\n1.1 (2014-11-21)\n----------------\n\n* new module function ``lupa.lua_type()`` that returns the Lua type of\n a wrapped object as string, or ``None`` for normal Python objects\n\n* new helper method ``LuaRuntime.table_from(...)`` that creates a Lua\n table from one or more Python mappings and/or sequences\n\n* new ``lupa.unpacks_lua_table`` and ``lupa.unpacks_lua_table_method``\n decorators to allow calling Python functions from Lua using named\n arguments\n\n* fix a hang on shutdown where the LuaRuntime failed to deallocate due\n to reference cycles\n\n* Lupa now plays more nicely with other Lua extensions that create\n userdata objects\n\n\n1.0.1 (2014-10-11)\n------------------\n\n* fix a crash when requesting attributes of wrapped Lua coroutine objects\n\n* looking up attributes on Lua objects that do not support it now always\n raises an AttributeError instead of sometimes raising a TypeError depending\n on the attribute name\n\n\n1.0 (2014-09-28)\n----------------\n\n* NOTE: this release includes the major backwards incompatible changes listed\n below. It is believed that they simplify the interaction between Python code\n and Lua code by more strongly following idiomatic Lua on the Lua side.\n\n * Instead of passing a wrapped ``python.none`` object into Lua, ``None``\n return values are now mapped to ``nil``, making them more straight forward\n to handle in Lua code. This makes the behaviour more consistent, as it\n was previously somewhat arbitrary where ``none`` could appear and where a\n ``nil`` value was used. The only remaining exception is during iteration,\n where the first returned value must not be ``nil`` in Lua, or otherwise\n the loop terminates prematurely. To prevent this, any ``None`` value\n that the iterator returns, or any first item in exploded tuples that is\n ``None``, is still mapped to ``python.none``. Any further values\n returned in the same iteration will be mapped to ``nil`` if they are\n ``None``, not to ``none``. This means that only the first argument\n needs to be manually checked for this special case. For the\n ``enumerate()`` iterator, the counter is never ``None`` and thus the\n following unpacked items will never be mapped to ``python.none``.\n\n * When ``unpack_returned_tuples=True``, iteration now also unpacks tuple\n values, including ``enumerate()`` iteration, which yields a flat sequence\n of counter and unpacked values.\n\n * When calling bound Python methods from Lua as \"obj:meth()\", Lupa now\n prevents Python from prepending the self argument a second time, so that\n the Python method is now called as \"obj.meth()\". Previously, it was called\n as \"obj.meth(obj)\". Note that this can be undesired when the object itself\n is explicitly passed as first argument from Lua, e.g. when calling\n \"func(obj)\" where \"func\" is \"obj.meth\", but these constellations should be\n rare. As a work-around for this case, user code can wrap the bound method\n in another function so that the final call comes from Python.\n\n* garbage collection works for reference cycles that span both runtimes,\n Python and Lua\n\n* calling from Python into Lua and back into Python did not clean up the\n Lua call arguments before the innermost call, so that they could leak\n into the nested Python call or its return arguments\n\n* support for Lua 5.2 (in addition to Lua 5.1 and LuaJIT 2.0)\n\n* Lua tables support Python's \"del\" statement for item deletion\n (patch by Jason Fried)\n\n* Attribute lookup can use a more fine-grained control mechanism by\n implementing explicit getter and setter functions for a LuaRuntime\n (``attribute_handlers`` argument). Patch by Brian Moe.\n\n* item assignments/lookups on Lua objects from Python no longer\n special case double underscore names (as opposed to attribute lookups)\n\n\n0.21 (2014-02-12)\n-----------------\n\n* some garbage collection issues were cleaned up using new Cython features\n\n* new ``LuaRuntime`` option ``unpack_returned_tuples`` which automatically\n unpacks tuples returned from Python functions into separate Lua objects\n (instead of returning a single Python tuple object)\n\n* some internal wrapper classes were removed from the module API\n\n* Windows build fixes\n\n* Py3.x build fixes\n\n* support for building with Lua 5.1 instead of LuaJIT (setup.py --no-luajit)\n\n* no longer uses Cython by default when building from released sources (pass\n ``--with-cython`` to explicitly request a rebuild)\n\n* requires Cython 0.20+ when building from unreleased sources\n\n* built with Cython 0.20.1\n\n\n0.20 (2011-05-22)\n-----------------\n\n* fix \"deallocating None\" crash while iterating over Lua tables in\n Python code\n\n* support for filtering attribute access to Python objects for Lua\n code\n\n* fix: setting source encoding for Lua code was broken\n\n\n0.19 (2011-03-06)\n-----------------\n\n* fix serious resource leak when creating multiple LuaRuntime instances\n\n* portability fix for binary module importing\n\n\n0.18 (2010-11-06)\n-----------------\n\n* fix iteration by returning ``Py_None`` object for ``None`` instead\n of ``nil``, which would terminate the iteration\n\n* when converting Python values to Lua, represent ``None`` as a\n ``Py_None`` object in places where ``nil`` has a special meaning,\n but leave it as ``nil`` where it doesn't hurt\n\n* support for counter start value in ``python.enumerate()``\n\n* native implementation for ``python.enumerate()`` that is several\n times faster\n\n* much faster Lua iteration over Python objects\n\n\n0.17 (2010-11-05)\n-----------------\n\n* new helper function ``python.enumerate()`` in Lua that returns a Lua\n iterator for a Python object and adds the 0-based index to each\n item.\n\n* new helper function ``python.iterex()`` in Lua that returns a Lua\n iterator for a Python object and unpacks any tuples that the\n iterator yields.\n\n* new helper function ``python.iter()`` in Lua that returns a Lua\n iterator for a Python object.\n\n* reestablished the ``python.as_function()`` helper function for Lua\n code as it can be needed in cases where Lua cannot determine how to\n run a Python function.\n\n\n0.16 (2010-09-03)\n-----------------\n\n* dropped ``python.as_function()`` helper function for Lua as all\n Python objects are callable from Lua now (potentially raising a\n ``TypeError`` at call time if they are not callable)\n\n* fix regression in 0.13 and later where ordinary Lua functions failed\n to print due to an accidentally used meta table\n\n* fix crash when calling ``str()`` on wrapped Lua objects without\n metatable\n\n\n0.15 (2010-09-02)\n-----------------\n\n* support for loading binary Lua modules on systems that support it\n\n\n0.14 (2010-08-31)\n-----------------\n\n* relicensed to the MIT license used by LuaJIT2 to simplify licensing\n considerations\n\n\n0.13.1 (2010-08-30)\n-------------------\n\n* fix Cython generated C file using Cython 0.13\n\n\n0.13 (2010-08-29)\n-----------------\n\n* fixed undefined behaviour on ``str(lua_object)`` when the object's\n ``__tostring()`` meta method fails\n\n* removed redundant \"error:\" prefix from ``LuaError`` messages\n\n* access to Python's ``python.builtins`` from Lua code\n\n* more generic wrapping rules for Python objects based on supported\n protocols (callable, getitem, getattr)\n\n* new helper functions ``as_attrgetter()`` and ``as_itemgetter()`` to\n specify the Python object protocol used by Lua indexing when\n wrapping Python objects in Python code\n\n* new helper functions ``python.as_attrgetter()``,\n ``python.as_itemgetter()`` and ``python.as_function()`` to specify\n the Python object protocol used by Lua indexing of Python objects in\n Lua code\n\n* item and attribute access for Python objects from Lua code\n\n\n0.12 (2010-08-16)\n-----------------\n\n* fix Lua stack leak during table iteration\n\n* fix lost Lua object reference after iteration\n\n\n0.11 (2010-08-07)\n-----------------\n\n* error reporting on Lua syntax errors failed to clean up the stack so\n that errors could leak into the next Lua run\n\n* Lua error messages were not properly decoded\n\n\n0.10 (2010-07-27)\n-----------------\n\n* much faster locking of the LuaRuntime, especially in the single\n threaded case (see\n http://code.activestate.com/recipes/577336-fast-re-entrant-optimistic-lock-implemented-in-cyt/)\n\n* fixed several error handling problems when executing Python code\n inside of Lua\n\n\n0.9 (2010-07-23)\n----------------\n\n* fixed Python special double-underscore method access on LuaObject\n instances\n\n* Lua coroutine support through dedicated wrapper classes, including\n Python iteration support. In Python space, Lua coroutines behave\n exactly like Python generators.\n\n\n0.8 (2010-07-21)\n----------------\n\n* support for returning multiple values from Lua evaluation\n\n* ``repr()`` support for Lua objects\n\n* ``LuaRuntime.table()`` method for creating Lua tables from Python\n space\n\n* encoding fix for ``str(LuaObject)``\n\n\n0.7 (2010-07-18)\n----------------\n\n* ``LuaRuntime.require()`` and ``LuaRuntime.globals()`` methods\n\n* renamed ``LuaRuntime.run()`` to ``LuaRuntime.execute()``\n\n* support for ``len()``, ``setattr()`` and subscripting of Lua objects\n\n* provide all built-in Lua libraries in ``LuaRuntime``, including\n support for library loading\n\n* fixed a thread locking issue\n\n* fix passing Lua objects back into the runtime from Python space\n\n\n0.6 (2010-07-18)\n----------------\n\n* Python iteration support for Lua objects (e.g. tables)\n\n* threading fixes\n\n* fix compile warnings\n\n\n0.5 (2010-07-14)\n----------------\n\n* explicit encoding options per LuaRuntime instance to decode/encode\n strings and Lua code\n\n\n0.4 (2010-07-14)\n----------------\n\n* attribute read access on Lua objects, e.g. to read Lua table values\n from Python\n\n* str() on Lua objects\n\n* include .hg repository in source downloads\n\n* added missing files to source distribution\n\n\n0.3 (2010-07-13)\n----------------\n\n* fix several threading issues\n\n* safely free the GIL when calling into Lua\n\n\n0.2 (2010-07-13)\n----------------\n\n* propagate Python exceptions through Lua calls\n\n\n0.1 (2010-07-12)\n----------------\n\n* first public release\n\n\nLicense\n=======\n\nLupa\n----\n\nCopyright (c) 2010-2017 Stefan Behnel. All rights reserved.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\nLua\n---\n\n(See https://www.lua.org/license.html)\n\nCopyright \u00a9 1994\u20132017 Lua.org, PUC-Rio.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n\n",
"bugtrack_url": null,
"license": "MIT style",
"summary": "Python wrapper around Lua and LuaJIT",
"version": "2.1",
"project_urls": {
"Homepage": "https://github.com/scoder/lupa"
},
"split_keywords": [],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "2c2b715be444013f307a1d04b1adb4c6e8be30c994928a4d1786b32a22adef5b",
"md5": "658735e791f47ff8a40bca9ddcb17533",
"sha256": "70cba7ca6b7e64071524d43f1af0921085f8585c80714605e4d968fb947cf25d"
},
"downloads": -1,
"filename": "lupa-2.1-cp27-cp27m-macosx_11_0_x86_64.whl",
"has_sig": false,
"md5_digest": "658735e791f47ff8a40bca9ddcb17533",
"packagetype": "bdist_wheel",
"python_version": "cp27",
"requires_python": null,
"size": 990609,
"upload_time": "2024-03-24T19:33:03",
"upload_time_iso_8601": "2024-03-24T19:33:03.446514Z",
"url": "https://files.pythonhosted.org/packages/2c/2b/715be444013f307a1d04b1adb4c6e8be30c994928a4d1786b32a22adef5b/lupa-2.1-cp27-cp27m-macosx_11_0_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "36cc25ae7c1e15fe7ce79551aecb35672bc19719ab43fd4f112f6b9e72eff3ae",
"md5": "549c171f674b4f63baf706ebb33fd8b4",
"sha256": "6b5a50b598064d4cf0f0b417fbe0136f0eb059c3a9c0b671ced299d6c4214267"
},
"downloads": -1,
"filename": "lupa-2.1-cp310-cp310-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "549c171f674b4f63baf706ebb33fd8b4",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 975448,
"upload_time": "2024-03-24T19:33:06",
"upload_time_iso_8601": "2024-03-24T19:33:06.963580Z",
"url": "https://files.pythonhosted.org/packages/36/cc/25ae7c1e15fe7ce79551aecb35672bc19719ab43fd4f112f6b9e72eff3ae/lupa-2.1-cp310-cp310-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "1fece53d993f85c92977375abb330bd645055df1fa7713a564050812e618bf71",
"md5": "c005b67e84d47f4837c4bee848341879",
"sha256": "b91157e7d431c146acf694bf6cb8657bd76aa66805dd79fa03aef13e14d9a2ff"
},
"downloads": -1,
"filename": "lupa-2.1-cp310-cp310-macosx_11_0_universal2.whl",
"has_sig": false,
"md5_digest": "c005b67e84d47f4837c4bee848341879",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 2003909,
"upload_time": "2024-03-24T19:33:09",
"upload_time_iso_8601": "2024-03-24T19:33:09.745013Z",
"url": "https://files.pythonhosted.org/packages/1f/ec/e53d993f85c92977375abb330bd645055df1fa7713a564050812e618bf71/lupa-2.1-cp310-cp310-macosx_11_0_universal2.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "ccba3c0f2527c5ee5052aa01b393549835adc1639e18a1b7d43f5a37d90c40ce",
"md5": "de874a83a57e9a3cf357012be319a9bf",
"sha256": "5d91f1ad69e4012c4afc0aa7287339d036b6b7c554ebfc583b06ec47751963a3"
},
"downloads": -1,
"filename": "lupa-2.1-cp310-cp310-macosx_11_0_x86_64.whl",
"has_sig": false,
"md5_digest": "de874a83a57e9a3cf357012be319a9bf",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 1047428,
"upload_time": "2024-03-24T19:33:12",
"upload_time_iso_8601": "2024-03-24T19:33:12.960011Z",
"url": "https://files.pythonhosted.org/packages/cc/ba/3c0f2527c5ee5052aa01b393549835adc1639e18a1b7d43f5a37d90c40ce/lupa-2.1-cp310-cp310-macosx_11_0_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "2084fa14ca5eb75aec3a646b12c92d1ece9114b7b8eb774faeed6f1e91493412",
"md5": "4fb03d8b1f529963f296340762780c39",
"sha256": "35350b8f70f0e9422c7c96be478cdb0afb09aac1724e2eccc4f3bf60881073b9"
},
"downloads": -1,
"filename": "lupa-2.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"has_sig": false,
"md5_digest": "4fb03d8b1f529963f296340762780c39",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 1152922,
"upload_time": "2024-03-24T19:33:15",
"upload_time_iso_8601": "2024-03-24T19:33:15.593217Z",
"url": "https://files.pythonhosted.org/packages/20/84/fa14ca5eb75aec3a646b12c92d1ece9114b7b8eb774faeed6f1e91493412/lupa-2.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "edbf9f1c3936b24b7f0b9aebc5ed053d5a138482de8c3a8820f01c4fbaae39e0",
"md5": "95caf47b2efa397b2b50514603f6ed3c",
"sha256": "09ade981e97c8267029c89fb374f92f327b55198eded6b386065963d93157a62"
},
"downloads": -1,
"filename": "lupa-2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"has_sig": false,
"md5_digest": "95caf47b2efa397b2b50514603f6ed3c",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 1046276,
"upload_time": "2024-03-24T19:33:18",
"upload_time_iso_8601": "2024-03-24T19:33:18.908361Z",
"url": "https://files.pythonhosted.org/packages/ed/bf/9f1c3936b24b7f0b9aebc5ed053d5a138482de8c3a8820f01c4fbaae39e0/lupa-2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "631310cf8effffce9066debd3b209df517c12176d1cdb46b52eb5b1a23636f57",
"md5": "02c6246961e727e753e02cccb45bb1ee",
"sha256": "35630eef63d8f363d768beec5c14e7ccaf4cfc2a979e0662fce998b26678dc2e"
},
"downloads": -1,
"filename": "lupa-2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "02c6246961e727e753e02cccb45bb1ee",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 2060622,
"upload_time": "2024-03-24T19:33:21",
"upload_time_iso_8601": "2024-03-24T19:33:21.649248Z",
"url": "https://files.pythonhosted.org/packages/63/13/10cf8effffce9066debd3b209df517c12176d1cdb46b52eb5b1a23636f57/lupa-2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "01c22265f5d4df73565af2116d233e79478ab1e648e6d34c9b973b4c1c0dd492",
"md5": "3060674b5c1e119a1ddb5490b48196cd",
"sha256": "fb683e0affa423614ea4cd518c6a4d8ac68f0d09928e4188f26be1668d3c0bc7"
},
"downloads": -1,
"filename": "lupa-2.1-cp310-cp310-musllinux_1_1_aarch64.whl",
"has_sig": false,
"md5_digest": "3060674b5c1e119a1ddb5490b48196cd",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 1063519,
"upload_time": "2024-03-24T19:33:24",
"upload_time_iso_8601": "2024-03-24T19:33:24.727336Z",
"url": "https://files.pythonhosted.org/packages/01/c2/2265f5d4df73565af2116d233e79478ab1e648e6d34c9b973b4c1c0dd492/lupa-2.1-cp310-cp310-musllinux_1_1_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "1d44f7b72381fc6f66e101c4f41636f15454633581223fcfe527939e6a50ca57",
"md5": "5665cb4e70d7e7dda96c1db7a9a5aff2",
"sha256": "4b136250e3abf6cd366db3516c0df8fc3bdf485dbb681e09cda6f58ea63a6db0"
},
"downloads": -1,
"filename": "lupa-2.1-cp310-cp310-musllinux_1_1_i686.whl",
"has_sig": false,
"md5_digest": "5665cb4e70d7e7dda96c1db7a9a5aff2",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 1163552,
"upload_time": "2024-03-24T19:33:27",
"upload_time_iso_8601": "2024-03-24T19:33:27.784732Z",
"url": "https://files.pythonhosted.org/packages/1d/44/f7b72381fc6f66e101c4f41636f15454633581223fcfe527939e6a50ca57/lupa-2.1-cp310-cp310-musllinux_1_1_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "e8e317b3784101a1d8f36b610299e730147e3ebfb7bc340621c144cd8a3c2c52",
"md5": "7d5f01770a945345cb57f3aca32e7243",
"sha256": "553b94b068a3fe22dc7c5724d1a312d3bc6daed40ad36138b0ad4b3667e34c09"
},
"downloads": -1,
"filename": "lupa-2.1-cp310-cp310-musllinux_1_1_x86_64.whl",
"has_sig": false,
"md5_digest": "7d5f01770a945345cb57f3aca32e7243",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 2106405,
"upload_time": "2024-03-24T19:33:30",
"upload_time_iso_8601": "2024-03-24T19:33:30.220904Z",
"url": "https://files.pythonhosted.org/packages/e8/e3/17b3784101a1d8f36b610299e730147e3ebfb7bc340621c144cd8a3c2c52/lupa-2.1-cp310-cp310-musllinux_1_1_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "0989b8343ec4d9edb5ff3fbba43d45eafdaf46ca90bd4f120a43959a646c7629",
"md5": "145008d9336d7276b1d07def1a9093a2",
"sha256": "db39dbb443ad89fe6c2059dd4a2bcb80bfbe6b9d2ed137c4c83b476e826b76ad"
},
"downloads": -1,
"filename": "lupa-2.1-cp310-cp310-win32.whl",
"has_sig": false,
"md5_digest": "145008d9336d7276b1d07def1a9093a2",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 808389,
"upload_time": "2024-03-24T19:33:33",
"upload_time_iso_8601": "2024-03-24T19:33:33.357671Z",
"url": "https://files.pythonhosted.org/packages/09/89/b8343ec4d9edb5ff3fbba43d45eafdaf46ca90bd4f120a43959a646c7629/lupa-2.1-cp310-cp310-win32.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "908da4be680e073791cf3e6f552cca2982ce0984f80f516b9612c05c01d5016d",
"md5": "e60d865bd90f8a9a3f8f369681611143",
"sha256": "354ab722b30711de8e30a11f9383bb68fd4acf68b87915f26960477906690455"
},
"downloads": -1,
"filename": "lupa-2.1-cp310-cp310-win_amd64.whl",
"has_sig": false,
"md5_digest": "e60d865bd90f8a9a3f8f369681611143",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 976379,
"upload_time": "2024-03-24T19:33:36",
"upload_time_iso_8601": "2024-03-24T19:33:36.395879Z",
"url": "https://files.pythonhosted.org/packages/90/8d/a4be680e073791cf3e6f552cca2982ce0984f80f516b9612c05c01d5016d/lupa-2.1-cp310-cp310-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "3e603484ee02c78a550cd914a221b2130a20330c256ea7652e7b8faa9b46ae3a",
"md5": "9728d9b717f596d34a2d5cbd97ed13f1",
"sha256": "98d260af271353d3eaea3a44ab610db25c7eb3a489d39cfdd20a6ccb482dba92"
},
"downloads": -1,
"filename": "lupa-2.1-cp311-cp311-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "9728d9b717f596d34a2d5cbd97ed13f1",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 980146,
"upload_time": "2024-03-24T19:33:39",
"upload_time_iso_8601": "2024-03-24T19:33:39.481576Z",
"url": "https://files.pythonhosted.org/packages/3e/60/3484ee02c78a550cd914a221b2130a20330c256ea7652e7b8faa9b46ae3a/lupa-2.1-cp311-cp311-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "f032cc373ceb95fa6e42dc89ec1020b594d0e348d49f86c17226696182f313d8",
"md5": "104ef3df9f449c6ace0a64b57dd31933",
"sha256": "e7876d07cdd1709c7890e0b51ef595600fb72dee40351d0327056300becce601"
},
"downloads": -1,
"filename": "lupa-2.1-cp311-cp311-macosx_11_0_universal2.whl",
"has_sig": false,
"md5_digest": "104ef3df9f449c6ace0a64b57dd31933",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 2014907,
"upload_time": "2024-03-24T19:33:42",
"upload_time_iso_8601": "2024-03-24T19:33:42.170493Z",
"url": "https://files.pythonhosted.org/packages/f0/32/cc373ceb95fa6e42dc89ec1020b594d0e348d49f86c17226696182f313d8/lupa-2.1-cp311-cp311-macosx_11_0_universal2.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "14f0fff5f5f7859d2808d626619af71e5bab3266f17e6b2e9b99c598b327a44b",
"md5": "d9f81828e74a467c0c4017c4aea0095f",
"sha256": "43a15a366dea073072cccf800fdbd9c63fb83b77c783674e1e0900013fddd833"
},
"downloads": -1,
"filename": "lupa-2.1-cp311-cp311-macosx_11_0_x86_64.whl",
"has_sig": false,
"md5_digest": "d9f81828e74a467c0c4017c4aea0095f",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 1054121,
"upload_time": "2024-03-24T19:33:44",
"upload_time_iso_8601": "2024-03-24T19:33:44.846617Z",
"url": "https://files.pythonhosted.org/packages/14/f0/fff5f5f7859d2808d626619af71e5bab3266f17e6b2e9b99c598b327a44b/lupa-2.1-cp311-cp311-macosx_11_0_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "24a9f7888420a402b46cec4924ccdf2a52adc03d2de634d4472b10356344a25b",
"md5": "cb3bc1351e78201e67cb770772c78715",
"sha256": "6b53faece345c5b711713337777cf2e8c148359df44ec819949022072372d1ac"
},
"downloads": -1,
"filename": "lupa-2.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"has_sig": false,
"md5_digest": "cb3bc1351e78201e67cb770772c78715",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 1139010,
"upload_time": "2024-03-24T19:33:47",
"upload_time_iso_8601": "2024-03-24T19:33:47.427154Z",
"url": "https://files.pythonhosted.org/packages/24/a9/f7888420a402b46cec4924ccdf2a52adc03d2de634d4472b10356344a25b/lupa-2.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "5060c928eb4ce9f7fbb7fd6a42d94acf73d904f05ab57357c2f7f3804f2d0173",
"md5": "3f2e50d6d4f29683c46f959a4a44fd5f",
"sha256": "5988d7a7d0c469eebbe30a59442980dd950369ea824bffef499eeb7920e63db5"
},
"downloads": -1,
"filename": "lupa-2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"has_sig": false,
"md5_digest": "3f2e50d6d4f29683c46f959a4a44fd5f",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 1042019,
"upload_time": "2024-03-24T19:33:50",
"upload_time_iso_8601": "2024-03-24T19:33:50.699804Z",
"url": "https://files.pythonhosted.org/packages/50/60/c928eb4ce9f7fbb7fd6a42d94acf73d904f05ab57357c2f7f3804f2d0173/lupa-2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "c1e63ab9132ed957720e4daaab68a65d6082caf2fcb5d0afb061ee7a08f8fd99",
"md5": "fbb45f890e121b3782566d98a27bd67b",
"sha256": "68ffa2545329144ec419587175620f67882c0d062d0dd749f6524d608a92d63c"
},
"downloads": -1,
"filename": "lupa-2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "fbb45f890e121b3782566d98a27bd67b",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 2047868,
"upload_time": "2024-03-24T19:33:53",
"upload_time_iso_8601": "2024-03-24T19:33:53.982543Z",
"url": "https://files.pythonhosted.org/packages/c1/e6/3ab9132ed957720e4daaab68a65d6082caf2fcb5d0afb061ee7a08f8fd99/lupa-2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "255f72832a6f3cd8fcb480f95f1d32c4a83ef35768ca9011a5e50bdaed44c805",
"md5": "ee1f6e7391f4b97ac52924c44b763b23",
"sha256": "27a23b70bd995688925e8c64fbc2119cc2577e266aa40b8c8ff5c3eee51b0a62"
},
"downloads": -1,
"filename": "lupa-2.1-cp311-cp311-musllinux_1_1_aarch64.whl",
"has_sig": false,
"md5_digest": "ee1f6e7391f4b97ac52924c44b763b23",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 1067837,
"upload_time": "2024-03-24T19:33:56",
"upload_time_iso_8601": "2024-03-24T19:33:56.569702Z",
"url": "https://files.pythonhosted.org/packages/25/5f/72832a6f3cd8fcb480f95f1d32c4a83ef35768ca9011a5e50bdaed44c805/lupa-2.1-cp311-cp311-musllinux_1_1_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "e405584efefea7ff9f377553afb1213c07810d84c6b2ba37d4116401738fadf1",
"md5": "16a10a5c2c9c94a534e54bb676c31047",
"sha256": "d29bafd459d925339771ef0cb5c83bd7f5f4b5743fc717d55428b77d41032145"
},
"downloads": -1,
"filename": "lupa-2.1-cp311-cp311-musllinux_1_1_i686.whl",
"has_sig": false,
"md5_digest": "16a10a5c2c9c94a534e54bb676c31047",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 1163894,
"upload_time": "2024-03-24T19:33:59",
"upload_time_iso_8601": "2024-03-24T19:33:59.207115Z",
"url": "https://files.pythonhosted.org/packages/e4/05/584efefea7ff9f377553afb1213c07810d84c6b2ba37d4116401738fadf1/lupa-2.1-cp311-cp311-musllinux_1_1_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "0027c7452157ad8a55bf6164f1b2453fa95f4427d1874de9a6c0928d475a2238",
"md5": "1bfed2c50131584e44bb5e8d69a1ee5b",
"sha256": "d0b046d05a60ce4026c3732e35e99e0c876e143b4dc22bf875ecd6fc87a90e48"
},
"downloads": -1,
"filename": "lupa-2.1-cp311-cp311-musllinux_1_1_x86_64.whl",
"has_sig": false,
"md5_digest": "1bfed2c50131584e44bb5e8d69a1ee5b",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 2114535,
"upload_time": "2024-03-24T19:34:04",
"upload_time_iso_8601": "2024-03-24T19:34:04.001608Z",
"url": "https://files.pythonhosted.org/packages/00/27/c7452157ad8a55bf6164f1b2453fa95f4427d1874de9a6c0928d475a2238/lupa-2.1-cp311-cp311-musllinux_1_1_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "961c545a3c657d76f426d868e4cc76549629729525e2545df9105bbee1db5dd2",
"md5": "6446e4fef4bf356e0c605229a6ef3e70",
"sha256": "35f44781de55a4ebf8270e1ae1d50975c43f6e04ef91efb5f60b4fdbc3141c98"
},
"downloads": -1,
"filename": "lupa-2.1-cp311-cp311-win32.whl",
"has_sig": false,
"md5_digest": "6446e4fef4bf356e0c605229a6ef3e70",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 808396,
"upload_time": "2024-03-24T19:34:06",
"upload_time_iso_8601": "2024-03-24T19:34:06.207191Z",
"url": "https://files.pythonhosted.org/packages/96/1c/545a3c657d76f426d868e4cc76549629729525e2545df9105bbee1db5dd2/lupa-2.1-cp311-cp311-win32.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "9f5777306afe02e835ed0132685d8173d3099cc5b209897d932789c72ea3e58f",
"md5": "e8bb14d486b551a0a36ba97787c28c4d",
"sha256": "151077023b2be939c09a6393142be6d70b92cac2fea38e21cfb976ea28c022dc"
},
"downloads": -1,
"filename": "lupa-2.1-cp311-cp311-win_amd64.whl",
"has_sig": false,
"md5_digest": "e8bb14d486b551a0a36ba97787c28c4d",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 987948,
"upload_time": "2024-03-24T19:34:08",
"upload_time_iso_8601": "2024-03-24T19:34:08.618743Z",
"url": "https://files.pythonhosted.org/packages/9f/57/77306afe02e835ed0132685d8173d3099cc5b209897d932789c72ea3e58f/lupa-2.1-cp311-cp311-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "eaf721a4c3665d8cc6a802018572a9126da5904fe3522177caea66d02aa43e4e",
"md5": "1af3b201da60e1aeb32e423a0853cb64",
"sha256": "f2dcac388cf6995e5c6b4b3cb3acfa8af70e2542c3ae50c294a02a8a06e1534f"
},
"downloads": -1,
"filename": "lupa-2.1-cp312-cp312-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "1af3b201da60e1aeb32e423a0853cb64",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": null,
"size": 989212,
"upload_time": "2024-03-24T19:34:11",
"upload_time_iso_8601": "2024-03-24T19:34:11.146432Z",
"url": "https://files.pythonhosted.org/packages/ea/f7/21a4c3665d8cc6a802018572a9126da5904fe3522177caea66d02aa43e4e/lupa-2.1-cp312-cp312-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "9813178c1817963399b7bf848753f534457432edc06f9f48b6446a961b6fdc0b",
"md5": "275b6324bc64400928f388814d50ab93",
"sha256": "738295b071749da7e25f81f25245fdafbf310cbf68e1a9a91e61658f6542fd0b"
},
"downloads": -1,
"filename": "lupa-2.1-cp312-cp312-macosx_11_0_universal2.whl",
"has_sig": false,
"md5_digest": "275b6324bc64400928f388814d50ab93",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": null,
"size": 2032719,
"upload_time": "2024-03-24T19:34:14",
"upload_time_iso_8601": "2024-03-24T19:34:14.178821Z",
"url": "https://files.pythonhosted.org/packages/98/13/178c1817963399b7bf848753f534457432edc06f9f48b6446a961b6fdc0b/lupa-2.1-cp312-cp312-macosx_11_0_universal2.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "262a7c1dd339f03aab22378d4a5b821de72ec653950b9fb3f585df5ed17059e0",
"md5": "385691b730098af4605782408b3c1043",
"sha256": "5a8ff2bb744d17c7ba4fd1158feada8a49c77b28105c077858b1d8ac90e0e8ff"
},
"downloads": -1,
"filename": "lupa-2.1-cp312-cp312-macosx_11_0_x86_64.whl",
"has_sig": false,
"md5_digest": "385691b730098af4605782408b3c1043",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": null,
"size": 1062454,
"upload_time": "2024-03-24T19:34:17",
"upload_time_iso_8601": "2024-03-24T19:34:17.508907Z",
"url": "https://files.pythonhosted.org/packages/26/2a/7c1dd339f03aab22378d4a5b821de72ec653950b9fb3f585df5ed17059e0/lupa-2.1-cp312-cp312-macosx_11_0_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "723cb904c484200de7809107f4cb58d43e1ff17b657c97e1fefd9b83a3fae1c2",
"md5": "fb323cfa705bf55034c298249db2f7c4",
"sha256": "809ce9a77eef51089c98360312ef59ece7839af331f9aea7afbf40842d7116f5"
},
"downloads": -1,
"filename": "lupa-2.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"has_sig": false,
"md5_digest": "fb323cfa705bf55034c298249db2f7c4",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": null,
"size": 1121189,
"upload_time": "2024-03-24T19:34:19",
"upload_time_iso_8601": "2024-03-24T19:34:19.769870Z",
"url": "https://files.pythonhosted.org/packages/72/3c/b904c484200de7809107f4cb58d43e1ff17b657c97e1fefd9b83a3fae1c2/lupa-2.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "92dd73eac38a49b84b933a9ac8ef5982bca67dde2ae450eb76db901b4175ef61",
"md5": "8aba3b098c629887633f9479ea7e3f36",
"sha256": "c2a96fa5fcc10eef350bf3cf685fd5c9c90cd5548e57369881b736bb5848dcf9"
},
"downloads": -1,
"filename": "lupa-2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"has_sig": false,
"md5_digest": "8aba3b098c629887633f9479ea7e3f36",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": null,
"size": 1015552,
"upload_time": "2024-03-24T19:34:22",
"upload_time_iso_8601": "2024-03-24T19:34:22.230026Z",
"url": "https://files.pythonhosted.org/packages/92/dd/73eac38a49b84b933a9ac8ef5982bca67dde2ae450eb76db901b4175ef61/lupa-2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "4fc3c7b9c176cb6c63e8c9c3b07e9a2d49b7b370f59dae7e605a4553fcdb4d20",
"md5": "a52aa6c15a0f8ebe7b9eada4aa145921",
"sha256": "5a69abf48ba14df28901d00156023799dd6d9d25489018f8dca0f784d5b48003"
},
"downloads": -1,
"filename": "lupa-2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "a52aa6c15a0f8ebe7b9eada4aa145921",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": null,
"size": 2002418,
"upload_time": "2024-03-24T19:34:24",
"upload_time_iso_8601": "2024-03-24T19:34:24.673147Z",
"url": "https://files.pythonhosted.org/packages/4f/c3/c7b9c176cb6c63e8c9c3b07e9a2d49b7b370f59dae7e605a4553fcdb4d20/lupa-2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "01da40726e77ffabd64f82cf60aa8ed426b5e7248fc215b88992d50fe1629a50",
"md5": "808e131c0534f9d9999039b1457229e2",
"sha256": "8b0636b1fc9f97d416005ddd3c59d5ce0ae98580534d830625c692d31053f486"
},
"downloads": -1,
"filename": "lupa-2.1-cp312-cp312-musllinux_1_1_aarch64.whl",
"has_sig": false,
"md5_digest": "808e131c0534f9d9999039b1457229e2",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": null,
"size": 1042874,
"upload_time": "2024-03-24T19:34:27",
"upload_time_iso_8601": "2024-03-24T19:34:27.318314Z",
"url": "https://files.pythonhosted.org/packages/01/da/40726e77ffabd64f82cf60aa8ed426b5e7248fc215b88992d50fe1629a50/lupa-2.1-cp312-cp312-musllinux_1_1_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "d330128de0c77da8563338b1ae3daa1dce5461962cf3937f5d5f806f4a9ba094",
"md5": "af969797776f5b4484ea20fea0e6782e",
"sha256": "caf3bed9165ff503b9a381ce13655e0487499094b2065e8d90f55d98b28623ba"
},
"downloads": -1,
"filename": "lupa-2.1-cp312-cp312-musllinux_1_1_i686.whl",
"has_sig": false,
"md5_digest": "af969797776f5b4484ea20fea0e6782e",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": null,
"size": 1145361,
"upload_time": "2024-03-24T19:34:30",
"upload_time_iso_8601": "2024-03-24T19:34:30.471332Z",
"url": "https://files.pythonhosted.org/packages/d3/30/128de0c77da8563338b1ae3daa1dce5461962cf3937f5d5f806f4a9ba094/lupa-2.1-cp312-cp312-musllinux_1_1_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "79a57dd72bcef751ff8b40d7529d63262a71baf48186e12c22e774d603c07a0d",
"md5": "c1ebed54fd12f57d94230310ea5266f9",
"sha256": "63d4991769497044531ac25390d6dcb960402425eb670022274a830c505bda07"
},
"downloads": -1,
"filename": "lupa-2.1-cp312-cp312-musllinux_1_1_x86_64.whl",
"has_sig": false,
"md5_digest": "c1ebed54fd12f57d94230310ea5266f9",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": null,
"size": 2075489,
"upload_time": "2024-03-24T19:34:33",
"upload_time_iso_8601": "2024-03-24T19:34:33.221777Z",
"url": "https://files.pythonhosted.org/packages/79/a5/7dd72bcef751ff8b40d7529d63262a71baf48186e12c22e774d603c07a0d/lupa-2.1-cp312-cp312-musllinux_1_1_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "7fc118517ac932259b5b4dcc79cc0915875d1b52ab3d0150fef4ee28ca665fd2",
"md5": "c11fec90db3bae0836a9f370bfbb68a1",
"sha256": "5cddbf849e6292da3cd9e0e2352392817db041cf368517ac0618c273188e4aaf"
},
"downloads": -1,
"filename": "lupa-2.1-cp312-cp312-win32.whl",
"has_sig": false,
"md5_digest": "c11fec90db3bae0836a9f370bfbb68a1",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": null,
"size": 817497,
"upload_time": "2024-03-24T19:34:35",
"upload_time_iso_8601": "2024-03-24T19:34:35.432861Z",
"url": "https://files.pythonhosted.org/packages/7f/c1/18517ac932259b5b4dcc79cc0915875d1b52ab3d0150fef4ee28ca665fd2/lupa-2.1-cp312-cp312-win32.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "8bba7e1cfbc050e85ac4d2c6d5bc7909a8708167881c68d66d602616b350bb6d",
"md5": "639ce40abd1a74f6e94553d8416b8147",
"sha256": "d3faf580c2b0c70f778b1a22a0afc4bc225076d50ae3f9e354237259d83af97b"
},
"downloads": -1,
"filename": "lupa-2.1-cp312-cp312-win_amd64.whl",
"has_sig": false,
"md5_digest": "639ce40abd1a74f6e94553d8416b8147",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": null,
"size": 1002408,
"upload_time": "2024-03-24T19:34:37",
"upload_time_iso_8601": "2024-03-24T19:34:37.995075Z",
"url": "https://files.pythonhosted.org/packages/8b/ba/7e1cfbc050e85ac4d2c6d5bc7909a8708167881c68d66d602616b350bb6d/lupa-2.1-cp312-cp312-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "aeea45b944b5bd93db3ea82f28bd52729d83b97497eae3d1f6051c69dd5d98ff",
"md5": "868aa82b3d58e3de1062ff2442d3877b",
"sha256": "b518e7e38cb47c22243fbddd12ef85f24852f60f1a7152fd92a8290128cc1643"
},
"downloads": -1,
"filename": "lupa-2.1-cp36-cp36m-macosx_11_0_x86_64.whl",
"has_sig": false,
"md5_digest": "868aa82b3d58e3de1062ff2442d3877b",
"packagetype": "bdist_wheel",
"python_version": "cp36",
"requires_python": null,
"size": 998018,
"upload_time": "2024-03-24T19:34:41",
"upload_time_iso_8601": "2024-03-24T19:34:41.225007Z",
"url": "https://files.pythonhosted.org/packages/ae/ea/45b944b5bd93db3ea82f28bd52729d83b97497eae3d1f6051c69dd5d98ff/lupa-2.1-cp36-cp36m-macosx_11_0_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "70f8d279eb39271f33e946cc91d0f335f7be9f7339f7e38c9f9bffccf9bb6d2d",
"md5": "45bc929cf334d55bf48e7341c26c7375",
"sha256": "607955e6d8faf304ef9c0186f11e479b7e175c894d1eb312ea1234b997d1e5a4"
},
"downloads": -1,
"filename": "lupa-2.1-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"has_sig": false,
"md5_digest": "45bc929cf334d55bf48e7341c26c7375",
"packagetype": "bdist_wheel",
"python_version": "cp36",
"requires_python": null,
"size": 1119879,
"upload_time": "2024-03-24T19:34:44",
"upload_time_iso_8601": "2024-03-24T19:34:44.338593Z",
"url": "https://files.pythonhosted.org/packages/70/f8/d279eb39271f33e946cc91d0f335f7be9f7339f7e38c9f9bffccf9bb6d2d/lupa-2.1-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "2487af81b531645f4ea4a9e6b88789e5a698be9ecc5646e0f9c842a0eb49faf1",
"md5": "e4755a9921d3fa00adfc27d3cb0fb82f",
"sha256": "d25089fe7d6160ff98613e9e28844aad431453abd7fad820117ab901c36c1fae"
},
"downloads": -1,
"filename": "lupa-2.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"has_sig": false,
"md5_digest": "e4755a9921d3fa00adfc27d3cb0fb82f",
"packagetype": "bdist_wheel",
"python_version": "cp36",
"requires_python": null,
"size": 1013911,
"upload_time": "2024-03-24T19:34:46",
"upload_time_iso_8601": "2024-03-24T19:34:46.785620Z",
"url": "https://files.pythonhosted.org/packages/24/87/af81b531645f4ea4a9e6b88789e5a698be9ecc5646e0f9c842a0eb49faf1/lupa-2.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "c6aac5428db2db0685ce6076fe53f6805d37d0013b9cb3eb06a91ab1878cb44b",
"md5": "486dd3cc2786dbb74d95d664c452aeb9",
"sha256": "59dcc5a65af2e8b35594466b1ca4005e03c4ee5dd90d88113334c4cef45ee035"
},
"downloads": -1,
"filename": "lupa-2.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "486dd3cc2786dbb74d95d664c452aeb9",
"packagetype": "bdist_wheel",
"python_version": "cp36",
"requires_python": null,
"size": 2001313,
"upload_time": "2024-03-24T19:34:49",
"upload_time_iso_8601": "2024-03-24T19:34:49.260155Z",
"url": "https://files.pythonhosted.org/packages/c6/aa/c5428db2db0685ce6076fe53f6805d37d0013b9cb3eb06a91ab1878cb44b/lupa-2.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "576c0504f6d6d86752516dae191900d6ab6252005b1de274273224e067b42f2b",
"md5": "17528bc08575a9153adb9fdda7041737",
"sha256": "b0503575acd52a828017b10b5358f39bdb3a55918e10ac5ee96533db374f7d94"
},
"downloads": -1,
"filename": "lupa-2.1-cp36-cp36m-musllinux_1_1_aarch64.whl",
"has_sig": false,
"md5_digest": "17528bc08575a9153adb9fdda7041737",
"packagetype": "bdist_wheel",
"python_version": "cp36",
"requires_python": null,
"size": 1041497,
"upload_time": "2024-03-24T19:34:52",
"upload_time_iso_8601": "2024-03-24T19:34:52.807997Z",
"url": "https://files.pythonhosted.org/packages/57/6c/0504f6d6d86752516dae191900d6ab6252005b1de274273224e067b42f2b/lupa-2.1-cp36-cp36m-musllinux_1_1_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "c287e5c7e7053372a12d681ec4644c6179159f35fe70cc9aec7d5c122e56dd81",
"md5": "3781150bea68a804e894e14ddd53991f",
"sha256": "1e2ad3329e89fbc20a8c32eb64bb6416207c12e60b30ce002e0e4a425c7eb0ea"
},
"downloads": -1,
"filename": "lupa-2.1-cp36-cp36m-musllinux_1_1_i686.whl",
"has_sig": false,
"md5_digest": "3781150bea68a804e894e14ddd53991f",
"packagetype": "bdist_wheel",
"python_version": "cp36",
"requires_python": null,
"size": 1134220,
"upload_time": "2024-03-24T19:34:55",
"upload_time_iso_8601": "2024-03-24T19:34:55.073111Z",
"url": "https://files.pythonhosted.org/packages/c2/87/e5c7e7053372a12d681ec4644c6179159f35fe70cc9aec7d5c122e56dd81/lupa-2.1-cp36-cp36m-musllinux_1_1_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "be5d4758e1917f7df3337a0442e836b6ad4dedc1d49d94ef2634b7d5ad51783f",
"md5": "fad9aea3e1869dab44ea92fd2c017ed5",
"sha256": "0cc42e41f82ed6812a930a2c3599d1964583a482adbed4599f9a94a6e2aff7c8"
},
"downloads": -1,
"filename": "lupa-2.1-cp36-cp36m-musllinux_1_1_x86_64.whl",
"has_sig": false,
"md5_digest": "fad9aea3e1869dab44ea92fd2c017ed5",
"packagetype": "bdist_wheel",
"python_version": "cp36",
"requires_python": null,
"size": 2058480,
"upload_time": "2024-03-24T19:34:57",
"upload_time_iso_8601": "2024-03-24T19:34:57.686847Z",
"url": "https://files.pythonhosted.org/packages/be/5d/4758e1917f7df3337a0442e836b6ad4dedc1d49d94ef2634b7d5ad51783f/lupa-2.1-cp36-cp36m-musllinux_1_1_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "6ab645f9fe5ed3809412411eaad77a2801be34df5b8814875ac7b02bae8d26bb",
"md5": "77953b5594f630928cfc73d8cba4fd7b",
"sha256": "12f4591da2c7ff5b84a69a5363c0f5ce646fcff8519b49200d17e5fdb987a6cd"
},
"downloads": -1,
"filename": "lupa-2.1-cp36-cp36m-win32.whl",
"has_sig": false,
"md5_digest": "77953b5594f630928cfc73d8cba4fd7b",
"packagetype": "bdist_wheel",
"python_version": "cp36",
"requires_python": null,
"size": 897388,
"upload_time": "2024-03-24T19:35:00",
"upload_time_iso_8601": "2024-03-24T19:35:00.076790Z",
"url": "https://files.pythonhosted.org/packages/6a/b6/45f9fe5ed3809412411eaad77a2801be34df5b8814875ac7b02bae8d26bb/lupa-2.1-cp36-cp36m-win32.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "ec1de6891df46883bf77805fcc4de086d187128492c7dae6872c3f33012b7923",
"md5": "1749232581902b6d93340f97b271b6d5",
"sha256": "ce67c0de8d0aaa707d45dec3a4da360e7432fb396d832dda608bc1ab3534abe2"
},
"downloads": -1,
"filename": "lupa-2.1-cp36-cp36m-win_amd64.whl",
"has_sig": false,
"md5_digest": "1749232581902b6d93340f97b271b6d5",
"packagetype": "bdist_wheel",
"python_version": "cp36",
"requires_python": null,
"size": 1120428,
"upload_time": "2024-03-24T19:35:02",
"upload_time_iso_8601": "2024-03-24T19:35:02.947510Z",
"url": "https://files.pythonhosted.org/packages/ec/1d/e6891df46883bf77805fcc4de086d187128492c7dae6872c3f33012b7923/lupa-2.1-cp36-cp36m-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "cf7f9dd5042762126c947551bbb20d2e0eb15c1d401750f37267cf81f5c0f4aa",
"md5": "b56d46a338b227cb7f391029bbb3ae3c",
"sha256": "d19171e45156935eb75879d39f9dc69d21140fdcba40c441ba5e866eacdd3804"
},
"downloads": -1,
"filename": "lupa-2.1-cp37-cp37m-macosx_11_0_x86_64.whl",
"has_sig": false,
"md5_digest": "b56d46a338b227cb7f391029bbb3ae3c",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": null,
"size": 1026610,
"upload_time": "2024-03-24T19:35:06",
"upload_time_iso_8601": "2024-03-24T19:35:06.314336Z",
"url": "https://files.pythonhosted.org/packages/cf/7f/9dd5042762126c947551bbb20d2e0eb15c1d401750f37267cf81f5c0f4aa/lupa-2.1-cp37-cp37m-macosx_11_0_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "6a4ec68e9623e324f88059027edcbf5492731e22a33d24186509120f8c168949",
"md5": "2fe9fdb2faa0581e5bdbf0ce10247f28",
"sha256": "7edf57a0f5f9da3fe8997bb7a11007c6e01b757bd72beee99ecdb7491877c5a9"
},
"downloads": -1,
"filename": "lupa-2.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"has_sig": false,
"md5_digest": "2fe9fdb2faa0581e5bdbf0ce10247f28",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": null,
"size": 1131701,
"upload_time": "2024-03-24T19:35:08",
"upload_time_iso_8601": "2024-03-24T19:35:08.938395Z",
"url": "https://files.pythonhosted.org/packages/6a/4e/c68e9623e324f88059027edcbf5492731e22a33d24186509120f8c168949/lupa-2.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "5e2b2e9675731b4914df90f8e6614b3cae0190a121d2aca1dac9f7171c15115d",
"md5": "dba53b4a960fcdee52366893ea52d58d",
"sha256": "aada43e1a378eef21418b34fe33194d42f74ca98e9541cfacd4e49470050937a"
},
"downloads": -1,
"filename": "lupa-2.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"has_sig": false,
"md5_digest": "dba53b4a960fcdee52366893ea52d58d",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": null,
"size": 1029832,
"upload_time": "2024-03-24T19:35:12",
"upload_time_iso_8601": "2024-03-24T19:35:12.013203Z",
"url": "https://files.pythonhosted.org/packages/5e/2b/2e9675731b4914df90f8e6614b3cae0190a121d2aca1dac9f7171c15115d/lupa-2.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "9d55f24faabcff30772574bfcf6e140590578f692f636820c5deac4f0c4ed6bf",
"md5": "419a8109339b4ef41554e906ab6b840a",
"sha256": "d76c75c032c674897338df93dc660d02316f5217c8075f2e9ebfcfdbc798a6e0"
},
"downloads": -1,
"filename": "lupa-2.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "419a8109339b4ef41554e906ab6b840a",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": null,
"size": 2019681,
"upload_time": "2024-03-24T19:35:15",
"upload_time_iso_8601": "2024-03-24T19:35:15.427524Z",
"url": "https://files.pythonhosted.org/packages/9d/55/f24faabcff30772574bfcf6e140590578f692f636820c5deac4f0c4ed6bf/lupa-2.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "2cd854484eaa1a63d2cf5c2a8a2751d680c2d4fb3bccbfad209aba605f2f7df0",
"md5": "ba42dc1de5438069986ffed8315f7986",
"sha256": "8b64ea3ea1d3988a10227507f122b8b1ae65d7491a7f21e622fade6af313c29c"
},
"downloads": -1,
"filename": "lupa-2.1-cp37-cp37m-musllinux_1_1_aarch64.whl",
"has_sig": false,
"md5_digest": "ba42dc1de5438069986ffed8315f7986",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": null,
"size": 1053389,
"upload_time": "2024-03-24T19:35:18",
"upload_time_iso_8601": "2024-03-24T19:35:18.301933Z",
"url": "https://files.pythonhosted.org/packages/2c/d8/54484eaa1a63d2cf5c2a8a2751d680c2d4fb3bccbfad209aba605f2f7df0/lupa-2.1-cp37-cp37m-musllinux_1_1_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "7b0486b9e17662ed680209b7f37e74e7773492272a791b311def042f41fa4401",
"md5": "bfa3fa9b89aeee2c1dc9ef78bdc6a892",
"sha256": "4ea6a0137d02dcc87db56099d79ec859d0b3dece7557cae02c1bb4e332be440b"
},
"downloads": -1,
"filename": "lupa-2.1-cp37-cp37m-musllinux_1_1_i686.whl",
"has_sig": false,
"md5_digest": "bfa3fa9b89aeee2c1dc9ef78bdc6a892",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": null,
"size": 1144710,
"upload_time": "2024-03-24T19:35:20",
"upload_time_iso_8601": "2024-03-24T19:35:20.557009Z",
"url": "https://files.pythonhosted.org/packages/7b/04/86b9e17662ed680209b7f37e74e7773492272a791b311def042f41fa4401/lupa-2.1-cp37-cp37m-musllinux_1_1_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "2b2b56d066727f3c2ecc91d840dbb4a4909875fc64ff2d1fde0f7d4597f9232e",
"md5": "8b99f9bcb3d75fa8949496fb61c4a21f",
"sha256": "45f4194d1d72d01cc1034ab2ed3e1d34c5e9b58652dab5222f54e6051456ecd1"
},
"downloads": -1,
"filename": "lupa-2.1-cp37-cp37m-musllinux_1_1_x86_64.whl",
"has_sig": false,
"md5_digest": "8b99f9bcb3d75fa8949496fb61c4a21f",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": null,
"size": 2077794,
"upload_time": "2024-03-24T19:35:23",
"upload_time_iso_8601": "2024-03-24T19:35:23.947044Z",
"url": "https://files.pythonhosted.org/packages/2b/2b/56d066727f3c2ecc91d840dbb4a4909875fc64ff2d1fde0f7d4597f9232e/lupa-2.1-cp37-cp37m-musllinux_1_1_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "c5e00a21e482284b0622bb7df37308476aa09f2df1a4cdc57935dad3107f3b59",
"md5": "040fd8fc13acb78e4c16c55979a86b53",
"sha256": "0912e46a398831d4299f6fb4bb75ba5a8de9cd73a3461cbc4a37123a0c660d51"
},
"downloads": -1,
"filename": "lupa-2.1-cp37-cp37m-win32.whl",
"has_sig": false,
"md5_digest": "040fd8fc13acb78e4c16c55979a86b53",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": null,
"size": 802588,
"upload_time": "2024-03-24T19:35:26",
"upload_time_iso_8601": "2024-03-24T19:35:26.313594Z",
"url": "https://files.pythonhosted.org/packages/c5/e0/0a21e482284b0622bb7df37308476aa09f2df1a4cdc57935dad3107f3b59/lupa-2.1-cp37-cp37m-win32.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "ed3aa6d472fb514e1170313029f7ab645098e52c299c50605e5a4698fc022cc6",
"md5": "524fb415cdc13d432342c592a1604a44",
"sha256": "23c28564dd5812ba31e07e0bb0e7334ca33b46ded233935982074db7088832fc"
},
"downloads": -1,
"filename": "lupa-2.1-cp37-cp37m-win_amd64.whl",
"has_sig": false,
"md5_digest": "524fb415cdc13d432342c592a1604a44",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": null,
"size": 971018,
"upload_time": "2024-03-24T19:35:28",
"upload_time_iso_8601": "2024-03-24T19:35:28.903595Z",
"url": "https://files.pythonhosted.org/packages/ed/3a/a6d472fb514e1170313029f7ab645098e52c299c50605e5a4698fc022cc6/lupa-2.1-cp37-cp37m-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "f99d13dd0148966fb61cbd7f800d4ce559e86f4c7b468efdaeeea76056940434",
"md5": "f5c46a68f4f92fa4a3a4fedc6b07eb87",
"sha256": "48bc5e40218f4e20e6734d9f945c634d5c8e2514b98ed1cf5650961f65c71501"
},
"downloads": -1,
"filename": "lupa-2.1-cp38-cp38-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "f5c46a68f4f92fa4a3a4fedc6b07eb87",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 972179,
"upload_time": "2024-03-24T19:35:31",
"upload_time_iso_8601": "2024-03-24T19:35:31.964049Z",
"url": "https://files.pythonhosted.org/packages/f9/9d/13dd0148966fb61cbd7f800d4ce559e86f4c7b468efdaeeea76056940434/lupa-2.1-cp38-cp38-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "81fff3dbccb797ff4cc224047484847d8fab602a2a75e7e8979ed32bf05d2168",
"md5": "a53b21ff50ceb520d75d4b7028e9a3ff",
"sha256": "2d82bea5aa6eb98208f3a07f7feea253998b7fa7e76ef2e4ab5510e0156a0ce3"
},
"downloads": -1,
"filename": "lupa-2.1-cp38-cp38-macosx_11_0_x86_64.whl",
"has_sig": false,
"md5_digest": "a53b21ff50ceb520d75d4b7028e9a3ff",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 1042807,
"upload_time": "2024-03-24T19:35:34",
"upload_time_iso_8601": "2024-03-24T19:35:34.780874Z",
"url": "https://files.pythonhosted.org/packages/81/ff/f3dbccb797ff4cc224047484847d8fab602a2a75e7e8979ed32bf05d2168/lupa-2.1-cp38-cp38-macosx_11_0_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "c50cc6df69dc7dafb61fe93a0ea97b8979bf9d032d5d1e77b65d4488401b5b7d",
"md5": "f46518df1c092fc06181250fc027062f",
"sha256": "c33ee203ab6310ba0f43069a6b7acf89313da9acedc4c9a1df21b250cd9dc69f"
},
"downloads": -1,
"filename": "lupa-2.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"has_sig": false,
"md5_digest": "f46518df1c092fc06181250fc027062f",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 1155670,
"upload_time": "2024-03-24T19:35:37",
"upload_time_iso_8601": "2024-03-24T19:35:37.179688Z",
"url": "https://files.pythonhosted.org/packages/c5/0c/c6df69dc7dafb61fe93a0ea97b8979bf9d032d5d1e77b65d4488401b5b7d/lupa-2.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "09b06b5f765a03c1cf650f39e96655b0eb7801f3b7f69f3803e4bb7ef3712e98",
"md5": "e21a20ee9fef302b257f02d13e991d8e",
"sha256": "b43404eee3f543696d55583283b0df919ded8a152f5a1226efdc2a0694189a27"
},
"downloads": -1,
"filename": "lupa-2.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"has_sig": false,
"md5_digest": "e21a20ee9fef302b257f02d13e991d8e",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 1050325,
"upload_time": "2024-03-24T19:35:39",
"upload_time_iso_8601": "2024-03-24T19:35:39.490203Z",
"url": "https://files.pythonhosted.org/packages/09/b0/6b5f765a03c1cf650f39e96655b0eb7801f3b7f69f3803e4bb7ef3712e98/lupa-2.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "277778684f7fa42d9737a6ee9c8a203ef326c4f67eb86de82fc0c274b76ec2b8",
"md5": "07fb14d5e72f21a53d29f2c2744c72b5",
"sha256": "689099fbe46258f6e4722a3ec595fd785375fadc853020543f75bdf3e23ffbf4"
},
"downloads": -1,
"filename": "lupa-2.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "07fb14d5e72f21a53d29f2c2744c72b5",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 2066690,
"upload_time": "2024-03-24T19:35:43",
"upload_time_iso_8601": "2024-03-24T19:35:43.109317Z",
"url": "https://files.pythonhosted.org/packages/27/77/78684f7fa42d9737a6ee9c8a203ef326c4f67eb86de82fc0c274b76ec2b8/lupa-2.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "e902c38a4d1a4e008aad0d001ed5613bf3e138d78c67dcc133ee92dad7541126",
"md5": "59a8c83f5e3239a018c65f35f0063103",
"sha256": "7f34eef2370377f55df184c033864f4d371bef50688867929b1cf85e796e8c22"
},
"downloads": -1,
"filename": "lupa-2.1-cp38-cp38-musllinux_1_1_aarch64.whl",
"has_sig": false,
"md5_digest": "59a8c83f5e3239a018c65f35f0063103",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 1072549,
"upload_time": "2024-03-24T19:35:45",
"upload_time_iso_8601": "2024-03-24T19:35:45.433908Z",
"url": "https://files.pythonhosted.org/packages/e9/02/c38a4d1a4e008aad0d001ed5613bf3e138d78c67dcc133ee92dad7541126/lupa-2.1-cp38-cp38-musllinux_1_1_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "92947845b174aa7fe6a322ddd1da3ed59717902e0640b98ffc89ebba858a8219",
"md5": "0ac124b65e7087490fc17890b98ac35a",
"sha256": "7230cc64bcc661ed92c7d94ea3f394c3e79a24588e988203214847d15f3ef7a7"
},
"downloads": -1,
"filename": "lupa-2.1-cp38-cp38-musllinux_1_1_i686.whl",
"has_sig": false,
"md5_digest": "0ac124b65e7087490fc17890b98ac35a",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 1169553,
"upload_time": "2024-03-24T19:35:48",
"upload_time_iso_8601": "2024-03-24T19:35:48.716047Z",
"url": "https://files.pythonhosted.org/packages/92/94/7845b174aa7fe6a322ddd1da3ed59717902e0640b98ffc89ebba858a8219/lupa-2.1-cp38-cp38-musllinux_1_1_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "c4db8130436d22b246dd48e0ee0775960f5c3017b54d24683f55331bdce495c1",
"md5": "0713f72a01c33d95ddab53789206bced",
"sha256": "ba6a0ec6df9e75f18c8bf33cad1e983b55ad8f6965c99ae2d9f6e7f73bac6cdb"
},
"downloads": -1,
"filename": "lupa-2.1-cp38-cp38-musllinux_1_1_x86_64.whl",
"has_sig": false,
"md5_digest": "0713f72a01c33d95ddab53789206bced",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 2126521,
"upload_time": "2024-03-24T19:35:51",
"upload_time_iso_8601": "2024-03-24T19:35:51.698043Z",
"url": "https://files.pythonhosted.org/packages/c4/db/8130436d22b246dd48e0ee0775960f5c3017b54d24683f55331bdce495c1/lupa-2.1-cp38-cp38-musllinux_1_1_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "adf0d209eb44e2980b64d5149e9c65ef088198f6a6735a2e2cba1bc9419367d7",
"md5": "89d644bdec8eac5f54d09397cfbe1adf",
"sha256": "4bebb8792220b91d7d97a8f0fe1b07002e3947471f80c7b872f8a994ee4c0926"
},
"downloads": -1,
"filename": "lupa-2.1-cp38-cp38-win32.whl",
"has_sig": false,
"md5_digest": "89d644bdec8eac5f54d09397cfbe1adf",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 809472,
"upload_time": "2024-03-24T19:35:54",
"upload_time_iso_8601": "2024-03-24T19:35:54.572516Z",
"url": "https://files.pythonhosted.org/packages/ad/f0/d209eb44e2980b64d5149e9c65ef088198f6a6735a2e2cba1bc9419367d7/lupa-2.1-cp38-cp38-win32.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "f95d515a044c4e49c393ea9f0d47e01c16070fc2e4a73313f766d92ea3a1b8f2",
"md5": "8073f9586697be54172227150eaf5403",
"sha256": "60eb8ffde52d989ddd2a403c3d7c0268447b663e75bd52e6e10fecdcf673c90e"
},
"downloads": -1,
"filename": "lupa-2.1-cp38-cp38-win_amd64.whl",
"has_sig": false,
"md5_digest": "8073f9586697be54172227150eaf5403",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 978332,
"upload_time": "2024-03-24T19:35:57",
"upload_time_iso_8601": "2024-03-24T19:35:57.621881Z",
"url": "https://files.pythonhosted.org/packages/f9/5d/515a044c4e49c393ea9f0d47e01c16070fc2e4a73313f766d92ea3a1b8f2/lupa-2.1-cp38-cp38-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "22f172718bcd32ab2507159296cb877b571339eb6d61a3b22755b42ed5e50cf4",
"md5": "9db8ab4a3544a4d931a5a0f30ae0d0ad",
"sha256": "f0cbd41c23bf18d3ae6bc65c0ec88f711a1e012bca56a19e6cd04265da1bdf5a"
},
"downloads": -1,
"filename": "lupa-2.1-cp39-cp39-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "9db8ab4a3544a4d931a5a0f30ae0d0ad",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 976273,
"upload_time": "2024-03-24T19:36:00",
"upload_time_iso_8601": "2024-03-24T19:36:00.421153Z",
"url": "https://files.pythonhosted.org/packages/22/f1/72718bcd32ab2507159296cb877b571339eb6d61a3b22755b42ed5e50cf4/lupa-2.1-cp39-cp39-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "e37a8a3a6b8f133c7e6d0bd84a54dac24184c158cb6da0076fdb7442435d534c",
"md5": "6d4f69b5f71c396be2fa9a9a18cc3ba5",
"sha256": "29f50f1d2a53071c6eb3b89289753ba6306417cb4bf55c00897251e2e813fe7e"
},
"downloads": -1,
"filename": "lupa-2.1-cp39-cp39-macosx_11_0_universal2.whl",
"has_sig": false,
"md5_digest": "6d4f69b5f71c396be2fa9a9a18cc3ba5",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 2005776,
"upload_time": "2024-03-24T19:36:03",
"upload_time_iso_8601": "2024-03-24T19:36:03.987461Z",
"url": "https://files.pythonhosted.org/packages/e3/7a/8a3a6b8f133c7e6d0bd84a54dac24184c158cb6da0076fdb7442435d534c/lupa-2.1-cp39-cp39-macosx_11_0_universal2.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "7ac5600b55f2f2ac756c24ea37684040585ad0f3ff307cc2e3ae813ba3fa24e7",
"md5": "96601f3d90e131139298b3b7764112b5",
"sha256": "ca36d2337064a980e2f565ea28618744d85e75ea1b5b47be18d543810c413102"
},
"downloads": -1,
"filename": "lupa-2.1-cp39-cp39-macosx_11_0_x86_64.whl",
"has_sig": false,
"md5_digest": "96601f3d90e131139298b3b7764112b5",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 1048451,
"upload_time": "2024-03-24T19:36:06",
"upload_time_iso_8601": "2024-03-24T19:36:06.639716Z",
"url": "https://files.pythonhosted.org/packages/7a/c5/600b55f2f2ac756c24ea37684040585ad0f3ff307cc2e3ae813ba3fa24e7/lupa-2.1-cp39-cp39-macosx_11_0_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "c780c0102a8fdc50c55953eda510781ed45d6663afab1c8360e557d7025868dc",
"md5": "0145f6de2d9c21798ed7a1f23d160ad5",
"sha256": "c8ec99552cd5f2b1caba63d082ea3cbdf0872d8634d04233b9000ac0c1aebfcf"
},
"downloads": -1,
"filename": "lupa-2.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"has_sig": false,
"md5_digest": "0145f6de2d9c21798ed7a1f23d160ad5",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 1152852,
"upload_time": "2024-03-24T19:36:09",
"upload_time_iso_8601": "2024-03-24T19:36:09.887348Z",
"url": "https://files.pythonhosted.org/packages/c7/80/c0102a8fdc50c55953eda510781ed45d6663afab1c8360e557d7025868dc/lupa-2.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "cfc5d477bede8cbcf03d75ecc2b0438968d8eb5b829f481f7fc1be7f08b97369",
"md5": "c2bcc1dc2e7e1aeda882021b739cb0b0",
"sha256": "7a58963c9cd335d092d11c7242a6433806e70410fa66aafefe0cefd9bba30f42"
},
"downloads": -1,
"filename": "lupa-2.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"has_sig": false,
"md5_digest": "c2bcc1dc2e7e1aeda882021b739cb0b0",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 1049071,
"upload_time": "2024-03-24T19:36:12",
"upload_time_iso_8601": "2024-03-24T19:36:12.447458Z",
"url": "https://files.pythonhosted.org/packages/cf/c5/d477bede8cbcf03d75ecc2b0438968d8eb5b829f481f7fc1be7f08b97369/lupa-2.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "d939b366ea4feed64b0ddd979bbe45cfc73efbfcbe8c439f3800261c6cf99c73",
"md5": "c284c84c1358ffaeb2e76736f74fd882",
"sha256": "7d4f876d42236d47ef247076501a2c74849b52070637d8cca905d06a710794ce"
},
"downloads": -1,
"filename": "lupa-2.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "c284c84c1358ffaeb2e76736f74fd882",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 2062759,
"upload_time": "2024-03-24T19:36:15",
"upload_time_iso_8601": "2024-03-24T19:36:15.885213Z",
"url": "https://files.pythonhosted.org/packages/d9/39/b366ea4feed64b0ddd979bbe45cfc73efbfcbe8c439f3800261c6cf99c73/lupa-2.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "aa784d4f1f83e50fb622facbc35ac1bd403f609d720465df42bdc723158a5865",
"md5": "636786254cac75c4a38e43e82d2734da",
"sha256": "bd24a43ebef9deb5bea8f9f63ce0e0e1831fa0ffd663404bc06460ed53cbf0e4"
},
"downloads": -1,
"filename": "lupa-2.1-cp39-cp39-musllinux_1_1_aarch64.whl",
"has_sig": false,
"md5_digest": "636786254cac75c4a38e43e82d2734da",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 1064538,
"upload_time": "2024-03-24T19:36:19",
"upload_time_iso_8601": "2024-03-24T19:36:19.300999Z",
"url": "https://files.pythonhosted.org/packages/aa/78/4d4f1f83e50fb622facbc35ac1bd403f609d720465df42bdc723158a5865/lupa-2.1-cp39-cp39-musllinux_1_1_aarch64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "e3a1f8bcdb64d606579227aed1312b78550277aa176c606e283a9df34e5d93ef",
"md5": "548ac464da028e4f1a7497aad1a9a1dc",
"sha256": "05616bc5c467d7ec0b26de99d1586bdd4e034cd3b9068be9306e128d0d005d34"
},
"downloads": -1,
"filename": "lupa-2.1-cp39-cp39-musllinux_1_1_i686.whl",
"has_sig": false,
"md5_digest": "548ac464da028e4f1a7497aad1a9a1dc",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 1162950,
"upload_time": "2024-03-24T19:36:21",
"upload_time_iso_8601": "2024-03-24T19:36:21.886905Z",
"url": "https://files.pythonhosted.org/packages/e3/a1/f8bcdb64d606579227aed1312b78550277aa176c606e283a9df34e5d93ef/lupa-2.1-cp39-cp39-musllinux_1_1_i686.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "f53c1850eb7c012020123d37445d8492ce63417bc0b6233220382d14ccab7393",
"md5": "298c88005ced38bf32266edca8babc8a",
"sha256": "aab836f17b9625b8511f5f9c76fd4598c16e9d7a27d314cd12fc1de987f3bf58"
},
"downloads": -1,
"filename": "lupa-2.1-cp39-cp39-musllinux_1_1_x86_64.whl",
"has_sig": false,
"md5_digest": "298c88005ced38bf32266edca8babc8a",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 2106735,
"upload_time": "2024-03-24T19:36:25",
"upload_time_iso_8601": "2024-03-24T19:36:25.423530Z",
"url": "https://files.pythonhosted.org/packages/f5/3c/1850eb7c012020123d37445d8492ce63417bc0b6233220382d14ccab7393/lupa-2.1-cp39-cp39-musllinux_1_1_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "cba13869fdd2d120b1da93914dc88f8176ae7f6664695decceff3e75e1babf7c",
"md5": "d517f1575e8294ea95770d7ebf1670ec",
"sha256": "c1c0a0270e41a2dd982824cd2fd4960f4c09c97514c6ed58056834054637de39"
},
"downloads": -1,
"filename": "lupa-2.1-cp39-cp39-win32.whl",
"has_sig": false,
"md5_digest": "d517f1575e8294ea95770d7ebf1670ec",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 809082,
"upload_time": "2024-03-24T19:36:27",
"upload_time_iso_8601": "2024-03-24T19:36:27.602958Z",
"url": "https://files.pythonhosted.org/packages/cb/a1/3869fdd2d120b1da93914dc88f8176ae7f6664695decceff3e75e1babf7c/lupa-2.1-cp39-cp39-win32.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "0117a8213ecbad77bd455846cc7031ee1b4eded1712918f826a0c9e514fd361b",
"md5": "a05289feb7b9d4378d3ef29971c79ca1",
"sha256": "23852fb56d14853cc0a62c0f93decdb4d2b476ce7e512c4488fe8a186e6d060e"
},
"downloads": -1,
"filename": "lupa-2.1-cp39-cp39-win_amd64.whl",
"has_sig": false,
"md5_digest": "a05289feb7b9d4378d3ef29971c79ca1",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 977347,
"upload_time": "2024-03-24T19:36:30",
"upload_time_iso_8601": "2024-03-24T19:36:30.908948Z",
"url": "https://files.pythonhosted.org/packages/01/17/a8213ecbad77bd455846cc7031ee1b4eded1712918f826a0c9e514fd361b/lupa-2.1-cp39-cp39-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "f38022523e4d9a8f5d4324e0ef0734c0731a5f9ca12445e3e4c908df2c93ace3",
"md5": "927622d88adef15b75e7ef4aaf1d0265",
"sha256": "c82c96f0982eadfa5552a95df93ae563cc46a7948ba15542e03999ed82d3b6f8"
},
"downloads": -1,
"filename": "lupa-2.1-pp310-pypy310_pp73-macosx_11_0_x86_64.whl",
"has_sig": false,
"md5_digest": "927622d88adef15b75e7ef4aaf1d0265",
"packagetype": "bdist_wheel",
"python_version": "pp310",
"requires_python": null,
"size": 875489,
"upload_time": "2024-03-24T19:36:33",
"upload_time_iso_8601": "2024-03-24T19:36:33.430470Z",
"url": "https://files.pythonhosted.org/packages/f3/80/22523e4d9a8f5d4324e0ef0734c0731a5f9ca12445e3e4c908df2c93ace3/lupa-2.1-pp310-pypy310_pp73-macosx_11_0_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "d86ef78b88202fb74b661e071646ee95fb5c913b5a7a6674d7ee0bf119ca557b",
"md5": "f392d0aff0800680f1040e1495aef374",
"sha256": "9899df13e8518a807392febc9922372f904f72fc7b07c3b849e651bb2c51cdcc"
},
"downloads": -1,
"filename": "lupa-2.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "f392d0aff0800680f1040e1495aef374",
"packagetype": "bdist_wheel",
"python_version": "pp310",
"requires_python": null,
"size": 1957830,
"upload_time": "2024-03-24T19:36:36",
"upload_time_iso_8601": "2024-03-24T19:36:36.964383Z",
"url": "https://files.pythonhosted.org/packages/d8/6e/f78b88202fb74b661e071646ee95fb5c913b5a7a6674d7ee0bf119ca557b/lupa-2.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "d7dda5f8526938081ec9d7a8fe0f785ff289ecd6c2c813400124a19a0f0f7590",
"md5": "aa1603b93a0ffc73878aa0f7ad0e5ad9",
"sha256": "3c8956ea9a3cf930cdda50e985232dea813662ff7afd4e9595cacd8509d55aff"
},
"downloads": -1,
"filename": "lupa-2.1-pp310-pypy310_pp73-win_amd64.whl",
"has_sig": false,
"md5_digest": "aa1603b93a0ffc73878aa0f7ad0e5ad9",
"packagetype": "bdist_wheel",
"python_version": "pp310",
"requires_python": null,
"size": 942515,
"upload_time": "2024-03-24T19:36:39",
"upload_time_iso_8601": "2024-03-24T19:36:39.772042Z",
"url": "https://files.pythonhosted.org/packages/d7/dd/a5f8526938081ec9d7a8fe0f785ff289ecd6c2c813400124a19a0f0f7590/lupa-2.1-pp310-pypy310_pp73-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "0eb80bb9939d15bb35fe960d8b4740ae5e0f0a338ffea82b6f427df2afc0ff2c",
"md5": "8f8728de63c3424f435e745a0ad2f9cf",
"sha256": "5579bcf9e99ff85c7bba3eb98642059a9580e2d4aa038a19fef814512c4392c2"
},
"downloads": -1,
"filename": "lupa-2.1-pp37-pypy37_pp73-macosx_11_0_x86_64.whl",
"has_sig": false,
"md5_digest": "8f8728de63c3424f435e745a0ad2f9cf",
"packagetype": "bdist_wheel",
"python_version": "pp37",
"requires_python": null,
"size": 874416,
"upload_time": "2024-03-24T19:36:42",
"upload_time_iso_8601": "2024-03-24T19:36:42.318152Z",
"url": "https://files.pythonhosted.org/packages/0e/b8/0bb9939d15bb35fe960d8b4740ae5e0f0a338ffea82b6f427df2afc0ff2c/lupa-2.1-pp37-pypy37_pp73-macosx_11_0_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "f2980c086ef4b1edd94a4d2909dfb20cae236a8510c9f956deb2ade857dc7acf",
"md5": "6a5af252d5fafe0fa850633e01bcaf5e",
"sha256": "5dfd149622d688d2aefd50f74dea6ced1663e5ddedda0fb040bfc0fa0ddb15c7"
},
"downloads": -1,
"filename": "lupa-2.1-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "6a5af252d5fafe0fa850633e01bcaf5e",
"packagetype": "bdist_wheel",
"python_version": "pp37",
"requires_python": null,
"size": 1977546,
"upload_time": "2024-03-24T19:36:45",
"upload_time_iso_8601": "2024-03-24T19:36:45.268020Z",
"url": "https://files.pythonhosted.org/packages/f2/98/0c086ef4b1edd94a4d2909dfb20cae236a8510c9f956deb2ade857dc7acf/lupa-2.1-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "1aaba8a1017469ce66b76542e6c26386b62e5ff023c44152e66b2efd6908755a",
"md5": "f63734bbfb699fb9ceae010db08a6d8c",
"sha256": "e93adbabe49d2a548cdeb5c9862aacfc21d55899de795cf5de88a56f3e045115"
},
"downloads": -1,
"filename": "lupa-2.1-pp37-pypy37_pp73-win_amd64.whl",
"has_sig": false,
"md5_digest": "f63734bbfb699fb9ceae010db08a6d8c",
"packagetype": "bdist_wheel",
"python_version": "pp37",
"requires_python": null,
"size": 941540,
"upload_time": "2024-03-24T19:36:48",
"upload_time_iso_8601": "2024-03-24T19:36:48.469196Z",
"url": "https://files.pythonhosted.org/packages/1a/ab/a8a1017469ce66b76542e6c26386b62e5ff023c44152e66b2efd6908755a/lupa-2.1-pp37-pypy37_pp73-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "5797a0817235441cc35495d49f63d4c1506f2c3e120bb23e65586c423be1939f",
"md5": "b6acc87966b51bc8f0bfde341e2a754d",
"sha256": "bdf4e0d935fd1c7c7f1e4e97ae63b646eddf23dac2e06178f5238b10c3c1d2d8"
},
"downloads": -1,
"filename": "lupa-2.1-pp38-pypy38_pp73-macosx_11_0_x86_64.whl",
"has_sig": false,
"md5_digest": "b6acc87966b51bc8f0bfde341e2a754d",
"packagetype": "bdist_wheel",
"python_version": "pp38",
"requires_python": null,
"size": 874570,
"upload_time": "2024-03-24T19:36:51",
"upload_time_iso_8601": "2024-03-24T19:36:51.121016Z",
"url": "https://files.pythonhosted.org/packages/57/97/a0817235441cc35495d49f63d4c1506f2c3e120bb23e65586c423be1939f/lupa-2.1-pp38-pypy38_pp73-macosx_11_0_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "7c2a79896cebe42992fe993ca66384dbba28bedc3833d194573ffba5a456d474",
"md5": "9717a2557540aa4a378053ac63a5a0ff",
"sha256": "604609f8c636c16795426233691e35ab1877fd2b7833331aec62d5dac57ffb63"
},
"downloads": -1,
"filename": "lupa-2.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "9717a2557540aa4a378053ac63a5a0ff",
"packagetype": "bdist_wheel",
"python_version": "pp38",
"requires_python": null,
"size": 1968779,
"upload_time": "2024-03-24T19:36:53",
"upload_time_iso_8601": "2024-03-24T19:36:53.832288Z",
"url": "https://files.pythonhosted.org/packages/7c/2a/79896cebe42992fe993ca66384dbba28bedc3833d194573ffba5a456d474/lupa-2.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "df94682643a5b6aeba960e363b13d1f72c50719aa9547d0c5adc030a50694385",
"md5": "9964630adff3bd5c27753b6c33d9a986",
"sha256": "db60e884ba66182eddf62081f262f4080d2f34dd9fcac4ed941ccf0199f7ad28"
},
"downloads": -1,
"filename": "lupa-2.1-pp38-pypy38_pp73-win_amd64.whl",
"has_sig": false,
"md5_digest": "9964630adff3bd5c27753b6c33d9a986",
"packagetype": "bdist_wheel",
"python_version": "pp38",
"requires_python": null,
"size": 941802,
"upload_time": "2024-03-24T19:36:56",
"upload_time_iso_8601": "2024-03-24T19:36:56.952845Z",
"url": "https://files.pythonhosted.org/packages/df/94/682643a5b6aeba960e363b13d1f72c50719aa9547d0c5adc030a50694385/lupa-2.1-pp38-pypy38_pp73-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "a894dca59d812e875ca865adf5aaf7471b237d27537d329bf35de33cf4998911",
"md5": "039d865b4593d5233ba08925654c7627",
"sha256": "7713b5fd295e0934cf6c7778944bf750c7a78d69b7efb3fd68ba7ca1e12ddbd2"
},
"downloads": -1,
"filename": "lupa-2.1-pp39-pypy39_pp73-macosx_11_0_x86_64.whl",
"has_sig": false,
"md5_digest": "039d865b4593d5233ba08925654c7627",
"packagetype": "bdist_wheel",
"python_version": "pp39",
"requires_python": null,
"size": 874718,
"upload_time": "2024-03-24T19:36:59",
"upload_time_iso_8601": "2024-03-24T19:36:59.334746Z",
"url": "https://files.pythonhosted.org/packages/a8/94/dca59d812e875ca865adf5aaf7471b237d27537d329bf35de33cf4998911/lupa-2.1-pp39-pypy39_pp73-macosx_11_0_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "69833148ccb2d26e5f4d15e53b54c340a8db43fb657746e614376deb1649f1b2",
"md5": "47741feb6a4f86baae830e758ce86f31",
"sha256": "fdfd08101ddbbd178977f05bff94b9dbed677b5f218028412a98361c65a830d5"
},
"downloads": -1,
"filename": "lupa-2.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "47741feb6a4f86baae830e758ce86f31",
"packagetype": "bdist_wheel",
"python_version": "pp39",
"requires_python": null,
"size": 1955679,
"upload_time": "2024-03-24T19:37:02",
"upload_time_iso_8601": "2024-03-24T19:37:02.294988Z",
"url": "https://files.pythonhosted.org/packages/69/83/3148ccb2d26e5f4d15e53b54c340a8db43fb657746e614376deb1649f1b2/lupa-2.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "8aeacc21b4bdc54f746f5592d3a0abbd07155ddf57311cf979eb6b5f5f9545dc",
"md5": "f7029adac826d3705936385bdfa468ff",
"sha256": "05fa474ae5617a77bdb9e09c42d45f3b4b869cd3c412914eaf7913a0a38cf03d"
},
"downloads": -1,
"filename": "lupa-2.1-pp39-pypy39_pp73-win_amd64.whl",
"has_sig": false,
"md5_digest": "f7029adac826d3705936385bdfa468ff",
"packagetype": "bdist_wheel",
"python_version": "pp39",
"requires_python": null,
"size": 942122,
"upload_time": "2024-03-24T19:37:04",
"upload_time_iso_8601": "2024-03-24T19:37:04.851852Z",
"url": "https://files.pythonhosted.org/packages/8a/ea/cc21b4bdc54f746f5592d3a0abbd07155ddf57311cf979eb6b5f5f9545dc/lupa-2.1-pp39-pypy39_pp73-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "fe781483589b3e7114e0e63cde35a42781a73e1b976702009766e9b0e38667eb",
"md5": "7d9aaa12cbe10632bed26b71c6d69a11",
"sha256": "760030712d5273396f5e963dd8731aefb5ac65d92eff8bf8fd4124c1630fe950"
},
"downloads": -1,
"filename": "lupa-2.1.tar.gz",
"has_sig": false,
"md5_digest": "7d9aaa12cbe10632bed26b71c6d69a11",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 7111959,
"upload_time": "2024-03-24T19:37:09",
"upload_time_iso_8601": "2024-03-24T19:37:09.551467Z",
"url": "https://files.pythonhosted.org/packages/fe/78/1483589b3e7114e0e63cde35a42781a73e1b976702009766e9b0e38667eb/lupa-2.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-03-24 19:37:09",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "scoder",
"github_project": "lupa",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"appveyor": true,
"requirements": [],
"tox": true,
"lcname": "lupa"
}
