d4Solver 0.1.0__cp39-cp39-win_amd64.whl

d4solver-0.1.0.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.13.0
+Arguments: ['C:\\Users\\jmcla\\AppData\\Local\\Temp\\cibw-run-okvfe56f\\cp39-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '--add-path', 'C:\\vcpkg\\installed\\x64-windows\\bin', '-w', 'C:\\Users\\jmcla\\AppData\\Local\\Temp\\cibw-run-okvfe56f\\cp39-win_amd64\\repaired_wheel', 'C:\\Users\\jmcla\\AppData\\Local\\Temp\\cibw-run-okvfe56f\\cp39-win_amd64\\built_wheel\\d4solver-0.1.0-cp39-cp39-win_amd64.whl']

d4solver-0.1.0.dist-info/METADATA

@@ -0,0 +1,225 @@
+Metadata-Version: 2.2
+Name: d4Solver
+Version: 0.1.0
+Summary: Python bindings for the D4 model counter and compiler
+Author-Email: Logical Team <contact@univ-artois.fr>
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# py-d4
+
+Python bindings for the **D4** compiler and model counter, supporting option structures, CNF files, custom clause vectors, logic circuits, weighted model counting, and d-DNNF queries. Built with `nanobind` and `scikit-build-core`.
+
+---
+
+## 🚀 Users Guide
+
+### 1. Installation
+
+Install the package directly from your GitLab PyPI package registry (typically configured in your CI or local `.pip/pip.conf`):
+
+```bash
+pip install d4Solver --extra-index-url https://gitlab.univ-artois.fr/api/v4/projects/<PROJECT_ID>/packages/pypi/simple
+```
+
+### 2. Usage Examples
+
+#### 2.1 Basic Model Counting
+
+You can instantiate a `Solver` using a CNF filepath or raw Python clause structures (list of lists/tuples of literals, 1-based indexing):
+
+```python
+import py_d4
+
+# 1. Option A: Load from a DIMACS CNF file
+solver = py_d4.Solver("path/to/formula.cnf")
+
+# 2. Option B: Pass raw Python clauses and total variable count
+# Formula: (x1 or x2) and (not x2 or x3)
+clauses = [
+    [1, 2],
+    [-2, 3]
+]
+nb_vars = 3
+solver = py_d4.Solver(clauses, nb_vars)
+
+# Run model counting
+count_res = solver.count()
+print(f"Number of models: {count_res.getResult()}")     # Large integer as string (GMP support)
+print(f"As Python integer: {count_res.getIntResult()}")  # Safe python int
+```
+
+#### 2.2 Compilation to d-DNNF
+
+`py-d4` can compile CNF formulas and circuits into Decision Diagram / Deterministic Decomposable Negation Normal Form (d-DNNF):
+
+```python
+import py_d4
+
+clauses = [[1, 2], [-2, 3]]
+solver = py_d4.Solver(clauses, 3)
+
+# Compile
+compile_res = solver.compile()
+
+# Access compiled graph statistics
+print(f"Nodes in d-DNNF: {compile_res.getNbNodes()}")
+print(f"Edges in d-DNNF: {compile_res.getNbEdges()}")
+
+# Get the compiled NNF circuit string (in standard d-DNNF format)
+nnf_str = compile_res.getNNFString()
+print("NNF String:\n", nnf_str)
+```
+
+#### 2.3 Querying the Compiled d-DNNF
+
+Once compiled, you can run multiple queries (SAT checks or model counting) under different literal assumptions:
+
+```python
+# Check if the formula is satisfiable (no assumptions)
+is_sat = compile_res.isSAT([])  # True/False
+
+# Check satisfiability assuming x1 is True (1) and x2 is False (-2)
+is_sat_under_assumptions = compile_res.isSAT([1, -2])
+
+# Count models under literal assumptions
+# E.g., model count assuming x1 is True
+count_under_x1 = compile_res.count([1])
+print(f"Models satisfying x1: {count_under_x1}")
+```
+
+#### 2.4 Weighted Model Counting (WMC)
+
+You can assign weights to literals for exact weighted model counting:
+
+```python
+import py_d4
+
+# Formula: (x1 or x2)
+solver = py_d4.Solver([[1, 2]], nb_vars=2)
+
+# Define weights for literals (keys are 1-based literals, values are string representations)
+weights = {
+    1: "0.3",
+    -1: "0.7",
+    2: "0.4",
+    -2: "0.6"
+}
+# Set weights (WeightType can be FLOAT or GMP)
+solver.setWeights(weights, py_d4.WeightType.FLOAT)
+
+# Compute WMC directly
+count_res = solver.count()
+print("WMC Result:", float(count_res.getResult()))  # Output: 0.58
+
+# Or compile and query WMC under assumptions
+compile_res = solver.compile()
+print("WMC under x1=True:", float(compile_res.count([1])))  # Output: 0.3
+```
+
+#### 2.5 Logic Gates / Circuit Compilation
+
+Instead of CNF, you can initialize the solver with logic gates to compile or count structured circuits:
+
+```python
+import py_d4
+
+# Create a gate representing: x3 = x1 AND (not x2)
+gate = py_d4.Gate()
+gate.gateType = py_d4.GateType.AND
+gate.inputs = [1, -2]
+gate.output = 3
+
+# Instantiate solver from gate specifications
+solver = py_d4.Solver([gate], nb_vars=3)
+print("Models for circuit:", solver.count().getIntResult())
+```
+
+#### 2.6 Solver Configuration & Options
+
+Fine-tune the behavior of D4 by mutating native C++ option structures. Documentation and description of settings are exposed natively as Python docstrings:
+
+```python
+import py_d4
+
+# Instantiate default options
+opt = py_d4.OptionDpllStyleMethod()
+
+# 1. Read Option Descriptions (C++ docstrings exposed to Python)
+print(py_d4.OptionDpllStyleMethod.exploitModel.__doc__)
+# Output: "If we exploit model during search"
+
+# 2. Modify properties directly (with type safety)
+opt.precision = 30
+opt.exploitModel = False
+opt.optionSolver.solverName = 0  # 0: glucose, 1: minisat
+
+# 3. Modify nested option group settings
+opt.optionBranchingHeuristic.freqDecay = 98
+
+# 4. Pass options to the Solver
+solver = py_d4.Solver("formula.cnf", opt)
+
+# 5. Serialize options to/from standard Python Dictionaries
+config_dict = py_d4.dump_options_to_dict(opt)
+opt_restored = py_d4.load_options_from_dict(config_dict)
+
+# 6. Serialize options to/from raw JSON Strings (via native C++ bindings)
+json_str = py_d4._py_d4.dump_options_to_json(opt)
+opt_restored_json = py_d4._py_d4.load_options_from_json(json_str)
+```
+
+---
+
+## 🛠️ Developers Guide
+
+### 1. Requirements
+
+Before building locally, ensure the following system-level dependencies are installed on your host:
+- C++20 compatible compiler (e.g. GCC >= 10, Clang >= 10)
+- CMake (>= 3.15)
+- GMP development headers (`libgmp-dev` / `gmp-devel`)
+- Zlib development headers (`zlib1g-dev` / `zlib-devel`)
+
+### 2. Local Build Pipeline
+
+To compile the C++ extension module and deploy it directly inside your local Python package tree, run:
+
+```bash
+# 1. Provide your GitLab access token to clone the D4 dependency
+export GITLAB_TOKEN_LOGICAL="your_gitlab_token"
+
+# 2. Configure, generate bindings, compile, and deploy shared library
+./build.sh
+```
+
+Alternatively, you can install the package in editable mode via pip:
+```bash
+pip install -e .
+```
+
+### 3. Re-Generating Bindings
+
+If D4 option headers change, you can automatically parse the new C++ classes and inline constructor descriptions to rebuild the `nanobind` bindings:
+
+```bash
+python3 scripts/generate_bindings.py /path/to/local/d4
+```
+*(If `/path/to/local/d4` is omitted, the script automatically searches the CMake FetchContent directory).*
+
+### 4. Running Tests
+
+To execute the test suite and verify the integrity of the wrapper:
+
+```bash
+LD_PRELOAD=$(gcc -print-file-name=libstdc++.so.6) PYTHONPATH=. python3 tests/test_options.py
+```
+
+### 5. GitLab CI/CD Pipeline
+
+The project includes an automated multi-stage `.gitlab-ci.yml` pipeline:
+- **Build Stage**: Uses `cibuildwheel` to compile optimized, standalone Linux wheels for Python 3.8 to 3.13. It automatically routes the group-level `GITLAB_TOKEN_LOGICAL` CI variable to authenticate both the `py-d4` and internal `d4`/`optree` sub-project checkouts.
+- **Deploy Stage**: Triggered on pushing Git tags. Automatically publishes the generated wheel packages directly to the GitLab project PyPI package registry using `twine`.

d4solver-0.1.0.dist-info/RECORD

@@ -0,0 +1,161 @@
+d4solver-0.1.0.dist-info/DELVEWHEEL,sha256=dSEswSwTg7ro9AjNNaixXHYXOSUEUSPtczQDMMpz1us,434
+d4solver-0.1.0.dist-info/METADATA,sha256=XLJbz2j6VHPwzkjXyS-a0zwLD0B7COH0EqQRX6PahlY,6996
+d4solver-0.1.0.dist-info/RECORD,,
+d4solver-0.1.0.dist-info/WHEEL,sha256=jZUvyGBCQrKVx2-MUp-gceh00vI_BpQj-dsg9mVPBY0,103
+d4solver.libs/.load-order-d4solver-0.1.0,sha256=JLvkuJrVdExkN74gKXGKhtX9HhEFTen54e9_esnNhY8,135
+d4solver.libs/gmp-10-521f5d57a531da7f2ddd75a64634bf47.dll,sha256=Uh9dV6Ux2n8t3XWmRjS_R6xFy_jAqitZQNhB5mhXlqE,423424
+d4solver.libs/gmpxx-4-1aec0d72b737c81b6397e2967c9be349.dll,sha256=ph9Yg908BAzNwGoQrzcMsO9cW23twhLJ0QlBi4hTyR4,27136
+d4solver.libs/msvcp140-484f56d9de72c048820300919dc49e56.dll,sha256=SE9W2d5ywEiCAwCRncSeVtm8O7RWdnkNPu60BsFCjCk,568712
+include/__init__.py,sha256=Zn0lfL13i8oze3nyGmRZW32A6pVMT0F9HDKZQBZNc28,1570
+include/optree/EnumMetadata.hpp,sha256=cj62izIeeV9eS2j_ZPLM3x83Xta-Tmmd9j2JJfDEWgw,1821
+include/optree/Option.hpp,sha256=k6ZfXLBrcDKxRxFz8lw5RVq14T69kHYUR5F4vfUQzYw,5803
+include/optree/OptionBase.hpp,sha256=AYqym2Hv1Uz-ysG9o7t9oTn_FFI3LbZVd4TdkP8V_LY,1543
+include/optree/OptionGroup.hpp,sha256=aOHsmoldHwoabRx7jRMz31SoILTyhhpkeVXVtBeOSR8,2239
+include/optree/OptionJson.hpp,sha256=wkWPMkYnmdz7hcEe_hCAL3dsKF1VBGzQ8_KuL8Yti98,7988
+include/optree/OptionRegistry.hpp,sha256=pksvrMcES3dN32TsFZKFVuaurIzo9DQcQ5PdEXr68dE,13121
+include/py-d4-standard/ActivityManager.hpp,sha256=rc6syVLEl1kMU-9hDgd285i-nwEvom4GNZWbWuMgmeI,1239
+include/py-d4-standard/Alg.hpp,sha256=RFhMjm4TwjqGxG5iO2lFZhiRFMOQLwTZOB6qG-Lemes,2780
+include/py-d4-standard/Alloc.hpp,sha256=01QcLu-LgdXvi5JmSUkHJvmjeONUjdjpSSiVCsSPDW8,4287
+include/py-d4-standard/AndGatesExtractor.hpp,sha256=s23xhF3rl193S5zKM1zGTf3zy1OXb1_P5OxSaRVvPls,1518
+include/py-d4-standard/AtMost1Extractor.hpp,sha256=f9xxfW7M2U0o5DxYwCo_KurtMaLTi0UmFyqLf71XUUk,1967
+include/py-d4-standard/BadBehaviourException.hpp,sha256=v4o-4ZKEqKA3b-oEvgaEbjKVu-zKxL2jYwzAKesoAx8,1532
+include/py-d4-standard/BranchingHeuristic.hpp,sha256=mU8Y5VI9FUm-0KZU5uq_eAgaeMjRDsVJPELkklqwgWo,7971
+include/py-d4-standard/BranchingHeuristicClassic.hpp,sha256=L7ZRE-zyYGo-BnIu0yd1CX4lnkIDYezHum6UMU1UAFY,2845
+include/py-d4-standard/BranchingHeuristicHybridPartialClassic.hpp,sha256=ntIJqEaAfQ8lVrShx5gkqHBBfjd9DXCl4cdOmk6wShs,3666
+include/py-d4-standard/BranchingHeuristicLargeArity.hpp,sha256=bchVaERu1uX26bDBn5vCbTXIzYvrQymEaiesALr34Ks,3193
+include/py-d4-standard/BucketAllocator.hpp,sha256=30KF0pScuQjV89qXEsX7IhFqRF4xdg_oummrLXRIklY,3991
+include/py-d4-standard/BucketException.hpp,sha256=reOQi76jxIB5mhpgJ7-cxtdvsr3zdn8u7OrtS6j0DFc,1520
+include/py-d4-standard/BucketInConstruction.hpp,sha256=BEYT_pxE5SC3Ji3uHFqIinl7VQ2AG-lCkYKojXLWwuk,2164
+include/py-d4-standard/BucketManager.hpp,sha256=JDorIW4IUgbp1Zy5rGZJxCOAcZGGut68evtbaT4UJFQ,2968
+include/py-d4-standard/BucketSortInfo.hpp,sha256=eCJnQsKZ5GpsnL5my4zlHQnd039KK4pFQnZ1mU1yJ2s,1493
+include/py-d4-standard/BufferRead.hpp,sha256=QHSqNzEtYIPEjo4VfHDErHktAIWNNQJ_ar7B6Nd9eUM,4251
+include/py-d4-standard/CacheCleaningExpectation.hpp,sha256=TOkxgfkbqGytOEz6vkrVmbdB3xcVFm1KCVpQzg7V32c,4706
+include/py-d4-standard/CacheCleaningManager.hpp,sha256=lr2fdCUbEd4MnCl_JM9YnGiZSNvAj-Cbo5DAyabVkL8,2908
+include/py-d4-standard/CacheCleaningNone.hpp,sha256=jTzx7jsNJtYTTWa4F__l6fgUs1r-HlF_Tro8_7qk2lk,1588
+include/py-d4-standard/CachedBucket.hpp,sha256=kZFP0Wbq7Y2MxMcgBPzbDjaJMsvrf6fGXYGzP9Kg9JY,2053
+include/py-d4-standard/CacheList.hpp,sha256=wHsRXsjOJpXMk-YlKKDUuVu7ea8UgzrUx4xJM1_R5GI,5663
+include/py-d4-standard/CacheManager.hpp,sha256=NjSr68fkouiA_11hL0ehgwKPENEHGzvDDtlzBw-xCu0,8876
+include/py-d4-standard/CacheNoCollision.hpp,sha256=VLaX5jWEHZIjKi48mNGjuyP4FDatzmPrg5NzvVrnsMU,4493
+include/py-d4-standard/CircuitManager.hpp,sha256=5okugdLTkmGy2c7c9pek3g5uMMx_MLZUOr7JEqeMYww,3443
+include/py-d4-standard/CircuitManagerDyn.hpp,sha256=WpreEgWRn2FEijR8kxzHaZETPT4Y2fgx0xAt3vb45dc,2280
+include/py-d4-standard/CircuitWithCnfManager.hpp,sha256=L_9emw8xOP2GtSzOa4odSlVAiQOKZMKU-SfS3q-Woo4,2098
+include/py-d4-standard/ClauseInfo.hpp,sha256=HxFkDS7ptq1ovPtbZpk7es2kS1eQ8B_KT_7HuzyK8cA,1130
+include/py-d4-standard/CnfManager.hpp,sha256=rHx8lD2hrSoDlV5Wzc72v-Sn14G_NjokzZho6WHuc88,7885
+include/py-d4-standard/CnfManagerDyn.hpp,sha256=Y7bVxEbw5xQAoJ3L9O2CjyP6lmR7ISonBcojflmGiHI,6062
+include/py-d4-standard/CnfManagerDynBlockedCl.hpp,sha256=-ASyyl_0ZXb8-8WmKexQiiVG4M_TuFqHWE1Ut3Arnd0,2698
+include/py-d4-standard/CnfManagerDynPure.hpp,sha256=JC3-oUpJ3_BeOaZuG-88Br1Ar6XfeCx2bcspcG756Zk,2161
+include/py-d4-standard/Counter.hpp,sha256=WggUpl0r7ZE_0GmMMzKe2gzcv24JA3sYG7VL9RZZ4bA,1700
+include/py-d4-standard/DataBranch.hpp,sha256=xhqsaFJi-rxRSCfRbgE2SA8BaGcx3VTLVl1ebJLUH2o,1184
+include/py-d4-standard/DataInfo.hpp,sha256=-g0kX0x3m2hc94urR_7vJVJBNoVgUA3lNXBJvxZk5vY,2033
+include/py-d4-standard/DataOccurrence.hpp,sha256=mFrXL7ftW-Bga3-MmtJ3Ed4IynnaZ_920pA-GD5Dt5Y,2993
+include/py-d4-standard/DpllStyleMethod.hpp,sha256=T1lRcrSlTVqmmAgMf3EXqOGAX4FTO3CbXfY9jdMWkJw,18882
+include/py-d4-standard/EnumMetadata.hpp,sha256=i99qZjZsmFyry5OTftzSNF4TdOgI5QTe7WdAixYPzPk,620
+include/py-d4-standard/EquivExtractor.hpp,sha256=5qLA8ttLChXArYI5oM7SeIkwcr5CaTkwYQwEsdPU2DA,1489
+include/py-d4-standard/ErrorCode.hpp,sha256=Hh-U36MpXNpUmm5wFohd6BtIJbhk8nLkYOPy3oa-pZo,951
+include/py-d4-standard/ExistRandomExist.hpp,sha256=NH39YhWi9xBFwnf_lmz1rZBzaJm9kXVNLia0YrOWb7c,39079
+include/py-d4-standard/FactoryException.hpp,sha256=GL6aXgy1vT9JZpgcvMlVAXrv61ZkY3XyOYVJbYgAn7o,1522
+include/py-d4-standard/FormulaManager.hpp,sha256=8Qy1sgLMbEZbrdW3fLif2k43shHgscE2Xll8Hy0Se2o,8607
+include/py-d4-standard/FormulaStore.hpp,sha256=KQ5juBTCoW3SB526Kl9EOj2C4Sow8Zjj-7S6pkWJVU0,1749
+include/py-d4-standard/FormulaStoreCnf.hpp,sha256=UlEXsJreyEAs0_nNAeS-naWKrTw1QTvqKwWXJVMdPqo,2859
+include/py-d4-standard/FormulaStoreCnfCl.hpp,sha256=V26drLeC_Y0J4HFYTCEeD_zrObV1xyscxldXAr9eV88,3315
+include/py-d4-standard/FormulaStoreCnfCombi.hpp,sha256=ZWAuEsnTusJodAnJr-vz1x7m1BWCnHOs6Iplgt7AZBg,1776
+include/py-d4-standard/FormulaStoreCnfIndex.hpp,sha256=wIBWf2hb2-QUi0izwJ9A3ds_Xf55pbvi7ydh9L3nhXU,1402
+include/py-d4-standard/FormulaStoreCnfSym.hpp,sha256=gIFTMgssPyVfL5ShC9Lj45sdaMgWyJe0uC4HCFVgT2c,3332
+include/py-d4-standard/Graph.hpp,sha256=W7MTqFifdp_q-puI7q_rAcJ4-HP19GqT2wlU_DJUFOQ,2255
+include/py-d4-standard/GraphExtractor.hpp,sha256=F44x3yp3hPvGCrT3Emvfy6lR21AL9XPSbeRQDbRLwQc,2375
+include/py-d4-standard/GraphExtractorCircuit.hpp,sha256=mfg5Md-nDt6lgIi8FcLfoOV7yTMPwgXAOL1lgP-PrQM,1490
+include/py-d4-standard/GraphExtractorCircuitPrimal.hpp,sha256=LPEjNWowKVpI1lNOxjFIzbW2JI_UfZQh4WDT3QMg3FU,1600
+include/py-d4-standard/GraphExtractorCnf.hpp,sha256=oNFgOtxB-PV7rhceLRN1P1scTZApLldU5ljYS0rAjTI,1758
+include/py-d4-standard/GraphExtractorCnfPrimal.hpp,sha256=46IBfq7ZIugW7aKAfP2YtcxoTr8XSOjyv5Kae38kM74,1624
+include/py-d4-standard/HashString.hpp,sha256=184OHOPaPpEb0WlRCiI9ZLzZADR8xEdZVIgNCYYtQJ8,1308
+include/py-d4-standard/Heap.hpp,sha256=tEO0n-apfBIwe3dl-TQutYcvyhX0xFxm7fkHU7ae57M,4393
+include/py-d4-standard/HyperEdge.hpp,sha256=3UZp9x3a796mskBb7L-BBvfpnwPgIypk1S8RaBTDNrc,1627
+include/py-d4-standard/HyperGraph.hpp,sha256=_BlATkbT-aDF8bxTSyF_AxVHZfP06lkaYiKeaWtZDXQ,2065
+include/py-d4-standard/HyperGraphExtractor.hpp,sha256=xinijZPrvWOA1q-nEmKcB2Khnl1a28WxjqVuHs0pCJ0,3328
+include/py-d4-standard/HyperGraphExtractorCnfDual.hpp,sha256=LG7srBdmDzT4tOsleaXvnj5T741jndvTBBhjXPs2yMc,2572
+include/py-d4-standard/IntTypes.hpp,sha256=rp4L4FnXIF0PCHTSyUjMn2gJannfn6-TTUeWx8EqokY,1822
+include/py-d4-standard/Map.hpp,sha256=djMy3z-S_QcYJBA9GlNSDfHndqM7ZaBfMLsqn8npi0A,6432
+include/py-d4-standard/MaxSharpSAT.hpp,sha256=sRiIcAUtoIhJQhR0B8WR1c62GtrsWkXFJTcQrOKXttk,32916
+include/py-d4-standard/MaxT.hpp,sha256=F8Vytd9KDIhmN5SaX8GF2okIMsHPHcnw2jIMfpeK4wg,32268
+include/py-d4-standard/MemoryStat.hpp,sha256=INDSVTnyX0WnAT3-zmsmiUvlt6vztIo4gx0oEzHbcRo,3959
+include/py-d4-standard/MethodManager.hpp,sha256=AoMDJWeJ70XgvNIgY1ODgzzVCvz9QXSAdiTpRhKBaWc,2159
+include/py-d4-standard/MinSharpSAT.hpp,sha256=p9NkcJlWoW_R2dN26N-j2A-mvc1OVjBEU1tBp5emdtw,22359
+include/py-d4-standard/MpzTypes.hpp,sha256=kKxUOeNzTyYTPImoGupoOLdK3Cwc18GxfbAqBlax3Qg,1320
+include/py-d4-standard/NodeException.hpp,sha256=-HKw7aYd2LFidf3paXU9l0PgxQ5vTlI5kqhe9zttd3A,1516
+include/py-d4-standard/Option.hpp,sha256=FSTJovYcWFt2-CVR_LiWSgGcQGnIr521YmRI0nrQrzE,162
+include/py-d4-standard/OptionBase.hpp,sha256=Noq-qKUHX9_18LpAQfnDVKOB1vQdM1IwNQm6rCBv0YI,157
+include/py-d4-standard/OptionBranchingHeuristic.hpp,sha256=2QoE5tzEatQIBsa_XzFum_yJMl1Y0weJYHK1VRzubLM,5257
+include/py-d4-standard/OptionBucketManager.hpp,sha256=AYqqmiGIRSoK-A0on2ge2rcqqeerw4hOT9iE_bMybKc,3239
+include/py-d4-standard/OptionCacheCleaningManager.hpp,sha256=XCfZ9qAgrOa3jgXXAl_lQSIOUFHtMTfmWigZ4rr1Qiw,1449
+include/py-d4-standard/OptionCacheManager.hpp,sha256=vzwaODXQfmCiPiU3FqM-R676syHhmic9_SMBPC8IHzA,1844
+include/py-d4-standard/OptionDpllStyleMethod.hpp,sha256=rE1dv-LNPcAOtC_QvGnu_vthSlAZEE0J73cojMDvTfs,3330
+include/py-d4-standard/OptionEREMethod.hpp,sha256=FI1Nn1pUobzzbSoYx8WAloWZrOrd5lHeoJbbRaFT3kk,4513
+include/py-d4-standard/OptionException.hpp,sha256=Ma4Kfqud0N_DTl1E2JoUwamh3FsU_PUnpUtY_McfbsQ,1520
+include/py-d4-standard/OptionFormulaManager.hpp,sha256=0VfBxB4NJ6I_TmBzyxvHR29HyNWA4iaYVxFaiYaPf_c,3130
+include/py-d4-standard/OptionGroup.hpp,sha256=3-5iWWj5pPklYlK54YTSj6SBME44UUTGyB2gaXjQVl4,186
+include/py-d4-standard/OptionMaxSharpSatMethod.hpp,sha256=EIfkYB10zbPmGG9oR-33r7DARflFyk9UYjzDBp5Lzxk,3493
+include/py-d4-standard/OptionMaxTMethod.hpp,sha256=Kz2DlUdfkBPK95mIT0fdx8rgq4Yfnzzdi7Kyrlz9WlI,3865
+include/py-d4-standard/OptionMethodManager.hpp,sha256=I8dFLyJQwcTfzL543_ukIkVJsSnW9-fGFdtzMv1HQ5I,1236
+include/py-d4-standard/OptionMinSharpSatMethod.hpp,sha256=Wr78T3-ZsOO-NgiRMTDmZ8q42KVDL6gK8UstruSpK2k,3493
+include/py-d4-standard/OptionOperationManager.hpp,sha256=F5KqzWitpTjnYmqR7e06bgbo4h9nSrucxU81e7_Crh4,2229
+include/py-d4-standard/OptionPartialOrderHeuristic.hpp,sha256=OWSMvjtOePLpFHNKQjyM7e0zUnYsIUuJ0TecPVYNl_Y,5438
+include/py-d4-standard/OptionProjMcMethod.hpp,sha256=RjXzIFXkiU6vG_Aid5CpFPzT-YuMN9wvXdTt3Ar_pYw,2611
+include/py-d4-standard/OptionQbfCounter.hpp,sha256=R1fREn-9PV00pbGO7CaKy3Tw3BPYCyF4vcD1yYulXVE,2541
+include/py-d4-standard/OptionRegistry.hpp,sha256=WdXMr7uP8a0E6bKxMKOqDLyYxMHAST9iYVxD23P3YWs,160
+include/py-d4-standard/OptionRoot.hpp,sha256=LPvj1ck1YH7gO5xElmiY6LiEBNTfGNWQGdDQvwaCI9s,1303
+include/py-d4-standard/Options.hpp,sha256=I_b4LnX4nn-RhNTN1hK6rHoP-Gs0gQYGiULDzSO40YA,12374
+include/py-d4-standard/OptionSolver.hpp,sha256=3H-ItLpSU8nVkS8L6DrX1tMA-X7G3Su4nG2k_3MVl_I,3024
+include/py-d4-standard/ParserException.hpp,sha256=Pq0aIdRlJsfIM7p6PVqz-NmUALxaMWCyEH_PBSYC8jM,1520
+include/py-d4-standard/PartialOrderHeuristic.hpp,sha256=-1CaLEjXOeoTsPSO5Q2hc5NcwJ0kutu3VfVAvOGcBpA,2358
+include/py-d4-standard/PartialOrderHeuristicGiven.hpp,sha256=F4HIjqNvRjSFKwFaOegLpWDrbU6S78Iax3Gml91RAuw,2060
+include/py-d4-standard/PartialOrderHeuristicNone.hpp,sha256=OS1P1voQVTsJskCT5MCYlSohxmAvkI8EBGh5lQOWvHs,1147
+include/py-d4-standard/PartialOrderHeuristicTreeDecomp.hpp,sha256=fVz-7wJgrhQu1hxpfc7dSaJNiCXEPtCOeJecg66w9AE,2363
+include/py-d4-standard/PartitionerManager.hpp,sha256=CCtQYV-8nz4AiUXPmKdWSO1yWSPKvJGvB72Zv06h7g0,2490
+include/py-d4-standard/PartitionerPatoh.hpp,sha256=VvrOUQiKe8bZL4ReRS5r1r3wQMIrGApEQTdos3mxZDI,1399
+include/py-d4-standard/PhaseHeuristic.hpp,sha256=gztbRmeiCsPOGenRwBNRgDmEPUKey60ouiCPN9mTqcI,1373
+include/py-d4-standard/PhaseHeuristicFalse.hpp,sha256=VX2_VB_TzbTUzfopPtSXQ2-nNdjYxjlTnmWNHuYSNik,1020
+include/py-d4-standard/PhaseHeuristicOccurrence.hpp,sha256=JLkf3v5KEx3lliHZZFTx_-Lqw-ZXImYdqLX1B4ogLcA,1129
+include/py-d4-standard/PhaseHeuristicPolarity.hpp,sha256=hOG0C_S4S6ujPrped7nuSFOrFJfOGem6bmeobzUqgHg,1131
+include/py-d4-standard/PhaseHeuristicTrue.hpp,sha256=7ZWEERzjTzU4sxoEVycKcWPWTwo8k54_5LgF9iJG1qs,1018
+include/py-d4-standard/PolarityManager.hpp,sha256=00bUg_nPrTqyjzF2Cpr0JVuciHIYdRxf1e455vRJecg,1025
+include/py-d4-standard/ProblemManager.hpp,sha256=jdPGxsKI6bYm4XVmlaghtzJyk_P7IWgkqDXzFjaDDbc,10423
+include/py-d4-standard/ProblemTypes.hpp,sha256=HClFvOxD_tUvuukoSl6H78GcdkCgwVEGtDOysY5FqOc,4210
+include/py-d4-standard/ProjMCMethod.hpp,sha256=UdjT0YnLBPmR9_OOvqi3apkSZ_ze6R2LCr0Zl-oh25Y,25189
+include/py-d4-standard/QbfCounter.hpp,sha256=hdaTsHv4OeGmbQmHgC1eFDAWKpyaSo1rHZKgCNSoRH8,17340
+include/py-d4-standard/Queue.hpp,sha256=PE0weHDKiM7ECXn3f-3J9KmdQ925XbPYQ-2uotsnrik,2820
+include/py-d4-standard/ScoringMethod.hpp,sha256=CnpJa5aNNnmpRlcMmfXuPmPPKqzHopjsVOvS7fdF1OU,1930
+include/py-d4-standard/ScoringMethodDlcs.hpp,sha256=bco2fD3hvatA__3tX1Bs6ywjRlS_DKOy7cbguloNzHo,1110
+include/py-d4-standard/ScoringMethodJwts.hpp,sha256=0zhLbqGquTiXgzJiJWpi-ZvAg5sU5_a1mm0JzAaTAeU,1103
+include/py-d4-standard/ScoringMethodMom.hpp,sha256=l-9r-OrYLy7rZzpPm2gcLy58lKG68NLJQY8jXbyhXwI,1101
+include/py-d4-standard/ScoringMethodVsads.hpp,sha256=7RF03VdvEgNfv8MA7MCzxZizaNKCgnT65gNMpMdPhh0,1271
+include/py-d4-standard/ScoringMethodVsids.hpp,sha256=gfBE5ENhLkOowIcST9PIAreueZ2DW0O87ck1IKxtl6U,1114
+include/py-d4-standard/SemiringConcept.hpp,sha256=qbT5fme3e88PsZgPEThbA7wjYR8Aw8ad3M0oARxe3kM,2109
+include/py-d4-standard/Solver.hpp,sha256=qsq19XbNbCsC5MxM7g8srj0XxP1uV22rX4ZTBMYtqnU,33332
+include/py-d4-standard/SolverTypes.hpp,sha256=WQ2aRJneZXExl6FBzEPGzd4xb5-C_u_528OWOSDyWyY,18271
+include/py-d4-standard/Sort.hpp,sha256=rbFFyDEftORUAlxQcl8eDkRdAyWzeOddwspG4unxpjE,3256
+include/py-d4-standard/TmpEntry.hpp,sha256=WakVF552gZ09cWpbNR5zHQhTIHS7ryxceqFrc4e2Fl4,1429
+include/py-d4-standard/Translator.hpp,sha256=177kT_1t-je5kFmcamxN9POOFI4LqxeN0Tnl_IQpeSg,3933
+include/py-d4-standard/TreeDecomposition.hpp,sha256=TYlSxQeYlTu9De4OI0RZVksIJsSPQCHvUBt2eiBjiFo,8439
+include/py-d4-standard/TreeDecompositioner.hpp,sha256=wajefw0ovBWD0lbM9U0m9cJjBsIia6qr-pBTbdk46f4,2595
+include/py-d4-standard/TreeDecompositionerFlowCutter.hpp,sha256=qL_Q-xpc2FchmEGj5QyOwduIONJ6Fy2f-Tnt-fNkTDM,2641
+include/py-d4-standard/TreeDecompositionerHtd.hpp,sha256=5j-fSDFal8Ic2pZ0j9l-hqmj9TVRAH8xPIm3aaILAg8,2132
+include/py-d4-standard/TreeDecompositionPartition.hpp,sha256=ITvFhbOn5dDBb1V0JbDNys4dUlDoJ_fpjh--xFids1A,2085
+include/py-d4-standard/TreeDecompositionTreeWidth.hpp,sha256=Ue5FvTnB1axEifYxQwRvT2hZHl38ZZYKFisz7VO7cZU,2707
+include/py-d4-standard/Vec.hpp,sha256=Va2bvRjJVXTi-Vtx8i-NF1zWIm5bJdr5ngfYQbVsh-0,6142
+include/py-d4-standard/WrapperCircuitGlucose.hpp,sha256=Yff3MDladmLDavZN4byvlUvMO_-MWhoaw-CfxdKaWQA,1199
+include/py-d4-standard/WrapperCircuitMinisat.hpp,sha256=XFMS_ykEwS54nN2R-5tT6eJqtzv3-yzVaVC_N_4rnWA,1100
+include/py-d4-standard/WrapperGlucose.hpp,sha256=O2K4PiLbHeX94wuYzmxSVnsIkhBjkfeWKOU-WbqPu4E,2938
+include/py-d4-standard/WrapperMinisat.hpp,sha256=tq2EwPGgcKwJQWYlrSP3wYBweRDt3SbdtaHoPu9447I,2834
+include/py-d4-standard/WrapperSolver.hpp,sha256=VWdU7GgU0w1qy9l9qG1NsGW8NltE-Fo305c8trWlnj8,4096
+include/py-d4-standard/XAlloc.hpp,sha256=TkB4MQ5-tXy_kndbHmFZe-B_xUzI1dRkXW2hqmYHTJg,1849
+lib/d4.lib,sha256=avBKq6-DZLZmASgie12i1TFIkTNHfVRKcgBKFtn4MKY,22601752
+lib/__init__.py,sha256=Zn0lfL13i8oze3nyGmRZW32A6pVMT0F9HDKZQBZNc28,1570
+py_d4/options.py,sha256=Xddsss_a2Y_2AjFeYCG_XCGhxLyhCqgG-GtS0X1LinE,876
+py_d4/py.typed,sha256=V-lflWeK996Wlw7bjhCkJEcQU9mOk2QXj4MnZmQ7oMU,75
+py_d4/_py_d4.cp39-win_amd64.pyd,sha256=fJ-q6PDLTYdEJQwlZYekFGcECRM38GNM9D_gFvU9XnM,2475520
+py_d4/_py_d4.pyi,sha256=TZJfa4wSxc5M8hafEgn8SrWhg6xw6r8NPNvA317BWWM,15649
+py_d4/__init__.py,sha256=0ps6w6KQ3qlcUid0heTHx4oSVHCLnrmFKgtkk2IuBY0,3264
+share/__init__.py,sha256=Zn0lfL13i8oze3nyGmRZW32A6pVMT0F9HDKZQBZNc28,1570
+share/cmake/optree/optreeConfig.cmake,sha256=uRZTbyFByBz61hBlGtCt7M-bvQxibVqDjRHWuMEhauA,58
+share/cmake/optree/optreeConfigVersion.cmake,sha256=wrWvwXUoWsHZLhxkVa5C6bH6n4gMev3yLcWv7f5jNBw,2827
+share/cmake/optree/optreeTargets.cmake,sha256=U_QCD-4bKcT_5ANleMWpTkMHUJ9usj-q76kuX1L-ClI,4164

d4solver-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 1.0.3
+Root-Is-Purelib: false
+Tag: cp39-cp39-win_amd64
+

d4solver.libs/.load-order-d4solver-0.1.0

@@ -0,0 +1,3 @@
+msvcp140-484f56d9de72c048820300919dc49e56.dll
+gmp-10-521f5d57a531da7f2ddd75a64634bf47.dll
+gmpxx-4-1aec0d72b737c81b6397e2967c9be349.dll

include/__init__.py

@@ -0,0 +1,29 @@
+"""""" # start delvewheel patch
+def _delvewheel_patch_1_13_0():
+    import ctypes
+    import os
+    import platform
+    import sys
+    libs_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'd4solver.libs'))
+    is_conda_cpython = platform.python_implementation() == 'CPython' and (hasattr(ctypes.pythonapi, 'Anaconda_GetVersion') or 'packaged by conda-forge' in sys.version)
+    if sys.version_info[:2] >= (3, 8) and not is_conda_cpython or sys.version_info[:2] >= (3, 10):
+        if os.path.isdir(libs_dir):
+            os.add_dll_directory(libs_dir)
+    else:
+        load_order_filepath = os.path.join(libs_dir, '.load-order-d4solver-0.1.0')
+        if os.path.isfile(load_order_filepath):
+            import ctypes.wintypes
+            with open(os.path.join(libs_dir, '.load-order-d4solver-0.1.0')) as file:
+                load_order = file.read().split()
+            kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+            kernel32.LoadLibraryExW.restype = ctypes.wintypes.HMODULE
+            kernel32.LoadLibraryExW.argtypes = ctypes.wintypes.LPCWSTR, ctypes.wintypes.HANDLE, ctypes.wintypes.DWORD
+            for lib in load_order:
+                lib_path = os.path.join(os.path.join(libs_dir, lib))
+                if os.path.isfile(lib_path) and not kernel32.LoadLibraryExW(lib_path, None, 8):
+                    raise OSError('Error loading {}; {}'.format(lib, ctypes.FormatError(ctypes.get_last_error())))
+
+
+_delvewheel_patch_1_13_0()
+del _delvewheel_patch_1_13_0
+# end delvewheel patch

