towards good

Author: Markus Iser

MANIFEST.in

@@ -5,4 +5,5 @@ include gbd_server/static/img/*.png
 include gbd_server/static/img/*.jpg
 include gbd_server/static/*.css
 include gbd_server/static/*.js
+include default_config.toml
 

default_config.toml

@@ -0,0 +1,12 @@
+[contexts]
+default = "cnf"
+cnf = { suffix = ".cnf", idfunc = "cnf_hash", description = "DIMACS Conjunctive Normal Form (CNF)" }
+sancnf = { suffix = ".sanitized.cnf", idfunc = "cnf_hash", description = "Sanitized CNF" }
+kis = { suffix = ".kis", idfunc = "cnf_hash", description = "k-Independent Set Problem Graph" }
+opb = { suffix = ".opb", idfunc = "opb_hash", description = "Pseudo-Boolean Optimization Problem" }
+wcnf = { suffix = ".wcnf", idfunc = "wcnf_hash", description = "Weighted CNF (WCNF)" }
+wecnf = { suffix = ".wecnf", idfunc = "cnf_hash", description = "Weighted Extended CNF (WECNF)" }
+
+[transformers]
+
+[extractors]

gbd_core/config.py

@@ -0,0 +1,39 @@
+import toml
+import os
+import importlib.resources as pkg_resources
+
+### Default Context
+default = "cnf"
+
+### Load Configuration from Files
+def load_config(default_config_path, user_config_path=None):
+    # Load the default configuration file
+    with pkg_resources.open_text('gbd_tools', default_config_path) as f:
+        config = toml.load(f)
+    
+    # If a user configuration file is provided, load it and update the config
+    if user_config_path and os.path.exists(user_config_path):
+        with open(user_config_path, 'r') as f:
+            user_config = toml.load(f)
+        config.update(user_config)
+    
+    return config
+
+### Convert ConfigParser to Dictionary
+def config_to_dict(config):
+    config_dict = {}
+    for context, details in config['contexts'].items():
+        config_dict[context] = {
+            "description": details["description"],
+            "suffix": details["suffix"],
+            "idfunc": globals()[details["idfunc"]],
+        }
+    return config_dict
+
+### Paths to Configuration Files
+default_config_path = "default_config.toml"
+user_config_path = "user_config.toml"  # Adjust this path as needed
+
+### Load and Convert Configuration
+config_parser = load_config(default_config_path, user_config_path)
+config = config_to_dict(config_parser)

gbd_core/contexts.py

@@ -56,8 +56,7 @@ def description(context):
     return config[context]['description']
 
 def suffixes(context):
-    packed = [ "", ".gz", ".lzma", ".xz", ".bz2" ]
-    return [ config[context]['suffix'] + p for p in packed ]
+    return [ config[context]['suffix'] + p for p in [ "", ".gz", ".lzma", ".xz", ".bz2" ] ]
 
 def idfunc(context):
     return config[context]['idfunc']

gbd_init/feature_extractors.py

@@ -23,12 +23,9 @@
 from gbd_core.util import eprint, confirm
 from gbd_init.initializer import Initializer, InitializerException
 
-gbdc_available = True
 try:
-    from gbdc import extract_base_features, base_feature_names, extract_gate_features, gate_feature_names, isohash, wcnfisohash, wcnf_base_feature_names, extract_wcnf_base_features, opb_base_feature_names, extract_opb_base_features
+    from gbdc import extract_base_features, base_feature_names, extract_gate_features, gate_feature_names, isohash, wcnfisohash, wcnf_base_feature_names, extract_wcnf_base_features, opb_base_feature_names, extract_opb_base_features, checksani, checksani_feature_names
 except ImportError:
-    gbdc_available = False
-    warnings.warn("gbdc not found. Please install using 'pip install gbdc'.")
     def extract_base_features(path, tlim, mlim):
         raise ModuleNotFoundError("gbdc not found", name="gbdc")
 
@@ -55,6 +52,12 @@ def extract_opb_base_features(path, tlim, mlim):
 
     def opb_base_feature_names():
         return [ ]
+    
+    def checksani(path, tlim, mlim):
+        raise ModuleNotFoundError("gbdc not found", name="gbdc")
+    
+    def checksani_feature_names():
+        return [ ]
 
 ## GBDHash
 def compute_hash(hash, path, limits):
@@ -96,23 +99,35 @@ def compute_opb_base_features(hash, path, limits, tp=None):
     rec = extract_opb_base_features(path, limits['tlim'], limits['mlim'])
     return [ (key, hash, int(value) if isinstance(value, float) and value.is_integer() else value) for key, value in rec.items() ]
 
+## SANI Features
+def compute_sani_features(hash, path, limits, tp=None):
+    eprint('Extracting SANI features from {} {}'.format(hash, path))
+    rec = checksani(path, limits['tlim'], limits['mlim'])
+    return [ (key, hash, int(value) if isinstance(value, float) and value.is_integer() else value) for key, value in rec.items() ]
+
 
 generic_extractors = {
     "base" : {
         "description" : "Extract base features from CNF files. ",
-        "contexts" : [ "cnf" ],
+        "contexts" : [ "cnf", "sancnf" ],
         "features" : [ (name, "empty") for name in base_feature_names() ],
         "compute" : compute_base_features,
     },
+    "checksani" : {
+        "description" : "Extract sanitise status from CNF files. ",
+        "contexts" : [ "cnf", "sancnf" ],
+        "features" : [ (name, "empty") for name in checksani_feature_names() ],
+        "compute" : compute_sani_features,
+    },
     "gate" : {
         "description" : "Extract gate features from CNF files. ",
-        "contexts" : [ "cnf" ],
+        "contexts" : [ "cnf", "sancnf" ],
         "features" : [ (name, "empty") for name in gate_feature_names() ],
         "compute" : compute_gate_features,
     },
     "isohash" : {
         "description" : "Compute ISOHash for CNF or WCNF files. ",
-        "contexts" : [ "cnf", "wcnf" ],
+        "contexts" : [ "cnf", "wcnf", "sancnf" ],
         "features" : [ ("isohash", "empty") ],
         "compute" : compute_isohash,
     },

gbd_init/instance_transformers.py

@@ -25,31 +25,36 @@
 from gbd_init.initializer import Initializer, InitializerException
 
 try:
-    from gbdc import cnf2kis, sanitize
+    from gbdc import cnf2kis, sanitise, normalise
 except ImportError:
-    def cnf2kis(ipath, opath, maxedges, maxnodes, tlim, mlim, flim):
+    def cnf2kis(ipath, opath):
         raise ModuleNotFoundError("gbdc not found", name="gbdc")
 
-    def sanitize(ipath, tlim, mlim):
+    def sanitise(ipath, opath):
+        raise ModuleNotFoundError("gbdc not found", name="gbdc")
+    
+    def normalise(ipath, opath):
         raise ModuleNotFoundError("gbdc not found", name="gbdc")
 
 
-# Transform SAT Problem to k-Independent Set Problem
 def kis_filename(path):
     kispath = reduce(lambda path, suffix: path[:-len(suffix)] if path.endswith(suffix) else path, contexts.suffixes('cnf'), path)
     return kispath + '.kis'
 
-# Sanitize CNF
-def sanitized_filename(path):
+def sanitised_filename(path):
     sanpath = reduce(lambda path, suffix: path[:-len(suffix)] if path.endswith(suffix) else path, contexts.suffixes('cnf'), path)
     return sanpath + '.sanitized.cnf'
 
+def normalised_filename(path):
+    normpath = reduce(lambda path, suffix: path[:-len(suffix)] if path.endswith(suffix) else path, contexts.suffixes('cnf'), path)
+    return normpath + '.normalised.cnf'
+
 
 def wrap_cnf2kis(hash, path, limits):
     kispath = kis_filename(path)
     util.eprint('Transforming {} to k-ISP {}'.format(path, kispath))
     try:
-        result = cnf2kis(path, kispath, 2**32, 2**32, limits['tlim'], limits['mlim'], limits['flim'])
+        result = cnf2kis(path, kispath)
         if "local" in result:
             kishash = result['hash']
             return [ ('local', kishash, result['local']), ('to_cnf', kishash, hash),
@@ -63,20 +68,39 @@ def wrap_cnf2kis(hash, path, limits):
 
     return [ ]
 
-def wrap_sanitize(hash, path, limits):
-    sanname = sanitized_filename(path)
-    util.eprint('Sanitizing {}'.format(path))
+def wrap_sanitise(hash, path, limits):
+    sanpath = sanitised_filename(path)
+    util.eprint('Sanitising {}'.format(path))
     try:
-        with open(sanname, 'w') as f, util.stdout_redirected(f):
-            if sanitize(path): 
-                sanhash = identify(sanname)
-                return [ ('local', sanhash, sanname), ('to_cnf', sanhash, hash) ]
+        with open(sanpath, 'w') as f, util.stdout_redirected(f):
+            result = sanitise(path, sanpath)
+            if "local" in result:
+                sanhash = result['hash']
+                return [ ('local', sanhash, result['local']), ('to_cnf', sanhash, hash) ]
             else:
                 raise GBDException("Sanitization failed for {}".format(path))
     except Exception as e:
         util.eprint(str(e))
-        if os.path.exists(sanname):
-            os.remove(sanname)
+        if os.path.exists(sanpath):
+            os.remove(sanpath)
+
+    return [ ]
+
+def wrap_normalise(hash, path, limits):
+    normpath = normalised_filename(path)
+    util.eprint('Normalising {}'.format(path))
+    try:
+        with open(normpath, 'w') as f, util.stdout_redirected(f):
+            result = normalise(path, normpath)
+            normhash = result['hash']
+            if "local" in result and hash == normhash:
+                return [ ('local', normhash, result['local']) ]
+            else:
+                raise GBDException("Normalisation failed for {}".format(path))
+    except Exception as e:
+        util.eprint(str(e))
+        if os.path.exists(normpath):
+            os.remove(normpath)
 
     return [ ]
 
@@ -98,13 +122,21 @@ def transform_instances_generic(key: str, api: GBD, rlimits, query, hashes, targ
 
 
 generic_transformers = {
-    "sanitize" : {
-        "description" : "Sanitize CNF files. ",
+    "sanitise" : {
+        "description" : "Sanitise CNF files. ",
         "source" : [ "cnf" ],
         "target" : [ "sancnf" ],
         "features" : [ ('local', None) , ('to_cnf', None) ],
-        "compute" : wrap_sanitize,
-        "filename" : sanitized_filename,
+        "compute" : wrap_sanitise,
+        "filename" : sanitised_filename,
+    },
+    "normalise" : {
+        "description" : "Normalise CNF files. ",
+        "source" : [ "cnf" ],
+        "target" : [ "cnf" ],
+        "features" : [ ('local', None) ],
+        "compute" : wrap_normalise,
+        "filename" : normalised_filename,
     },
     "cnf2kis" : {
         "description" : "Transform CNF files to k-ISP instances. ",

pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gbd_tools"
+version = "4.9.7"
+description = "GBD Tools: Maintenance and Distribution of Benchmark Instances and their Attributes"
+readme = "README.md"
+requires-python = ">=3.6"
+license = { text = "MIT License" }
+authors = [
+    { name = "Markus Iser", email = "markus.iser@kit.edu" }
+]
+urls = { Homepage = "https://github.com/Udopia/gbd" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3"
+]
+dependencies = [
+    "flask",
+    "tatsu",
+    "pandas",
+    "waitress",
+    "pebble",
+    "gbdc"
+]
+scripts = { gbd = "gbd:main" }
+
+[tool.setuptools.packages.find]
+where = ["gbd_core", "gbd_init", "gbd_server"]
+
+[tool.setuptools]
+include-package-data = true

setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 setup(name='gbd_tools',
-  version='4.9.7',
+  version='4.9.8',
   description='GBD Tools: Maintenance and Distribution of Benchmark Instances and their Attributes',
   long_description=open('README.md', 'rt').read(),
   long_description_content_type="text/markdown",

update_tool.sh

@@ -1,4 +1,7 @@
 sudo rm -rf dist/
-sudo python3 setup.py develop sdist bdist_wheel
+# sudo python3 setup.py develop sdist bdist_wheel
+# twine upload dist/*
+sudo python3 -m pip install --upgrade build twine
+sudo python3 -m build
 twine upload dist/*
 sudo rm -Rf gbd_tools.egg-info dist build