numbox 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

numbox/__init__.py

@@ -1 +1 @@
-__version__ = '0.2.6'
+__version__ = '0.2.8'

numbox/core/proxy/proxy.py

@@ -7,20 +7,13 @@ from numba.extending import intrinsic  # noqa: F401
 from types import FunctionType as PyFunctionType
 from typing import List, Optional, Tuple
 
+from numbox.utils.standard import make_params_strings
+
 
 def make_proxy_name(name):
     return f'__{name}'
 
 
-def make_params_strings(func):
-    func_params = inspect.signature(func).parameters
-    func_params_str = ', '.join(
-        [k if v.default == inspect._empty else f'{k}={v.default}' for k, v in func_params.items()]
-    )
-    func_names_params_str = ', '.join(func_params.keys())
-    return func_params_str, func_names_params_str
-
-
 def proxy(sig, jit_options: Optional[dict] = None):
     """ Create a proxy for the decorated function `func` with the given signature(s) `sig`.
 

numbox/core/work/builder.py

@@ -1,5 +1,5 @@
 from collections import namedtuple
-from hashlib import md5
+from hashlib import sha256
 from inspect import getfile, getmodule, getsource
 from io import StringIO
 from itertools import chain
@@ -102,7 +102,7 @@ def _derived_line(
     sources_ = sources_ + ", " if "," not in sources_ else sources_
     ty_ = get_ty(derived_)
     derive_func = derived_.derive
-    derive_hashes.append(md5(getsource(derive_func).encode("utf-8")).hexdigest())
+    derive_hashes.append(sha256(getsource(derive_func).encode("utf-8")).hexdigest())
     derive_ = _derived_cres(ty_, derived_.sources, derive_func, jit_options)
     derive_name = f"{name_}_derive"
     init_name = f"{name_}_init"
@@ -115,7 +115,7 @@ def _derived_line(
 
 def code_block_hash(code_txt: str):
     """ Re-compile and re-save cache when source code has changed. """
-    return md5(code_txt.encode("utf-8")).hexdigest()
+    return sha256(code_txt.encode("utf-8")).hexdigest()
 
 
 def _infer_end_and_derived_nodes(spec: SpecTy, all_inputs_: Dict[str, Type], all_derived_: Dict[str, Type]):

numbox/core/work/work.py

@@ -166,6 +166,9 @@ def _call_derive(typingctx: Context, derive_ty: FunctionType, sources_ty: Tuple)
     return sig, codegen
 
 
+_source_getter_registry = {}
+
+
 def _make_source_getter(source_ind):
     return f"""
 @intrinsic
@@ -182,8 +185,6 @@ def _get_source_{source_ind}(typingctx: Context, sources_ty: Tuple):
 
 def _make_calculate_code(num_sources):
     code_txt = StringIO()