include/optree/EnumMetadata.hpp

@@ -0,0 +1,63 @@
+#pragma once
+#include <string>
+#include <map>
+#include <stdexcept>
+
+namespace optree {
+
+/**
+ * @brief Trait to provide metadata about enums.
+ * Specialize this template in your project to support custom enums.
+ */
+template<typename EnumType, typename Dummy = void>
+struct EnumMetadata {
+    static std::map<int, std::string> mapping() { return {}; }
+    static std::string name() { return "UnknownEnum"; }
+};
+
+/**
+ * @brief Helper to resolve an enum value from its string label.
+ */
+template<typename EnumType>
+inline EnumType resolve_enum(const std::string& label) {
+    auto m = EnumMetadata<EnumType>::mapping();
+    for (auto const& [val, str] : m) {
+        if (str == label) {
+            return static_cast<EnumType>(val);
+        }
+    }
+    // Fallback to integer conversion if it's a numeric string
+    try {
+        return static_cast<EnumType>(std::stoi(label));
+    } catch (...) {}
+    throw std::runtime_error("Unknown enum label: " + label + " for enum: " + EnumMetadata<EnumType>::name());
+}
+
+/**
+ * @brief Helper to convert an enum value to its string label.
+ */
+template<typename EnumType>
+inline std::string enum_to_string(const EnumType& val) {
+    auto m = EnumMetadata<EnumType>::mapping();
+    auto it = m.find(static_cast<int>(val));
+    if (it != m.end()) {
+        return it->second;
+    }
+    return std::to_string(static_cast<int>(val));
+}
+
+/**
+ * @brief Helper to generate a documentation string for an enum.
+ */
+template<typename EnumType>
+inline std::string get_enum_doc() {
+    auto m = EnumMetadata<EnumType>::mapping();
+    std::string doc = "";
+    for (auto const& [val, label] : m) {
+        if (!doc.empty()) doc += ", ";
+        doc += std::to_string(val) + "=" + label;
+    }
+    return doc;
+}
+
+} // namespace optree