compiled-knowledge 4.0.0a17__cp312-cp312-win_amd64.whl → 4.0.0a18__cp312-cp312-win_amd64.whl

ck/pgm_compiler/support/circuit_table/_circuit_table_py.py

@@ -40,21 +40,38 @@ class CircuitTable:
             * all row instances conform to the indexed random variables.
             * all row circuit nodes belong to the given circuit.
         """
-        self.circuit: Circuit = circuit
-        self.rv_idxs: Tuple[int, ...] = tuple(rv_idxs)
-        self.rows: Dict[TableInstance, CircuitNode] = dict(rows)
+        self._circuit: Circuit = circuit
+        self._rv_idxs: Tuple[int, ...] = tuple(rv_idxs)
+        self._rows: Dict[TableInstance, CircuitNode] = dict(rows)
+
+    @property
+    def circuit(self) -> Circuit:
+        return self._circuit
+
+    @property
+    def rv_idxs(self) -> Tuple[int, ...]:
+        return self._rv_idxs
 
     def __len__(self) -> int:
-        return len(self.rows)
+        return len(self._rows)
 
     def get(self, key, default=None):
-        return self.rows.get(key, default)
+        return self._rows.get(key, default)
+
+    def keys(self) -> Iterable[TableInstance]:
+        return self._rows.keys()
+
+    def values(self) -> Iterable[CircuitNode]:
+        return self._rows.values()
+
+    def items(self) -> Iterable[Tuple[TableInstance, CircuitNode]]:
+        return self._rows.items()
 
     def __getitem__(self, key):
-        return self.rows[key]
+        return self._rows[key]
 
     def __setitem__(self, key, value):
-        self.rows[key] = value
+        self._rows[key] = value
 
     def top(self) -> CircuitNode:
         """
@@ -66,10 +83,10 @@ class CircuitTable:
         Returns:
             A single circuit node.
         """
-        if len(self.rows) == 0:
-            return self.circuit.zero
-        elif len(self.rows) == 1:
-            return next(iter(self.rows.values()))
+        if len(self._rows) == 0:
+            return self._circuit.zero
+        elif len(self._rows) == 1:
+            return next(iter(self._rows.values()))
         else:
             raise RuntimeError('cannot get top node from a table with more that 1 row')
 
@@ -119,20 +136,34 @@ def sum_out(table: CircuitTable, rv_idxs: Iterable[int]) -> CircuitTable:
         for remaining_rv_index in remaining_rv_idxs
     )
 
+    # This is a one-pass version to sum the groups. The
+    # two-pass version (below) seems to have better performance.
+    #
+    # circuit: Circuit = table.circuit
+    # result = CircuitTable(circuit, remaining_rv_idxs)
+    # result_rows: Dict[TableInstance, CircuitNode] = result._rows
+    # for instance, node in table.items():
+    #     group_instance = tuple(instance[i] for i in index_map)
+    #     prev_sum = result_rows.get(group_instance)
+    #     if prev_sum is None:
+    #         result_rows[group_instance] = node
+    #     else:
+    #         result_rows[group_instance] = circuit.add(prev_sum, node)
+    # return result
+
     groups: MapList[TableInstance, CircuitNode] = MapList()
-    for instance, node in table.rows.items():
+    for instance, node in table.items():
         group_instance = tuple(instance[i] for i in index_map)
         groups.append(group_instance, node)
-
     circuit: Circuit = table.circuit
-
-    def _result_rows() -> Iterator[Tuple[TableInstance, CircuitNode]]:
-        for group, to_add in groups.items():
-            _node: CircuitNode = circuit.optimised_add(to_add)
-            if not _node.is_zero:
-                yield group, _node
-
-    return CircuitTable(circuit, remaining_rv_idxs, _result_rows())
+    return CircuitTable(
+        circuit,
+        remaining_rv_idxs,
+        (
+            (group, circuit.add(to_add))
+            for group, to_add in groups.items()
+        )
+    )
 
 
 def sum_out_all(table: CircuitTable) -> CircuitTable:
@@ -145,9 +176,9 @@ def sum_out_all(table: CircuitTable) -> CircuitTable:
     if num_rows == 0:
         return CircuitTable(circuit, ())
     elif num_rows == 1:
-        node = next(iter(table.rows.values()))
+        node = next(iter(table.values()))
     else:
-        node: CircuitNode = circuit.optimised_add(table.rows.values())
+        node: CircuitNode = circuit.optimised_add(table.values())
         if node.is_zero:
             return CircuitTable(circuit, ())
 
@@ -168,7 +199,7 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
     """
     Return a circuit table that results from the product of the two given tables.
 
