Using prebuilt scenarios

Author: yasserfarouk

src/negmas/gb/components/acceptance.py

@@ -244,7 +244,10 @@ class ACLast(AcceptancePolicy):
     alpha: float = 1.0
     beta: float = 0.0
 
-    def after_proposing(self, state: GBState, offer: Outcome | None):
+    def after_proposing(
+        self, state: GBState, offer: Outcome | None, dest: str | None = None
+    ):
+        return super().after_proposing(state, offer, dest)
         if not self.negotiator or not self.negotiator.ufun:
             return
         self.last_offer_util = float(self.negotiator.ufun(offer))
@@ -267,9 +270,15 @@ class AcceptBetween(AcceptancePolicy):
 
     min: float
     max: float = 1.0
+    rational: bool = True
 
     def __call__(self, state, offer, source):
-        if self.max >= state.relative_time >= self.min:
+        if self.max >= state.relative_time >= self.min and (
+            not self.rational
+            or self.negotiator.ufun.is_not_worse(  # type: ignore
+                offer, None
+            )
+        ):
             return ResponseType.ACCEPT_OFFER
         return ResponseType.REJECT_OFFER
 
@@ -283,9 +292,15 @@ class ACTime(AcceptancePolicy):
     """
 
     tau: float
+    rational: bool = True
 
     def __call__(self, state, offer, source):
-        if state.relative_time >= self.tau:
+        if state.relative_time >= self.tau and (
+            not self.rational
+            or self.negotiator.ufun.is_not_worse(  # type: ignore
+                offer, None
+            )
+        ):
             return ResponseType.ACCEPT_OFFER
         return ResponseType.REJECT_OFFER
 

src/negmas/inout.py

@@ -454,9 +454,7 @@ def calc_extra_stats(
             bilateral_frontier_outcomes=fo,
         )
 
-    def serialize(
-        self, python_class_identifier=PYTHON_CLASS_IDENTIFIER
-    ) -> dict[str, Any]:
+    def serialize(self) -> dict[str, Any]:
         """
         Converts the current scenario into a serializable dict.
 