-    for source_ind_ in range(num_sources):
-        code_txt.write(_make_source_getter(source_ind_))
     code_txt.write("""
 def _calculate_(work_):
     if work_.derived:
@@ -194,7 +195,8 @@ def _calculate_(work_):
         for source_ind_ in range(num_sources):
             code_txt.write(f"""
     source_{source_ind_} = _get_source_{source_ind_}(sources)
-    source_{source_ind_}.calculate()""")
+    if not source_{source_ind_}.derived:
+        source_{source_ind_}.calculate()""")
     code_txt.write("""
     v = _call_derive(work_.derive, work_.sources)
     work_.derived = True
@@ -206,6 +208,15 @@ def _calculate_(work_):
 _calculate_registry = {}
 
 
+def ensure_presence_of_source_getters_in_ns(num_sources_, ns_):
+    for source_i in range(num_sources_):
+        _source_getter = _source_getter_registry.get(source_i, None)
+        source_getter_code_txt = _make_source_getter(source_i)
+        source_getter_code = compile(source_getter_code_txt, getfile(_file_anchor), mode="exec")
+        exec(source_getter_code, ns_)
+        _source_getter_registry[source_i] = True
+
+
 @overload_method(WorkTypeClass, "calculate", strict=False, jit_options=default_jit_options)
 def ol_calculate(self_ty):
     derive_ty = self_ty.field_dict["derive"]
@@ -217,13 +228,15 @@ def ol_calculate(self_ty):
     sources_ty = self_ty.field_dict["sources"]
     num_sources = sources_ty.count
     _calculate = _calculate_registry.get(num_sources, None)
-    if _calculate is None:
-        code_txt = _make_calculate_code(num_sources)
-        ns = getmodule(_file_anchor).__dict__
-        code = compile(code_txt, getfile(_file_anchor), mode="exec")
-        exec(code, ns)
-        _calculate = ns["_calculate_"]
-        _calculate_registry[num_sources] = _calculate
+    if _calculate is not None:
+        return _calculate
+    ns = getmodule(_file_anchor).__dict__
+    ensure_presence_of_source_getters_in_ns(num_sources, ns)
+    code_txt = _make_calculate_code(num_sources)
+    code = compile(code_txt, getfile(_file_anchor), mode="exec")
+    exec(code, ns)
+    _calculate = ns["_calculate_"]
+    _calculate_registry[num_sources] = _calculate
     return _calculate
 
 
@@ -246,8 +259,6 @@ def _cast_to_work_data(typingctx, work_ty, data_as_erased_ty: ErasedType):
 
 def _make_loader_code(num_sources):
     code_txt = StringIO()
-    for source_ind_ in range(num_sources):
-        code_txt.write(_make_source_getter(source_ind_))
     code_txt.write("""
 def _loader_(work_, data_):
     reset = False
@@ -282,20 +293,20 @@ def ol_load(work_ty, data_ty: DictType):
     sources_ty = work_ty.field_dict["sources"]
     num_sources = sources_ty.count
     _loader = _loader_registry.get(num_sources, None)
-    if _loader is None:
-        code_txt = _make_loader_code(num_sources)
-        ns = getmodule(_file_anchor).__dict__
-        code = compile(code_txt, getfile(_file_anchor), mode="exec")
-        exec(code, ns)
-        _loader = ns["_loader_"]
-        _loader_registry[num_sources] = _loader
+    if _loader is not None:
+        return _loader
+    ns = getmodule(_file_anchor).__dict__
+    ensure_presence_of_source_getters_in_ns(num_sources, ns)
+    code_txt = _make_loader_code(num_sources)
+    code = compile(code_txt, getfile(_file_anchor), mode="exec")
+    exec(code, ns)
+    _loader = ns["_loader_"]
+    _loader_registry[num_sources] = _loader
     return _loader
 
 
 def _make_combine_code(num_sources):
     code_txt = StringIO()
-    for source_ind_ in range(num_sources):
-        code_txt.write(_make_source_getter(source_ind_))
     code_txt.write("""
 def _combine_(work_, data_, harvested_=None):
     if harvested_ is None:
@@ -331,13 +342,15 @@ def ol_combine(work_ty, data_ty: DictType, harvested_ty=NoneType):
     sources_ty = work_ty.field_dict["sources"]
     num_sources = sources_ty.count
     _combine = _combine_registry.get(num_sources, None)
-    if _combine is None:
-        code_txt = _make_combine_code(num_sources)
-        ns = {**getmodule(_file_anchor).__dict__, **{"boolean": boolean, "Dict": Dict}}
-        code = compile(code_txt, getfile(_file_anchor), mode="exec")
-        exec(code, ns)
-        _combine = ns["_combine_"]
-        _combine_registry[num_sources] = _combine
+    if _combine is not None:
+        return _combine
+    ns = {**getmodule(_file_anchor).__dict__, **{"boolean": boolean, "Dict": Dict}}
+    ensure_presence_of_source_getters_in_ns(num_sources, ns)
+    code_txt = _make_combine_code(num_sources)
+    code = compile(code_txt, getfile(_file_anchor), mode="exec")
+    exec(code, ns)
+    _combine = ns["_combine_"]
+    _combine_registry[num_sources] = _combine
     return _combine
 
 
@@ -364,8 +377,6 @@ def ol_get_inputs_names(self_ty):
 
 def _make_inputs_vector_code(num_sources):
     code_txt = StringIO()
-    for source_ind_ in range(num_sources):
-        code_txt.write(_make_source_getter(source_ind_))
     code_txt.write("""
 def _inputs_vector_(work_):
     node = work_.node
@@ -399,13 +410,15 @@ def ol_make_inputs_vector(self_ty):
             return inputs_vector
         return _
     _inputs_vector = _inputs_vector_registry.get(num_sources, None)
-    if _inputs_vector is None:
-        code_txt = _make_inputs_vector_code(num_sources)
-        ns = {**getmodule(_file_anchor).__dict__, **{"new": new}}
-        code = compile(code_txt, getfile(_file_anchor), mode="exec")
-        exec(code, ns)
-        _inputs_vector = ns["_inputs_vector_"]
-        _inputs_vector_registry[num_sources] = _inputs_vector
+    if _inputs_vector is not None:
+        return _inputs_vector
+    ns = {**getmodule(_file_anchor).__dict__, **{"new": new}}
+    ensure_presence_of_source_getters_in_ns(num_sources, ns)
+    code_txt = _make_inputs_vector_code(num_sources)
+    code = compile(code_txt, getfile(_file_anchor), mode="exec")
+    exec(code, ns)
+    _inputs_vector = ns["_inputs_vector_"]
+    _inputs_vector_registry[num_sources] = _inputs_vector
     return _inputs_vector
 
 

numbox/utils/highlevel.py

@@ -1,4 +1,7 @@
 import hashlib
+import re
+from inspect import getfile, getmodule, getsource
+from io import StringIO
 from numba import njit
 from numba.core.itanium_mangler import mangle_type_or_value
 from numba.core.types import Type
@@ -6,6 +9,17 @@ from numba.core.types.functions import Dispatcher
 from numba.core.types.function_type import CompileResultWAP
 from numba.core.typing.templates import Signature
 from numba.experimental.function_type import FunctionType
+from numba.experimental.structref import define_boxing, new, StructRefProxy
+from numba.extending import overload, overload_method
+from textwrap import dedent, indent
+from typing import Callable, Dict, Iterable, Optional
+
+from numbox.core.configurations import default_jit_options
+from numbox.utils.standard import make_params_strings
+
+
+def _file_anchor():
+    raise NotImplementedError
 
 
 def cres(sig, **kwargs):
@@ -32,7 +46,164 @@ def determine_field_index(struct_ty, field_name):
 
 def hash_type(ty: Type):
     mangled_ty = mangle_type_or_value(ty)
-    return hashlib.sha256(mangled_ty.encode('utf-8')).hexdigest()
+    return hashlib.sha256(mangled_ty.encode("utf-8")).hexdigest()
+
+
+def make_structref_code_txt(
+    struct_name: str,
+    struct_fields: Iterable[str] | Dict[str, Type],
+    struct_type_class: type | Type,
+    struct_methods: Optional[Dict[str, Callable]] = None,
+    jit_options: Optional[dict] = None
+):
+    if isinstance(struct_fields, dict):
+        struct_fields, fields_types = list(struct_fields.keys()), list(struct_fields.values())
+    else:
+        assert isinstance(struct_fields, (list, tuple)), struct_fields
+        fields_types = None
+    struct_fields_str = ", ".join([field for field in struct_fields])
+    make_name = f"make_{struct_name.lower()}"
+    new_returns = f"{make_name}({struct_fields_str})"
+    repr_str = f"f'{struct_name}(" + ", ".join([f"{field}={{self.{field}}}" for field in struct_fields]) + ")'"
+    code_txt = StringIO()
+    code_txt.write(f"""
+class {struct_name}(StructRefProxy):
+    def __new__(cls, {struct_fields_str}):
+        return {new_returns}
+
+    def __repr__(self):
+        return {repr_str}
+""")
+    for field in struct_fields:
+        code_txt.write(f"""
+    @property
+    @njit(**jit_options)
+    def {field}(self):
+        return self.{field}
+""")
+    methods_code_txt = StringIO()
+    if struct_methods is not None:
+        assert isinstance(struct_methods, dict), f"""
+    Expected dictionary of methods names to callable, got {struct_methods}"""
+        for method_name, method in struct_methods.items():
+            params_str, names_params_str = make_params_strings(method)
+            names_params_lst = names_params_str.split(", ")
+            self_name = names_params_lst[0]
+            names_params_str_wo_self = ", ".join(names_params_lst[1:])
+            method_source = dedent(getsource(method))
+            method_hash = hashlib.sha256(method_source.encode("utf-8")).hexdigest()
+            code_txt.write(f"""
+    def {method_name}({params_str}):
+        return {self_name}.{method_name}_{method_hash}({names_params_str_wo_self})
+    
+    @njit(**jit_options)
+    def {method_name}_{method_hash}({params_str}):
+        return {self_name}.{method_name}({names_params_str_wo_self})
+""")
+            method_header = re.findall(r"^\s*def\s+([a-zA-Z_]\w*)\s*\(([^)]*)\)\s*:[^\n]*", method_source, re.MULTILINE)
+            assert len(method_header) == 1, method_header
+            method_name, params_str_ = method_header[0]
+            assert params_str == params_str_, (params_str, params_str_)
+            method_source = re.sub(r"\bdef\s+([a-zA-Z_]\w*)\b", f"def _", method_source)
+            methods_code_txt.write(f"""
+@overload_method({struct_type_class.__name__}, "{method_name}", jit_options=jit_options)
+def ol_{method_name}({params_str}):
+{indent(method_source, "    ")}
+    return _
+""")
+    code_txt.write(f"""
+define_boxing({struct_type_class.__name__}, {struct_name})
+""")
+    struct_type_name = f"{struct_name}Type"
+    struct_fields_ty_str = ", ".join([f"{field}_ty" for field in struct_fields])
+    struct_type_code_block = ""
+    if fields_types is None:
+        struct_type_code_block = f"""fields_types = [{struct_fields_ty_str}]
+    fields_and_their_types = list(zip(fields, fields_types))    
+    {struct_name}Type = {struct_type_class.__name__}(fields_and_their_types)        
+"""
+    else:
+        code_txt.write(f"""
+fields_and_their_types = list(zip(fields, fields_types))    
+{struct_name}Type = {struct_type_class.__name__}(fields_and_their_types)
+""")
+    ctor_code_block = "\n".join([f"        struct_.{field} = {field}" for field in struct_fields])
+    code_txt.write(f"""
+@overload({struct_name}, strict=False, jit_options=jit_options)
+def ol_{struct_name.lower()}({struct_fields_ty_str}):
+    {struct_type_code_block}
+    def ctor({struct_fields_str}):
+        struct_ = new({struct_type_name})
+{ctor_code_block}
+        return struct_
+    return ctor
+""")
+    if fields_types is not None:
+        code_txt.write(f"""
+{make_name}_sig = {struct_name}Type(*fields_types)
+""")
+    else:
+        code_txt.write(f"""
+{make_name}_sig = None
+""")
+    code_txt.write(f"""
+@njit({make_name}_sig, **jit_options)
+def {make_name}({struct_fields_str}):
+    return {struct_name}({struct_fields_str})
+""")
+    code_txt = code_txt.getvalue() + methods_code_txt.getvalue()
+    return code_txt, fields_types
+
+
+def make_structref(
+    struct_name: str,
+    struct_fields: Iterable[str] | Dict[str, Type],
+    struct_type_class: type | Type,
+    *,
+    struct_methods: Optional[Dict[str, Callable]] = None,
+    jit_options: Optional[dict] = None
+):
+    """
+    Makes structure type with `struct_name` and `struct_fields` from the StructRef type class.
+
+    A unique `struct_type_class` for each structref needs to be provided.
+    If caching of code that will be using the created struct type is desired,
+    these type class(es) need/s to be defined in a python module that is *not* executed.
+    (Same requirement is also to observed even when the full definition of StructRef
+    is entirely hard-coded rather than created dynamically.)
+
+    In particular, that's why `struct_type_class` cannot be incorporated into
+    the dynamic compile / exec routine here.
+
+    Dictionary of methods to be bound to the created structref can be provided as well.
+    Struct methods will get inlined into the caller if numba deems it to be optimal
+    (even if `jit_options` says otherwise), therefore changing the methods code
+    without poking the jitted caller can result in a stale cache - when the latter is
+    cached. This is not an exclusive limitation of a dynamic structref creation via
+    this function and is equally true when the structref definition is coded explicitly.
+    """
+    code_txt, fields_types = make_structref_code_txt(
+        struct_name, struct_fields, struct_type_class, struct_methods, jit_options
+    )
+    if jit_options is None:
+        jit_options = default_jit_options
+    ns = {
+        **getmodule(_file_anchor).__dict__,
+        **{
+            "fields": struct_fields,
+            "fields_types": fields_types,
+            "define_boxing": define_boxing,
+            "jit_options": jit_options,
+            "new": new,
+            "njit": njit,
+            "overload_method": overload_method,
+            "StructRefProxy": StructRefProxy,
+            struct_type_class.__name__: struct_type_class
+        }
+    }
+    code = compile(code_txt, getfile(_file_anchor), mode="exec")
+    exec(code, ns)
+    return ns[struct_name]
 
 
 def prune_type(ty):

numbox/utils/standard.py

@@ -0,0 +1,17 @@
+import inspect
+
+
+def make_params_strings(func):
+    func_params = inspect.signature(func).parameters
+    func_params_str = ', '.join(
+        [k if v.default == inspect._empty else f'{k}={v.default}' for k, v in func_params.items()]
+    )
+    func_names_params_str = ', '.join(func_params.keys())
+    return func_params_str, func_names_params_str
+
+
+if __name__ == "__main__":
+    def aux(x, y, z=1):
+        pass
+    print(make_params_strings(aux))
+

numbox/utils/timer.py

@@ -9,13 +9,16 @@ logging.basicConfig(level=logging.WARNING)
 class Timer:
     times = {}
 
+    def __init__(self, precision=3):
+        self.precision = precision
+
     def __call__(self, func):
         def _(*args, **kws):
             t_start = perf_counter()
             res = func(*args, **kws)
             t_end = perf_counter()
             duration = t_end - t_start
-            logger.warning(f"Execution of {func.__name__} took {duration:.3f}s")
+            logger.warning(f"Execution of {func.__name__} took {duration:.{self.precision}f}s")
             self.times[func.__name__] = duration
             return res
         return _

{numbox-0.2.6.dist-info → numbox-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: numbox
-Version: 0.2.6
+Version: 0.2.8
 Author: Mikhail Goykhman
 License: MIT License (with Citation Clause)
         
@@ -34,8 +34,12 @@ Keywords: llvmlite,numba,numpy
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: llvmlite==0.44.0
+Requires-Dist: numba~=0.61.0
+Requires-Dist: numpy~=2.1.3
 Provides-Extra: docs
 Requires-Dist: sphinx==8.1.3; extra == "docs"
+Requires-Dist: sphinx-sitemap==2.7.2; extra == "docs"
 Requires-Dist: sphinx-rtd-theme; extra == "docs"
 
 # numbox

{numbox-0.2.6.dist-info → numbox-0.2.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-numbox/__init__.py,sha256=T150U4daRZ7ULOwxGUzzoBDAqm3bW9UydvCf0KJii9I,22
+numbox/__init__.py,sha256=QS1piWKz3Mys2vOiR2kTlrqfdbiwJYEfhOlgbh73Sg8,22
 numbox/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 numbox/core/configurations.py,sha256=0bCmxXL-QMwtvyIDhpXLeT-1KJMf_QpH0wLuEvYLGxQ,68
 numbox/core/any/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -13,9 +13,9 @@ numbox/core/bindings/call.py,sha256=LrSsp-b4Mz0Zjg7H3XkThEIOEqVcrcViEjI9yqhuMV4,
 numbox/core/bindings/signatures.py,sha256=OcSBDpJ422eoWkJXxHPEanMNbVB7bq9f5bRq5LGr86w,479
 numbox/core/bindings/utils.py,sha256=aRtN8oUYBk9vgoUGaUJosGx0Za-vvCNwwbZg_g_-LRs,460
 numbox/core/proxy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-numbox/core/proxy/proxy.py,sha256=kGYlEdLK40lxxu56e_S32s9YuQ6AuQnFegt5uQrUw5w,3889
+numbox/core/proxy/proxy.py,sha256=Wt7yzswDmeQXt0yjcTcnLi2coneowSHWXy_IFpZZJMU,3612
 numbox/core/work/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-numbox/core/work/builder.py,sha256=WFZmH8dHTQNx1TwjpJVtZXN5ud4K2j500HgbF-Msu4c,6063
+numbox/core/work/builder.py,sha256=U7hxopSwOc1ke1Hqup6xCliO7bqjq91zVX1SixYPxoM,6072
 numbox/core/work/combine_utils.py,sha256=qTVGke_ydzaTQ7o29DFjZWZzKjRNKb0L3yJMaR3TLII,2430
 numbox/core/work/explain.py,sha256=ESwvsTgfe0w7UnM13yyVpVDtfJyAK2A1sNdF3RNb-jU,1200
 numbox/core/work/loader_utils.py,sha256=g83mDWidZJ8oLWP3I3rK8aGISYOO2S-w6HDgtosCyck,1572
@@ -23,16 +23,17 @@ numbox/core/work/lowlevel_work_utils.py,sha256=TgRRcNfks0oaOXGXXr3ptafd_Xv_lpmH8
 numbox/core/work/node.py,sha256=CMolyoRQjG2A-pTQqZQ0kxKOYTKipWRC0mu8RWHuTUI,5096
 numbox/core/work/node_base.py,sha256=uI7asM2itQcHuOByXyJtqvrd4ovW6EXDRdHYp3JVHQ0,998
 numbox/core/work/print_tree.py,sha256=y2u7xmbHvpcA57y8PrGSqOunLNCqhgNXdVtXHqvy1M0,2340
-numbox/core/work/work.py,sha256=V_pYW0sqdYHh45ago3aMz0fG4U_UfsNLIcpBejn_ttU,14725
+numbox/core/work/work.py,sha256=596flxydeHuEJ3oUhNz3PYPtA58nxERifvBCh8BWVug,15091
 numbox/core/work/work_utils.py,sha256=3q_nnBdzuxWWcdFpbRL2H0T9ZNkUgx1J1uhiZkX3YG4,1039
 numbox/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-numbox/utils/highlevel.py,sha256=gXYzLsFPKHQfGqaz-Z4DWcCQddv0dS6SKwIsM-_xjYg,1487
+numbox/utils/highlevel.py,sha256=0sUVGOFAzFaGycKrXloGySLjp5EAPaf1B0AcOT1dfbw,8326
 numbox/utils/lowlevel.py,sha256=ACpf8_HyOIsobPlZ31bapkEyuCsV5dojW3AFrcKykrw,10712
 numbox/utils/meminfo.py,sha256=ykFi8Vt0WcHI3ztgMwvpn6NqaflDSQGL8tjI01jrzm0,1759
-numbox/utils/timer.py,sha256=KkAkWOHQ72WtPjyiAzt_tF1q0DcOnCDkITTb85DvkUM,553
+numbox/utils/standard.py,sha256=2fPrMlSXe2TG3CIfjJOT8LQkHEH86oOOj1AvwQkYCfA,450
+numbox/utils/timer.py,sha256=5_d690Fb3L2axJBRxtoB0qe23exBosNR4qu6cno4QfY,641
 numbox/utils/void_type.py,sha256=IkZsjNeAIShYJtvWbvERdHnl_mbF1rCRWiM3gp6II8U,404
-numbox-0.2.6.dist-info/LICENSE,sha256=YYgNvjH_p6-1NsdrIqGJnr1GUbZzA_8DxsP6vVfM6nY,1446
-numbox-0.2.6.dist-info/METADATA,sha256=H7eyqJTneiiqllMj4Boqaxpj-gwZpLjkQlGEhiOuJlE,2792
-numbox-0.2.6.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-numbox-0.2.6.dist-info/top_level.txt,sha256=A67jOkfqidCSYYm6ifjN_WZyIiR1B27fjxv6nNbPvjc,7
-numbox-0.2.6.dist-info/RECORD,,
+numbox-0.2.8.dist-info/LICENSE,sha256=YYgNvjH_p6-1NsdrIqGJnr1GUbZzA_8DxsP6vVfM6nY,1446
+numbox-0.2.8.dist-info/METADATA,sha256=krcMK7v4WNgTrcuriQAWMASeaRod9KybPc57tRUE7w0,2935
+numbox-0.2.8.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+numbox-0.2.8.dist-info/top_level.txt,sha256=A67jOkfqidCSYYm6ifjN_WZyIiR1B27fjxv6nNbPvjc,7
+numbox-0.2.8.dist-info/RECORD,,