-    If x or y equals `one_table`, then the other table is returned. Otherwise,
+    If x or y have a single row with value 1, then the other table is returned. Otherwise,
     a new circuit table will be constructed and returned.
     """
     circuit: Circuit = x.circuit
@@ -193,18 +224,18 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
     # Set operations on rv indexes. After these operations:
     # * co_rv_idxs is the set of rv indexes common (co) to x and y,
     # * yo_rv_idxs is the set of rv indexes in y only (yo), and not in x.
-    yo_rv_idxs: Set[int] = set(y_rv_idxs)
-    co_rv_idxs: Set[int] = set(x_rv_idxs)
-    co_rv_idxs.intersection_update(yo_rv_idxs)
-    yo_rv_idxs.difference_update(co_rv_idxs)
+    yo_rv_idxs_set: Set[int] = set(y_rv_idxs)
+    co_rv_idxs_set: Set[int] = set(x_rv_idxs)
+    co_rv_idxs_set.intersection_update(yo_rv_idxs_set)
+    yo_rv_idxs_set.difference_update(co_rv_idxs_set)
 
-    if len(co_rv_idxs) == 0:
+    if len(co_rv_idxs_set) == 0:
         # Special case: no common random variables.
         return _product_no_common_rvs(x, y)
 
     # Convert random variable index sets to sequences
-    yo_rv_idxs: Tuple[int, ...] = tuple(yo_rv_idxs)  # y only random variables
-    co_rv_idxs: Tuple[int, ...] = tuple(co_rv_idxs)  # common random variables
+    yo_rv_idxs: Tuple[int, ...] = tuple(yo_rv_idxs_set)  # y only random variables
+    co_rv_idxs: Tuple[int, ...] = tuple(co_rv_idxs_set)  # common random variables
 
     # Cache mappings from result Instance to index into source Instance (x or y).
     # This will be used in indexing and product loops to pull our needed values
@@ -215,7 +246,7 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
 
     # Index the y rows by common-only key (y is the smaller of the two tables).
     y_index: MapList[TableInstance, Tuple[TableInstance, CircuitNode]] = MapList()
-    for y_instance, y_node in y.rows.items():
+    for y_instance, y_node in y.items():
         co = tuple(y_instance[i] for i in co_from_y_map)
         yo = tuple(y_instance[i] for i in yo_from_y_map)
         y_index.append(co, (yo, y_node))
@@ -223,7 +254,7 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
     def _result_rows() -> Iterator[Tuple[TableInstance, CircuitNode]]:
         # Iterate over x rows, yielding (instance, value).
         # Rows with constant node values of one are optimised out.
-        for _x_instance, _x_node in x.rows.items():
+        for _x_instance, _x_node in x.items():
             _co = tuple(_x_instance[i] for i in co_from_x_map)
             if _x_node.is_one:
                 # Multiplying by one.
@@ -233,7 +264,10 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
             else:
                 # Iterate over matching y rows.
                 for _yo, _y_node in y_index.get(_co, ()):
-                    yield _x_instance + _yo, circuit.optimised_mul((_x_node, _y_node))
+                    if _y_node.is_one:
+                        yield _x_instance + _yo, _x_node
+                    else:
+                        yield _x_instance + _yo, circuit.mul(_x_node, _y_node)
 
     return CircuitTable(circuit, x_rv_idxs + yo_rv_idxs, _result_rows())
 
@@ -256,14 +290,15 @@ def _product_no_common_rvs(x: CircuitTable, y: CircuitTable) -> CircuitTable:
     result_rv_idxs: Tuple[int, ...] = x.rv_idxs + y.rv_idxs
 
     def _result_rows() -> Iterator[Tuple[TableInstance, CircuitNode]]:
-        for x_instance, x_node in x.rows.items():
+        for x_instance, x_node in x.items():
             if x_node.is_one:
-                for y_instance, y_node in y.rows.items():
-                    instance = x_instance + y_instance
-                    yield instance, y_node
+                for y_instance, y_node in y.items():
+                    yield x_instance + y_instance, y_node
             else:
-                for y_instance, y_node in y.rows.items():
-                    instance = x_instance + y_instance
-                    yield instance, circuit.optimised_mul((x_node, y_node))
+                for y_instance, y_node in y.items():
+                    if y_node.is_one:
+                        yield x_instance + y_instance, y_node
+                    else:
+                        yield x_instance + y_instance, circuit.mul(x_node, y_node)
 
     return CircuitTable(circuit, result_rv_idxs, _result_rows())

ck/pgm_compiler/support/named_compiler_maker.py

@@ -12,6 +12,7 @@ def get_compiler(module: ModuleType, **kwargs) -> Tuple[PGMCompiler]:
 
     Args:
         module: module containing `compile_pgm` function.
+        kwargs: are additional keyword arguments to `compile_pgm`.
 
     Returns:
         a singleton tuple containing PGMCompiler function.
@@ -24,10 +25,19 @@ def get_compiler(module: ModuleType, **kwargs) -> Tuple[PGMCompiler]:
     return compiler,
 
 
-def get_compiler_algorithm(module, algorithm: str, **kwargs) -> Tuple[PGMCompiler]:
+def get_compiler_algorithm(module: ModuleType, algorithm: str, **kwargs) -> Tuple[PGMCompiler]:
     """
     Helper function to create a named PGM compiler, with a named algorithm argument.
