reasoning_layer_python_sdk 1.0.0__py3-none-any.whl

reasoning_layer_python_sdk/generated/models/membership_dto.py

@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+    OSF Knowledge Base API
+
+    Order-Sorted Feature logic knowledge base with fuzzy reasoning, inference, and constraint solving. Note: Some endpoints are hidden from Swagger due to recursive type limitations but work via API calls.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from uuid import UUID
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class MembershipDto(BaseModel):
+    """
+    Membership information
+    """ # noqa: E501
+    community_id: UUID = Field(description="Community ID")
+    community_title: Optional[StrictStr] = Field(default=None, description="Community title (from report)")
+    degree: Union[StrictFloat, StrictInt] = Field(description="Membership degree (0.0 - 1.0, based on connectivity)")
+    level: Annotated[int, Field(strict=True, ge=0)] = Field(description="Community level")
+    __properties: ClassVar[List[str]] = ["community_id", "community_title", "degree", "level"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of MembershipDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if community_title (nullable) is None
+        # and model_fields_set contains the field
+        if self.community_title is None and "community_title" in self.model_fields_set:
+            _dict['community_title'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MembershipDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "community_id": obj.get("community_id"),
+            "community_title": obj.get("community_title"),
+            "degree": obj.get("degree"),
+            "level": obj.get("level")
+        })
+        return _obj
+
+

reasoning_layer_python_sdk/generated/models/merge_entity_request.py

@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+    OSF Knowledge Base API
+
+    Order-Sorted Feature logic knowledge base with fuzzy reasoning, inference, and constraint solving. Note: Some endpoints are hidden from Swagger due to recursive type limitations but work via API calls.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from uuid import UUID
+from reasoning_layer_python_sdk.generated.models.conflict_resolution import ConflictResolution
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class MergeEntityRequest(BaseModel):
+    """
+    Request to merge entity with existing term
+    """ # noqa: E501
+    conflict_resolution: Optional[ConflictResolution] = Field(default=None, description="How to handle conflicting features")
+    review_id: UUID = Field(description="The review ID to merge")
+    target_term_id: UUID = Field(description="Target term ID to merge with")
+    __properties: ClassVar[List[str]] = ["conflict_resolution", "review_id", "target_term_id"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of MergeEntityRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MergeEntityRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "conflict_resolution": obj.get("conflict_resolution"),
+            "review_id": obj.get("review_id"),
+            "target_term_id": obj.get("target_term_id")
+        })
+        return _obj
+
+

reasoning_layer_python_sdk/generated/models/meta_sorts_response.py