@@ -488,7 +486,7 @@ def adjust(
                 return d
             if adjust_name and "name" in d:
                 d["name"] = get_name(d["name"], default_name)
-            if d.get(PYTHON_CLASS_IDENTIFIER, "").startswith("negmas."):
+            if d.get(PYTHON_CLASS_IDENTIFIER, "").startswith("negobench."):
                 d[PYTHON_CLASS_IDENTIFIER] = d[PYTHON_CLASS_IDENTIFIER].split(".")[-1]
             for old, new in rename.items():
                 if old in d.keys():
@@ -512,23 +510,12 @@ def adjust(
 
         domain = adjust(
             serialize(
-                self.outcome_space,
-                shorten_type_field=True,
-                add_type_field=True,
-                python_class_identifier=python_class_identifier,
+                self.outcome_space, shorten_type_field=False, add_type_field=True
             ),
             "domain",
         )
         ufuns = [
-            adjust(
-                serialize(
-                    u,
-                    shorten_type_field=True,
-                    add_type_field=True,
-                    python_class_identifier=python_class_identifier,
-                ),
-                i,
-            )
+            adjust(serialize(u, shorten_type_field=False, add_type_field=True), i)
             for i, u in enumerate(self.ufuns)
         ]
         return dict(domain=domain, ufuns=ufuns)
@@ -549,22 +536,23 @@ def to_json(self, folder: Path | str) -> None:
         """
         self.dumpas(folder, "json")
 
-    def dumpas(
-        self,
-        folder: Path | str,
-        type="yml",
-        compact: bool = False,
-        python_class_identifier=PYTHON_CLASS_IDENTIFIER,
-    ) -> None:
+    def dumpas(self, folder: Path | str, type="yml", compact: bool = False) -> None:
         """
         Dumps the scenario in the given file format.
         """
+        if type.startswith("."):
+            type = type[1:]
         folder = Path(folder)
+        if type == "xml":
+            self.to_genius_folder(folder)
+            return
         folder.mkdir(parents=True, exist_ok=True)
-        serialized = self.serialize(python_class_identifier=python_class_identifier)
+        serialized = self.serialize()
         dump(serialized["domain"], folder / f"{serialized['domain']['name']}.{type}")
         for u in serialized["ufuns"]:
             dump(u, folder / f"{u['name']}.{type}", sort_keys=True, compact=compact)
+        if self.info:
+            dump(self.info, folder / f"{INFO_FILE_NAME}.{type}")
 
     def load_info_file(self, file: Path):
         if not file.is_file():
@@ -740,7 +728,8 @@ def from_yaml_files(
         _ = safe_parsing  # yaml parsing is always safe
 
         def adjust_type(d: dict, base: str = "negmas", domain=None) -> dict:
-            d["type"] = f"{base}.{d['type']}"
+            if "." not in d["type"]:
+                d["type"] = f"{base}.{d['type']}"
             if domain is not None:
                 d["outcome_space"] = domain
             return d
@@ -855,7 +844,7 @@ def load_genius_domain(
                 safe_parsing=safe_parsing,
                 ignore_discount=ignore_discount,
                 ignore_reserved=ignore_reserved,
-                name=str(ufname),
+                name=Path(ufname).stem,
             )
         except Exception as e:
             raise OSError(
@@ -865,7 +854,7 @@ def load_genius_domain(
         agent_info.append(
             {
                 "ufun": utility,
-                "ufun_name": ufname,
+                "ufun_name": Path(ufname).stem,
                 "reserved_value_func": utility.reserved_value
                 if utility is not None
                 else float("-inf"),

src/negmas/preferences/base_ufun.py

@@ -697,7 +697,7 @@ def _get_hyperrects(ufun, max_utility, utiltype=float):
                     info[a] = child.attrib.get(a, info[a])
                 issue_info[issue_key].update(info)
                 mytype = info["type"]
-                # vtype = info["vtype"]
+                info["vtype"]
                 if domain_issues_dict is None:
                     raise ValueError("unknown domain-issue-dict!!!")
 
@@ -891,7 +891,8 @@ def from_genius(
             See ``from_xml_str`` for all the parameters
 
         """
-        kwargs["name"] = str(file_name)
+        if "name" not in kwargs:
+            kwargs["name"] = str(Path(file_name).stem)
         with open(file_name) as f:
             xml_str = f.read()
         return cls.from_xml_str(xml_str=xml_str, **kwargs)

src/negmas/serialization.py

@@ -106,6 +106,9 @@ def good_field(k: str, v, objmem):
     def adjust_dict(d):
         if not isinstance(d, dict):
             return d
+        if python_class_identifier in d.keys():
+            if shorten_type_field and d[python_class_identifier].startswith("negmas."):
+                d[python_class_identifier] = d[python_class_identifier].split(".")[-1]
         for a, b in zip(SPECIAL_FIELDS, SPECIAL_FIELDS_SHORT_NAMES):
             if a in d.keys():
                 if b in d.keys() and d[b] != d[a]:
@@ -198,12 +201,15 @@ def convertwith(value, method, pass_identifier=False):
                 return adjust_dict(converted)
 
     if has(type(value)):
-        converted = asdict(value, recurse=deep)
+        clsname = get_full_type_name(value.__class__)
+        if shorten_type_field and clsname.startswith("negmas."):
+            clsname = clsname.split("n")[-1]
+        converted = asdict(value, recurse=deep) | {python_class_identifier: clsname}
         if converted is not None:
             return serialize(
                 converted,
                 deep=deep,
-                add_type_field=add_type_field,
+                add_type_field=False,
                 keep_private=keep_private,
                 ignore_methods=ignore_methods,
                 ignore_lambda=ignore_lambda,