+
+    Args:
+        module: module containing `compile_pgm` function.
+        algorithm: name of the algorithm, to pass as keyword argument to `compile_pgm`.
+            The algorithm should be declared in the module.
+        kwargs: are additional keyword arguments to `compile_pgm`.
+
+    Returns:
+        a singleton tuple containing PGMCompiler function.
     """
-    return get_compiler(module, algorithm=getattr(module, algorithm, **kwargs))
+    return get_compiler(module, algorithm=getattr(module, algorithm), **kwargs)
 
 

ck/utils/iter_extras.py

@@ -2,7 +2,7 @@
 A module with extra iteration functions.
 """
 from functools import reduce as _reduce
-from itertools import combinations, chain
+from itertools import combinations, chain, islice
 from operator import mul as _mul
 from typing import Iterable, Tuple, Sequence, TypeVar
 
@@ -154,3 +154,10 @@ def first(items: Iterable[_T]) -> _T:
     Return the first element of the iterable.
     """
     return next(iter(items))
+
+
+def take(iterable: Iterable[_T], n: int) -> Iterable[_T]:
+    """
+    Take the first n elements of the iterable.
+    """
+    return islice(iterable, n)

ck_demos/utils/compare.py

@@ -1,3 +1,4 @@
+import gc
 from typing import Sequence
 
 from ck.circuit_compiler import NamedCircuitCompiler
@@ -88,6 +89,7 @@ def compare(
                         print(f'{"":{col_cct_ops}}', end=sep)
                         print(f'{"":{col_pgm_compile_time}}', end=sep)
                     else:
+                        gc.collect()
                         time.start()
                         pgm_cct: PGMCircuit = pgm_compiler(pgm)
                         time.stop()
@@ -97,6 +99,7 @@ def compare(
                         prev_pgm = pgm
                         prev_pgm_compiler = pgm_compiler
 
+                    gc.collect()
                     time.start()
                     # `pgm_cct` will always be set but the IDE can't work that out.
                     # noinspection PyUnboundLocalVariable
@@ -104,11 +107,12 @@ def compare(
                     time.stop()
                     print(f'{time.seconds():{col_cct_compile_time}{comma}.3f}', end=sep)
 
+                    gc.collect()
                     time.start()
                     for _ in range(1000):
                         wmc.compute()
                     time.stop()
-                    print(f'{time.seconds() * 1000:{col_execute_time}{comma}.3f}', end=sep)
+                    print(f'{time.seconds() * 1000:{col_execute_time}{comma}.3f}', end='')
                 except Exception as err:
                     print(repr(err), end='')
                 print()

{compiled_knowledge-4.0.0a17.dist-info → compiled_knowledge-4.0.0a18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compiled-knowledge
-Version: 4.0.0a17
+Version: 4.0.0a18
 Summary: A Python package for compiling and querying discrete probabilistic graphical models.
 Author-email: Barry Drake <barry@compiledknowledge.org>
 License-Expression: MIT

{compiled_knowledge-4.0.0a17.dist-info → compiled_knowledge-4.0.0a18.dist-info}/RECORD

@@ -1,9 +1,10 @@
 ck/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/pgm.py,sha256=rbqgP-clfSvgpzUXxVjk_6SdM9neHmpChku6qpyeidk,120700
-ck/circuit/__init__.py,sha256=pMe0M2WI0A1Kr8TCty82oRKrHnDeTjL1rr0Wy03shY0,217
-ck/circuit/_circuit_cy.cp312-win_amd64.pyd,sha256=Pyd-NonuBw-XvnguxnsZBqf3P4O1W9Tdlt3T4p4OWG4,248320
-ck/circuit/_circuit_cy.pyx,sha256=wFu81taNG3M-SLJivhVoJwZVX_50eHyBVduIx5vtHFw,28453
-ck/circuit/_circuit_py.py,sha256=9C-5PuKEnU8eTgdCZysTAsbvHDOLTcsSjzcXdIHH-Ow,28339
+ck/circuit/__init__.py,sha256=7ZSBPV6HGKTJ9a_jSAgUbPNOZVHGaeR-e0H1-6cA0HY,621
+ck/circuit/_circuit_cy.cp312-win_amd64.pyd,sha256=9AhhezX-NSuOC0fItKegFsoE3trossTXenTyMzW4d_U,252928
+ck/circuit/_circuit_cy.pxd,sha256=hWdx4rcPS2iwHr6NBTjB38LAJZiLktTXhcoVqmGpwkk,1098
+ck/circuit/_circuit_cy.pyx,sha256=F9ut2mI92pIvBVAaetJqFpxbsBx--mNvHqVCTQ6Ad7k,27622
+ck/circuit/_circuit_py.py,sha256=vN8lg01RyjA_YUphjx1dr0Uj4ql4seczRcoCaH7ylAw,28341
 ck/circuit/tmp_const.py,sha256=dG9FuGfoAG5qjYG1rNwekqKiea_KmVfxHMTOgCPbBiQ,2372
 ck/circuit_compiler/__init__.py,sha256=T0Igyp5jPgnIXv4oRcIYhmsOdcNOb3L4Za6dK6eYk7g,132
 ck/circuit_compiler/circuit_compiler.py,sha256=8BLB8DUnPbpl5PXZsIopydPbItytdn2rzRfM2U1EC84,1018
@@ -12,9 +13,8 @@ ck/circuit_compiler/llvm_compiler.py,sha256=ejeNPkO5Og2FyjjyA5JAexxUl1f8IJ6mwU5N
 ck/circuit_compiler/llvm_vm_compiler.py,sha256=I46_XV5FrClDKO06zIjn8T3ME5XQ9RYJ_1aAE8e_YzM,21873
 ck/circuit_compiler/named_circuit_compilers.py,sha256=snlD3JnhAZC-atKpf5GD0v4CGdvj2_ZhCZ3O-tsxzxc,2284
 ck/circuit_compiler/cython_vm_compiler/__init__.py,sha256=pEAwTleuZgdYhTAQMea2f9YsFK54eoNbZSbrWkW8aeE,49
-ck/circuit_compiler/cython_vm_compiler/_compiler.c,sha256=nL6nPNrlx6RfmGeK7ZFgw38PMrs7n4w0KFBV9ba_zcU,722307
-ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win_amd64.pyd,sha256=JK43LQ7GVu7P_Lx5xO7-qdKi0z9baTTSthYg0Ra8XEQ,81920
-ck/circuit_compiler/cython_vm_compiler/_compiler.pyx,sha256=c9NVKWtL2ctY_ja5MZg74hgw8hKKztLi7FB6S1kLTe4,8542
+ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win_amd64.pyd,sha256=KXGhDoWnKSTxyi66ojn2FDlYL5ZqkR8bwQhsA4aLYog,82432
+ck/circuit_compiler/cython_vm_compiler/_compiler.pyx,sha256=L90JvxOXJq1eXy11ykWaFNcWU_p0pyfDVm9A4LKBjr8,8583
 ck/circuit_compiler/cython_vm_compiler/cython_vm_compiler.py,sha256=yUkBNr5HnoVXyWjJdXHp8lyAXFiIDYapvMvHtzKuhI8,3140
 ck/circuit_compiler/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/circuit_compiler/support/circuit_analyser.py,sha256=jM0QW2flucvpc6fqcT8mL00ZA0rPTUhaE-yFfFQMXgE,2722
@@ -83,11 +83,14 @@ ck/pgm_compiler/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 ck/pgm_compiler/support/clusters.py,sha256=7jsZfPqv29vZNxmtiHBCBo3mEfvLQ_ejYh69M_d-nmo,21381
 ck/pgm_compiler/support/factor_tables.py,sha256=tV9qE2zC8iwEQxTuXE6qiE6lmMpz4-Vc80_w5woo1tk,15556
 ck/pgm_compiler/support/join_tree.py,sha256=OGAuZVHzT0i4e6TJ03dOM7e3gbpuW9AyjZKvSBvKvJA,12894
-ck/pgm_compiler/support/named_compiler_maker.py,sha256=tQ79JOI8MknAziUiFhFGV9n4y6PPKrnbq3-quMmnrwY,974
-ck/pgm_compiler/support/circuit_table/__init__.py,sha256=V_hwJxsHqGucmE1k1VYg6QGzB9zJeaFBc2LBUyof3dk,172
-ck/pgm_compiler/support/circuit_table/_circuit_table_cy.cp312-win_amd64.pyd,sha256=m3OToh7KVIuOSxII_D0bbbDlnpUZ4bqjTOu9IoPH-DY,94720
-ck/pgm_compiler/support/circuit_table/_circuit_table_cy.pyx,sha256=JLC4_nsRPb8xC3alHE0G9Ojie9K4oUULVPrulkQnhds,11886
-ck/pgm_compiler/support/circuit_table/_circuit_table_py.py,sha256=Dr6R4BU_UGlDZYYq3jOlEdIwk_OilExaurSznIeajls,10146
+ck/pgm_compiler/support/named_compiler_maker.py,sha256=g2MLnlkWXkISHL6dh23EY53SptTo7-itfuZogSpMdB8,1420
+ck/pgm_compiler/support/circuit_table/__init__.py,sha256=Ct1i7jP4sZI_G4IU75pubf4tLyMrB8u47ZbTC8_zBqU,576
+ck/pgm_compiler/support/circuit_table/_circuit_table_cy.cp312-win_amd64.pyd,sha256=-vH_LNfBmGcD2fJEaNaARI7zO2bIfiWJNfrbHYrYVTE,93696
+ck/pgm_compiler/support/circuit_table/_circuit_table_cy.pyx,sha256=rVO1yxjZmZ6yv5s0zKq4Ji9WYrDuYTZsRG_zeF1_1xE,12015
+ck/pgm_compiler/support/circuit_table/_circuit_table_cy_cpp_verion.pyx,sha256=C6jQPXmZgLCFf799o1MoRnEr7ihlMYdSf_c4r1TPDEM,20614
+ck/pgm_compiler/support/circuit_table/_circuit_table_cy_minimal_version.pyx,sha256=n7qdSQwnpyQ_0g9esXGtFB3STI7N3uWLzEVhCjNXb_U,11417
+ck/pgm_compiler/support/circuit_table/_circuit_table_cy_v4.0.0a17.pyx,sha256=JLC4_nsRPb8xC3alHE0G9Ojie9K4oUULVPrulkQnhds,11886
+ck/pgm_compiler/support/circuit_table/_circuit_table_py.py,sha256=h6xPYGBSy6XHQBFLPD2D1-V7Kiw9utY68nWrcGRMEg4,11287
 ck/probability/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/probability/empirical_probability_space.py,sha256=HoLxmigzlWFWQlcZQwDOYk-mjgf6RW1IPE-l0t8vMPw,1950
 ck/probability/pgm_probability_space.py,sha256=vK-drx145PWW2aYB8HttQcvhvqPfxVl72bPcFO8jw8M,1034
@@ -107,7 +110,7 @@ ck/sampling/wmc_gibbs_sampler.py,sha256=GMKVW2AVtsWtP6vxE3Y2dy-dKr7GoO_vLEA9eC30
 ck/sampling/wmc_metropolis_sampler.py,sha256=PRv7wtPZz7BcwN8iArsykVwqgY77v5km7rXcawFAUPQ,6470
 ck/sampling/wmc_rejection_sampler.py,sha256=cd0VONZf-oa491RRKfwT2LakQs0o_slgPCes8AOvSNc,4897
 ck/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ck/utils/iter_extras.py,sha256=DDml5Jprmun2RovJxkwXx1uJkWacYhZEnX1ARSX2TB4,4310
+ck/utils/iter_extras.py,sha256=QNd3mJxPsKN0Wg12K_Iuefto5A2Vv9leuMvymAdt4uo,4479
 ck/utils/local_config.py,sha256=-oTKvKCpm29JeHEhV1_qLC5fMS523unDzXr0VYE3M0U,9535
 ck/utils/map_list.py,sha256=T2OpjI7eDgC4geCtW_FsEr6ryiePOnKZwfDahB63zfA,3847
 ck/utils/map_set.py,sha256=BLu9BO3FCtzZlZ9MfP9STtIdQ4Me8-QKdwB7o15y7f8,3809
@@ -160,12 +163,12 @@ ck_demos/sampling/demo_marginal_direct_sampler.py,sha256=RhNunuIUnYI_GXp9m8wzadM
 ck_demos/sampling/demo_uniform_sampler.py,sha256=Z6tX_OYKGLc_w3-kEPK4KEZlJo7F5HOq_tUVppB_VQE,962
 ck_demos/sampling/demo_wmc_direct_sampler.py,sha256=c7maxTmZyIijaVdFs2h_KQbK30LvI-oCm2BXSUXVoD8,1113
 ck_demos/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ck_demos/utils/compare.py,sha256=MwigxgMqeV7slrzdIJYVJ340QBCCXOeUzUKOJkkd98w,4972
+ck_demos/utils/compare.py,sha256=Bwjpflevl4nusfA0zp96rInaVKFGuhC5Xv7HzA1Fobk,5088
 ck_demos/utils/convert_network.py,sha256=TSKj8q7L7J5rhrvwjaDkdYZ0Sg8vV5FRL_vCanX1CQw,1363
 ck_demos/utils/sample_model.py,sha256=in-Nlv-iuNIu6y9fDuMyo7nzgimBuTAnCWcpnVqvqDQ,8839
 ck_demos/utils/stop_watch.py,sha256=VzXHRWx0V8vPSD-bLgLlEYkCkR2FA0-KmM_pfKx-Pxo,13205
-compiled_knowledge-4.0.0a17.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
-compiled_knowledge-4.0.0a17.dist-info/METADATA,sha256=tOzAP4I8J_GgurONBokeDJvcG1Ycdizt7uW3pDqcM7Y,1838
-compiled_knowledge-4.0.0a17.dist-info/WHEEL,sha256=b7PoVIxzH_MOHKjftqMzQiGKfdHRlRFepVBVPg0y3vc,101
-compiled_knowledge-4.0.0a17.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
-compiled_knowledge-4.0.0a17.dist-info/RECORD,,
+compiled_knowledge-4.0.0a18.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
+compiled_knowledge-4.0.0a18.dist-info/METADATA,sha256=ZjA0RqiyN9UdM20v0vQ_qb7Ru6dr8ZO7Bis-dX7rIM0,1838
+compiled_knowledge-4.0.0a18.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
+compiled_knowledge-4.0.0a18.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
+compiled_knowledge-4.0.0a18.dist-info/RECORD,,

{compiled_knowledge-4.0.0a17.dist-info → compiled_knowledge-4.0.0a18.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: false
 Tag: cp312-cp312-win_amd64