@@ -0,0 +1,429 @@
+# coding: utf-8
+
+"""
+    OSF Knowledge Base API
+
+    Order-Sorted Feature logic knowledge base with fuzzy reasoning, inference, and constraint solving. Note: Some endpoints are hidden from Swagger due to recursive type limitations but work via API calls.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List
+from uuid import UUID
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class MetaSortsResponse(BaseModel):
+    """
+    Response containing all meta sort IDs.  Clients need these IDs to create terms with built-in sorts like `guard_constraint`, `variable`, etc. This enables TRUE HOMOICONICITY where everything is referenced by ID, not by name.
+    """ # noqa: E501
+    abs_constraint: UUID = Field(description="Abs constraint (|X| = Y)")
+    aggregate_constraint: UUID = Field(description="Aggregate constraint (count, sum, min, max, avg)")
+    allen_constraint: UUID = Field(description="Allen temporal constraint sort (for interval relations: before, after, during, etc.)")
+    append_constraint: UUID = Field(description="Append constraint ([A|B] = C)")
+    arithmetic_constraint: UUID = Field(description="Arithmetic constraint (result = left_operand op right_operand)")
+    array_const_constraint: UUID
+    array_constraint: UUID
+    array_ext_constraint: UUID
+    array_select_constraint: UUID
+    array_store_constraint: UUID
+    bagof_constraint: UUID = Field(description="Bagof constraint (collect solutions, fails if none)")
+    between_constraint: UUID = Field(description="Between constraint (Low =< X =< High)")
+    bit_blast_tactic: UUID
+    bv_add_constraint: UUID
+    bv_and_constraint: UUID
+    bv_ashr_constraint: UUID
+    bv_concat_constraint: UUID
+    bv_constraint: UUID
+    bv_extract_constraint: UUID
+    bv_labeling_constraint: UUID
+    bv_lshr_constraint: UUID
+    bv_mul_constraint: UUID
+    bv_not_constraint: UUID
+    bv_or_constraint: UUID
+    bv_shl_constraint: UUID
+    bv_slt_constraint: UUID
+    bv_sub_constraint: UUID
+    bv_udiv_constraint: UUID
+    bv_ult_constraint: UUID
+    bv_xor_constraint: UUID
+    call_constraint: UUID = Field(description="Call constraint (meta-call)")
+    certified_proof: UUID
+    clause: UUID = Field(description="Clause sort (conjunction of constraints)")
+    cnf_tactic: UUID
+    constraint: UUID = Field(description="Constraint base sort")
+    cut: UUID = Field(description="Cut (commits to current choice point)")
+    datatype_constraint: UUID
+    depth_probe: UUID
+    disentailment: UUID = Field(description="Disentailment constraint (antecedent -/-> consequent)")
+    disequality_constraint: UUID = Field(description="Disequality constraint (X =/= Y)")
+    div_constraint: UUID = Field(description="Div constraint (X / Y = Z)")
+    drat_clause: UUID
+    dt_constructor_constraint: UUID
+    dt_selector_constraint: UUID
+    dt_tester_constraint: UUID
+    dt_update_constraint: UUID
+    entailment: UUID = Field(description="Entailment constraint (antecedent -> consequent)")
+    equality_constraint: UUID = Field(description="Equality constraint (X .= Y)")
+    feature_constraint: UUID = Field(description="Feature constraint (X.f .= Y)")
+    findall_constraint: UUID = Field(description="Findall constraint (collect all solutions)")
+    forall_constraint: UUID = Field(description="Forall constraint (universal quantification)")
+    fourier_motzkin_tactic: UUID
+    fp_add_constraint: UUID
+    fp_constraint: UUID
+    fp_div_constraint: UUID
+    fp_eq_constraint: UUID
+    fp_is_nan_constraint: UUID
+    fp_lt_constraint: UUID
+    fp_mul_constraint: UUID
+    fp_sqrt_constraint: UUID
+    fp_sub_constraint: UUID
+    fp_to_real_constraint: UUID
+    goal: UUID = Field(description="Goal sort (what we're proving)")
+    guard_constraint: UUID = Field(description="Guard constraint sort (for comparisons like <, >, <=, >=)")
+    if_tactic: UUID
+    if_then_else_constraint: UUID = Field(description="If-then-else constraint")
+    last_constraint: UUID = Field(description="Last constraint")
+    length_constraint: UUID = Field(description="Length constraint (length(List) = N)")
+    lexicographic_objective: UUID
+    max_constraint: UUID = Field(description="Max constraint (max(X, Y) = Z)")
+    maximize_objective: UUID
+    member_constraint: UUID = Field(description="Member constraint (X in List)")
+    min_constraint: UUID = Field(description="Min constraint (min(X, Y) = Z)")
+    minimize_objective: UUID
+    minus_constraint: UUID = Field(description="Minus constraint (X - Y = Z)")
+    mod_constraint: UUID = Field(description="Mod constraint (X mod Y = Z)")
+    negation: UUID = Field(description="Negation as failure (not(clause))")
+    nla_constraint: UUID
+    nla_labeling_constraint: UUID
+    nla_polynomial_constraint: UUID
+    nla_power_constraint: UUID
+    nnf_tactic: UUID
+    nth_constraint: UUID = Field(description="Nth constraint (nth element of list)")
+    num_vars_probe: UUID
+    objective_result: UUID
+    once_constraint: UUID = Field(description="Once constraint (succeed at most once)")
+    optimization_constraint: UUID
+    par_or_tactic: UUID
+    pareto_objective: UUID
+    pdr_counterexample: UUID
+    pdr_cube: UUID
+    pdr_frame: UUID
+    pdr_invariant: UUID
+    pdr_model_check: UUID
+    pdr_obligation: UUID
+    pdr_transition: UUID
+    plus_constraint: UUID = Field(description="Plus constraint (X + Y = Z)")
+    probe: UUID
+    proof_certificate: UUID
+    proof_step: UUID
+    propagate_values_tactic: UUID
+    qe_constraint: UUID
+    qe_eliminate: UUID
+    qe_exists: UUID
+    qe_forall: UUID
+    re_concat_constraint: UUID
+    re_literal_constraint: UUID
+    re_range_constraint: UUID
+    re_star_constraint: UUID
+    re_union_constraint: UUID
+    real_abs_constraint: UUID = Field(description="Real absolute value: |arg| = result")
+    real_between_constraint: UUID = Field(description="Real between: lower <= var <= upper")
+    real_constraint: UUID = Field(description="Parent sort for all real/rational constraints")
+    real_div_constraint: UUID = Field(description="Real division: dividend / divisor = result")
+    real_eq_constraint: UUID = Field(description="Real equality: left = right")
+    real_ge_constraint: UUID = Field(description="Real greater-equal: left >= right")
+    real_labeling_constraint: UUID = Field(description="Real labeling: solve collected real constraints")
+    real_le_constraint: UUID = Field(description="Real less-equal: left <= right")
+    real_max_constraint: UUID = Field(description="Real maximum: max(left, right) = result")
+    real_min_constraint: UUID = Field(description="Real minimum: min(left, right) = result")
+    real_minus_constraint: UUID = Field(description="Real subtraction: left - right = result")
+    real_plus_constraint: UUID = Field(description="Real addition: left + right = result")
+    real_times_constraint: UUID = Field(description="Real multiplication: coefficient * variable = result")
+    regex_constraint: UUID
+    repeat_tactic: UUID
+    resolution_step: UUID
+    reverse_constraint: UUID = Field(description="Reverse constraint")
+    rule: UUID = Field(description="Rule sort (head :- body)")
+    sat_assert: UUID = Field(description="SAT assert: add a clause to the solver")
+    sat_assumption: UUID = Field(description="SAT assumption: assumed literal for incremental solving")
+    sat_check_sat: UUID = Field(description="SAT check-sat: run the CDCL solver")
+    sat_clause: UUID = Field(description="SAT clause: a disjunction of literals")
+    sat_conflict: UUID = Field(description="SAT conflict: learned clause from conflict analysis")
+    sat_constraint: UUID = Field(description="Parent sort for all SAT constraints")
+    sat_get_model: UUID = Field(description="SAT get-model: retrieve the satisfying assignment")
+    sat_literal: UUID = Field(description="SAT literal: variable with polarity")
+    sat_variable_sort: UUID = Field(description="SAT variable sort")
+    setof_constraint: UUID = Field(description="Setof constraint (collect unique sorted solutions)")
+    simplify_tactic: UUID
+    smt_assert: UUID = Field(description="SMT assert: add a formula to the SMT solver")
+    smt_check_sat: UUID = Field(description="SMT check-sat: run the DPLL(T) solver")
+    smt_constraint: UUID = Field(description="SMT constraint: parent sort for all SMT constraints")
+    smt_get_model: UUID = Field(description="SMT get-model: retrieve the SMT model")
+    smt_get_proof: UUID = Field(description="SMT get-proof: retrieve the proof of unsatisfiability")
+    smt_pop: UUID = Field(description="SMT pop: pop an assertion scope")
+    smt_push: UUID = Field(description="SMT push: push an assertion scope")
+    soft_constraint: UUID
+    solve_eqs_tactic: UUID
+    sort_constraint: UUID = Field(description="Sort constraint (X : S)")
+    str_concat_constraint: UUID
+    str_contains_constraint: UUID
+    str_from_int_constraint: UUID
+    str_labeling_constraint: UUID
+    str_length_constraint: UUID
+    str_prefix_constraint: UUID
+    str_regex_match_constraint: UUID
+    str_replace_constraint: UUID
+    str_substr_constraint: UUID
+    str_suffix_constraint: UUID
+    str_to_int_constraint: UUID
+    string_constraint: UUID
+    substitution: UUID = Field(description="Substitution sort (variable bindings)")
+    succ_constraint: UUID = Field(description="Succ constraint (successor: S = X + 1)")
+    tactic: UUID
+    tactic_combinator: UUID
+    then_tactic: UUID
+    theory_lemma_proof: UUID
+    thing: UUID = Field(description="The root \"thing\" sort (top of hierarchy)")
+    times_constraint: UUID = Field(description="Times constraint (X * Y = Z)")
+    tseitin_tactic: UUID
+    variable: UUID = Field(description="Variable sort - unbound terms")
+    __properties: ClassVar[List[str]] = ["abs_constraint", "aggregate_constraint", "allen_constraint", "append_constraint", "arithmetic_constraint", "array_const_constraint", "array_constraint", "array_ext_constraint", "array_select_constraint", "array_store_constraint", "bagof_constraint", "between_constraint", "bit_blast_tactic", "bv_add_constraint", "bv_and_constraint", "bv_ashr_constraint", "bv_concat_constraint", "bv_constraint", "bv_extract_constraint", "bv_labeling_constraint", "bv_lshr_constraint", "bv_mul_constraint", "bv_not_constraint", "bv_or_constraint", "bv_shl_constraint", "bv_slt_constraint", "bv_sub_constraint", "bv_udiv_constraint", "bv_ult_constraint", "bv_xor_constraint", "call_constraint", "certified_proof", "clause", "cnf_tactic", "constraint", "cut", "datatype_constraint", "depth_probe", "disentailment", "disequality_constraint", "div_constraint", "drat_clause", "dt_constructor_constraint", "dt_selector_constraint", "dt_tester_constraint", "dt_update_constraint", "entailment", "equality_constraint", "feature_constraint", "findall_constraint", "forall_constraint", "fourier_motzkin_tactic", "fp_add_constraint", "fp_constraint", "fp_div_constraint", "fp_eq_constraint", "fp_is_nan_constraint", "fp_lt_constraint", "fp_mul_constraint", "fp_sqrt_constraint", "fp_sub_constraint", "fp_to_real_constraint", "goal", "guard_constraint", "if_tactic", "if_then_else_constraint", "last_constraint", "length_constraint", "lexicographic_objective", "max_constraint", "maximize_objective", "member_constraint", "min_constraint", "minimize_objective", "minus_constraint", "mod_constraint", "negation", "nla_constraint", "nla_labeling_constraint", "nla_polynomial_constraint", "nla_power_constraint", "nnf_tactic", "nth_constraint", "num_vars_probe", "objective_result", "once_constraint", "optimization_constraint", "par_or_tactic", "pareto_objective", "pdr_counterexample", "pdr_cube", "pdr_frame", "pdr_invariant", "pdr_model_check", "pdr_obligation", "pdr_transition", "plus_constraint", "probe", "proof_certificate", "proof_step", "propagate_values_tactic", "qe_constraint", "qe_eliminate", "qe_exists", "qe_forall", "re_concat_constraint", "re_literal_constraint", "re_range_constraint", "re_star_constraint", "re_union_constraint", "real_abs_constraint", "real_between_constraint", "real_constraint", "real_div_constraint", "real_eq_constraint", "real_ge_constraint", "real_labeling_constraint", "real_le_constraint", "real_max_constraint", "real_min_constraint", "real_minus_constraint", "real_plus_constraint", "real_times_constraint", "regex_constraint", "repeat_tactic", "resolution_step", "reverse_constraint", "rule", "sat_assert", "sat_assumption", "sat_check_sat", "sat_clause", "sat_conflict", "sat_constraint", "sat_get_model", "sat_literal", "sat_variable_sort", "setof_constraint", "simplify_tactic", "smt_assert", "smt_check_sat", "smt_constraint", "smt_get_model", "smt_get_proof", "smt_pop", "smt_push", "soft_constraint", "solve_eqs_tactic", "sort_constraint", "str_concat_constraint", "str_contains_constraint", "str_from_int_constraint", "str_labeling_constraint", "str_length_constraint", "str_prefix_constraint", "str_regex_match_constraint", "str_replace_constraint", "str_substr_constraint", "str_suffix_constraint", "str_to_int_constraint", "string_constraint", "substitution", "succ_constraint", "tactic", "tactic_combinator", "then_tactic", "theory_lemma_proof", "thing", "times_constraint", "tseitin_tactic", "variable"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of MetaSortsResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MetaSortsResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "abs_constraint": obj.get("abs_constraint"),
+            "aggregate_constraint": obj.get("aggregate_constraint"),
+            "allen_constraint": obj.get("allen_constraint"),
+            "append_constraint": obj.get("append_constraint"),
+            "arithmetic_constraint": obj.get("arithmetic_constraint"),
+            "array_const_constraint": obj.get("array_const_constraint"),
+            "array_constraint": obj.get("array_constraint"),
+            "array_ext_constraint": obj.get("array_ext_constraint"),
+            "array_select_constraint": obj.get("array_select_constraint"),
+            "array_store_constraint": obj.get("array_store_constraint"),
+            "bagof_constraint": obj.get("bagof_constraint"),
+            "between_constraint": obj.get("between_constraint"),
+            "bit_blast_tactic": obj.get("bit_blast_tactic"),
+            "bv_add_constraint": obj.get("bv_add_constraint"),
+            "bv_and_constraint": obj.get("bv_and_constraint"),
+            "bv_ashr_constraint": obj.get("bv_ashr_constraint"),
+            "bv_concat_constraint": obj.get("bv_concat_constraint"),
+            "bv_constraint": obj.get("bv_constraint"),
+            "bv_extract_constraint": obj.get("bv_extract_constraint"),
+            "bv_labeling_constraint": obj.get("bv_labeling_constraint"),
+            "bv_lshr_constraint": obj.get("bv_lshr_constraint"),
+            "bv_mul_constraint": obj.get("bv_mul_constraint"),
+            "bv_not_constraint": obj.get("bv_not_constraint"),
+            "bv_or_constraint": obj.get("bv_or_constraint"),
+            "bv_shl_constraint": obj.get("bv_shl_constraint"),
+            "bv_slt_constraint": obj.get("bv_slt_constraint"),
+            "bv_sub_constraint": obj.get("bv_sub_constraint"),
+            "bv_udiv_constraint": obj.get("bv_udiv_constraint"),
+            "bv_ult_constraint": obj.get("bv_ult_constraint"),
+            "bv_xor_constraint": obj.get("bv_xor_constraint"),
+            "call_constraint": obj.get("call_constraint"),
+            "certified_proof": obj.get("certified_proof"),
+            "clause": obj.get("clause"),
+            "cnf_tactic": obj.get("cnf_tactic"),
+            "constraint": obj.get("constraint"),
+            "cut": obj.get("cut"),
+            "datatype_constraint": obj.get("datatype_constraint"),
+            "depth_probe": obj.get("depth_probe"),
+            "disentailment": obj.get("disentailment"),
+            "disequality_constraint": obj.get("disequality_constraint"),
+            "div_constraint": obj.get("div_constraint"),
+            "drat_clause": obj.get("drat_clause"),
+            "dt_constructor_constraint": obj.get("dt_constructor_constraint"),
+            "dt_selector_constraint": obj.get("dt_selector_constraint"),
+            "dt_tester_constraint": obj.get("dt_tester_constraint"),
+            "dt_update_constraint": obj.get("dt_update_constraint"),
+            "entailment": obj.get("entailment"),
+            "equality_constraint": obj.get("equality_constraint"),
+            "feature_constraint": obj.get("feature_constraint"),
+            "findall_constraint": obj.get("findall_constraint"),
+            "forall_constraint": obj.get("forall_constraint"),
+            "fourier_motzkin_tactic": obj.get("fourier_motzkin_tactic"),
+            "fp_add_constraint": obj.get("fp_add_constraint"),
+            "fp_constraint": obj.get("fp_constraint"),
+            "fp_div_constraint": obj.get("fp_div_constraint"),
+            "fp_eq_constraint": obj.get("fp_eq_constraint"),
+            "fp_is_nan_constraint": obj.get("fp_is_nan_constraint"),
+            "fp_lt_constraint": obj.get("fp_lt_constraint"),
+            "fp_mul_constraint": obj.get("fp_mul_constraint"),
+            "fp_sqrt_constraint": obj.get("fp_sqrt_constraint"),
+            "fp_sub_constraint": obj.get("fp_sub_constraint"),
+            "fp_to_real_constraint": obj.get("fp_to_real_constraint"),
+            "goal": obj.get("goal"),
+            "guard_constraint": obj.get("guard_constraint"),
+            "if_tactic": obj.get("if_tactic"),
+            "if_then_else_constraint": obj.get("if_then_else_constraint"),
+            "last_constraint": obj.get("last_constraint"),
+            "length_constraint": obj.get("length_constraint"),
+            "lexicographic_objective": obj.get("lexicographic_objective"),
+            "max_constraint": obj.get("max_constraint"),
+            "maximize_objective": obj.get("maximize_objective"),
+            "member_constraint": obj.get("member_constraint"),
+            "min_constraint": obj.get("min_constraint"),
+            "minimize_objective": obj.get("minimize_objective"),
+            "minus_constraint": obj.get("minus_constraint"),
+            "mod_constraint": obj.get("mod_constraint"),
+            "negation": obj.get("negation"),
+            "nla_constraint": obj.get("nla_constraint"),
+            "nla_labeling_constraint": obj.get("nla_labeling_constraint"),
+            "nla_polynomial_constraint": obj.get("nla_polynomial_constraint"),
+            "nla_power_constraint": obj.get("nla_power_constraint"),
+            "nnf_tactic": obj.get("nnf_tactic"),
+            "nth_constraint": obj.get("nth_constraint"),
+            "num_vars_probe": obj.get("num_vars_probe"),
+            "objective_result": obj.get("objective_result"),
+            "once_constraint": obj.get("once_constraint"),
+            "optimization_constraint": obj.get("optimization_constraint"),
+            "par_or_tactic": obj.get("par_or_tactic"),
+            "pareto_objective": obj.get("pareto_objective"),
+            "pdr_counterexample": obj.get("pdr_counterexample"),
+            "pdr_cube": obj.get("pdr_cube"),
+            "pdr_frame": obj.get("pdr_frame"),
+            "pdr_invariant": obj.get("pdr_invariant"),
+            "pdr_model_check": obj.get("pdr_model_check"),
+            "pdr_obligation": obj.get("pdr_obligation"),
+            "pdr_transition": obj.get("pdr_transition"),
+            "plus_constraint": obj.get("plus_constraint"),
+            "probe": obj.get("probe"),
+            "proof_certificate": obj.get("proof_certificate"),
+            "proof_step": obj.get("proof_step"),
+            "propagate_values_tactic": obj.get("propagate_values_tactic"),
+            "qe_constraint": obj.get("qe_constraint"),
+            "qe_eliminate": obj.get("qe_eliminate"),
+            "qe_exists": obj.get("qe_exists"),
+            "qe_forall": obj.get("qe_forall"),
+            "re_concat_constraint": obj.get("re_concat_constraint"),
+            "re_literal_constraint": obj.get("re_literal_constraint"),
+            "re_range_constraint": obj.get("re_range_constraint"),
+            "re_star_constraint": obj.get("re_star_constraint"),
+            "re_union_constraint": obj.get("re_union_constraint"),
+            "real_abs_constraint": obj.get("real_abs_constraint"),
+            "real_between_constraint": obj.get("real_between_constraint"),
+            "real_constraint": obj.get("real_constraint"),
+            "real_div_constraint": obj.get("real_div_constraint"),
+            "real_eq_constraint": obj.get("real_eq_constraint"),
+            "real_ge_constraint": obj.get("real_ge_constraint"),
+            "real_labeling_constraint": obj.get("real_labeling_constraint"),
+            "real_le_constraint": obj.get("real_le_constraint"),
+            "real_max_constraint": obj.get("real_max_constraint"),
+            "real_min_constraint": obj.get("real_min_constraint"),
+            "real_minus_constraint": obj.get("real_minus_constraint"),
+            "real_plus_constraint": obj.get("real_plus_constraint"),
+            "real_times_constraint": obj.get("real_times_constraint"),
+            "regex_constraint": obj.get("regex_constraint"),
+            "repeat_tactic": obj.get("repeat_tactic"),
+            "resolution_step": obj.get("resolution_step"),
+            "reverse_constraint": obj.get("reverse_constraint"),
+            "rule": obj.get("rule"),
+            "sat_assert": obj.get("sat_assert"),
+            "sat_assumption": obj.get("sat_assumption"),
+            "sat_check_sat": obj.get("sat_check_sat"),
+            "sat_clause": obj.get("sat_clause"),
+            "sat_conflict": obj.get("sat_conflict"),
+            "sat_constraint": obj.get("sat_constraint"),
+            "sat_get_model": obj.get("sat_get_model"),
+            "sat_literal": obj.get("sat_literal"),
+            "sat_variable_sort": obj.get("sat_variable_sort"),
+            "setof_constraint": obj.get("setof_constraint"),
+            "simplify_tactic": obj.get("simplify_tactic"),
+            "smt_assert": obj.get("smt_assert"),
+            "smt_check_sat": obj.get("smt_check_sat"),
+            "smt_constraint": obj.get("smt_constraint"),
+            "smt_get_model": obj.get("smt_get_model"),
+            "smt_get_proof": obj.get("smt_get_proof"),
+            "smt_pop": obj.get("smt_pop"),
+            "smt_push": obj.get("smt_push"),
+            "soft_constraint": obj.get("soft_constraint"),
+            "solve_eqs_tactic": obj.get("solve_eqs_tactic"),
+            "sort_constraint": obj.get("sort_constraint"),
+            "str_concat_constraint": obj.get("str_concat_constraint"),
+            "str_contains_constraint": obj.get("str_contains_constraint"),
+            "str_from_int_constraint": obj.get("str_from_int_constraint"),
+            "str_labeling_constraint": obj.get("str_labeling_constraint"),
+            "str_length_constraint": obj.get("str_length_constraint"),
+            "str_prefix_constraint": obj.get("str_prefix_constraint"),
+            "str_regex_match_constraint": obj.get("str_regex_match_constraint"),
+            "str_replace_constraint": obj.get("str_replace_constraint"),
+            "str_substr_constraint": obj.get("str_substr_constraint"),
+            "str_suffix_constraint": obj.get("str_suffix_constraint"),
+            "str_to_int_constraint": obj.get("str_to_int_constraint"),
+            "string_constraint": obj.get("string_constraint"),
+            "substitution": obj.get("substitution"),
+            "succ_constraint": obj.get("succ_constraint"),
+            "tactic": obj.get("tactic"),
+            "tactic_combinator": obj.get("tactic_combinator"),
+            "then_tactic": obj.get("then_tactic"),
+            "theory_lemma_proof": obj.get("theory_lemma_proof"),
+            "thing": obj.get("thing"),
+            "times_constraint": obj.get("times_constraint"),
+            "tseitin_tactic": obj.get("tseitin_tactic"),
+            "variable": obj.get("variable")
+        })
+        return _obj
+
+