GitHub/gf-core
1
0
Fork 1
mirror of https://github.com/GrammaticalFramework/gf-core.git synced 2026-04-23 19:42:50 -06:00
Code Issues Packages Projects Releases Wiki Activity

Make hypos tuples again 😥

Browse Source
This commit is contained in:
John J. Camilleri
2021-09-28 10:35:19 +02:00
parent 9863f32d05
commit 388829d63d
6 changed files with 255 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files

240
src/runtime/python/expr.c
View File

@@ -28,18 +28,34 @@ Type_init(TypeObject *self, PyObject *args, PyObject *kwds)
} }
for (Py_ssize_t i = 0; i < PyList_Size(hypos); i++) { for (Py_ssize_t i = 0; i < PyList_Size(hypos); i++) {
if (!PyObject_TypeCheck(PyList_GetItem(hypos, i), &pgf_HypoType)) { // if (!PyObject_TypeCheck(PyList_GetItem(hypos, i), &pgf_HypoType)) {
PyErr_SetString(PyExc_TypeError, "invalid hypo in Type initialisation"); // PyErr_SetString(PyExc_TypeError, "invalid hypo in Type initialisation");
// return -1;
// }
PyObject *tup = PyList_GetItem(hypos, i);
if (!PyObject_TypeCheck(tup, &PyTuple_Type)) {
PyErr_SetString(PyExc_TypeError, "hypothesis must be a tuple");
return -1;
}
if (!PyLong_Check(PyTuple_GetItem(tup, 0))) {
PyErr_SetString(PyExc_TypeError, "hypothesis bind type must be a boolean");
return -1;
}
if (!PyUnicode_Check(PyTuple_GetItem(tup, 1))) {
PyErr_SetString(PyExc_TypeError, "hypothesis variable must be a string");
return -1;
}
if (!PyObject_TypeCheck(PyTuple_GetItem(tup, 2), &pgf_TypeType)) {
PyErr_SetString(PyExc_TypeError, "hypothesis type must be a Type");
return -1; return -1;
} }
// Py_INCREF(&hypos[i]);
} }
for (Py_ssize_t i = 0; i < PyList_Size(exprs); i++) { for (Py_ssize_t i = 0; i < PyList_Size(exprs); i++) {
if (!PyObject_TypeCheck(PyList_GetItem(exprs, i), &pgf_ExprType)) { if (!PyObject_TypeCheck(PyList_GetItem(exprs, i), &pgf_ExprType)) {
PyErr_SetString(PyExc_TypeError, "invalid expression in Type initialisation"); PyErr_SetString(PyExc_TypeError, "invalid expression in Type initialisation");
return -1; return -1;
} }
// Py_INCREF(&exprs[i]);
} }
self->hypos = hypos; self->hypos = hypos;
self->name = name; self->name = name;
@@ -163,114 +179,114 @@ PyTypeObject pgf_TypeType = {
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// hypos // hypos
static HypoObject * // static HypoObject *
Hypo_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) // Hypo_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
{ // {
HypoObject *self = (HypoObject *)subtype->tp_alloc(subtype, 0); // HypoObject *self = (HypoObject *)subtype->tp_alloc(subtype, 0);
return self; // return self;
} // }
//
static int // static int
Hypo_init(HypoObject *self, PyObject *args, PyObject *kwds) // Hypo_init(HypoObject *self, PyObject *args, PyObject *kwds)
{ // {
PyObject *bind_type; // PyObject *bind_type;
PyObject *cid; // PyObject *cid;
TypeObject *type; // TypeObject *type;
if (!PyArg_ParseTuple(args, "O!UO!", &PyBool_Type, &bind_type, &cid, &pgf_TypeType, &type)) { // if (!PyArg_ParseTuple(args, "O!UO!", &PyBool_Type, &bind_type, &cid, &pgf_TypeType, &type)) {
return -1; // return -1;
} // }
//
self->bind_type = bind_type; // self->bind_type = bind_type;
self->cid = cid; // self->cid = cid;
self->type = type; // self->type = type;
Py_INCREF(self->bind_type); // Py_INCREF(self->bind_type);
Py_INCREF(self->cid); // Py_INCREF(self->cid);
Py_INCREF(self->type); // Py_INCREF(self->type);
//
return 0; // return 0;
} // }
//
static void // static void
Hypo_dealloc(HypoObject *self) // Hypo_dealloc(HypoObject *self)
{ // {
Py_XDECREF(self->bind_type); // Py_XDECREF(self->bind_type);
Py_XDECREF(self->cid); // Py_XDECREF(self->cid);
Py_XDECREF(self->type); // Py_XDECREF(self->type);
Py_TYPE(self)->tp_free(self); // Py_TYPE(self)->tp_free(self);
} // }
//
static PyObject * // static PyObject *
Hypo_richcompare(HypoObject *t1, PyObject *p2, int op) // Hypo_richcompare(HypoObject *t1, PyObject *p2, int op)
{ // {
bool same = false; // bool same = false;
if (!PyObject_TypeCheck(p2, &pgf_HypoType)) goto done; // if (!PyObject_TypeCheck(p2, &pgf_HypoType)) goto done;
HypoObject *t2 = (HypoObject *)p2; // HypoObject *t2 = (HypoObject *)p2;
//
if (!PyObject_RichCompareBool(t1->bind_type, t2->bind_type, Py_EQ)) goto done; // if (!PyObject_RichCompareBool(t1->bind_type, t2->bind_type, Py_EQ)) goto done;
if (PyUnicode_Compare(t1->cid, t2->cid) != 0) goto done; // if (PyUnicode_Compare(t1->cid, t2->cid) != 0) goto done;
if (!PyObject_RichCompareBool((PyObject *)t1->type, (PyObject *)t2->type, Py_EQ)) goto done; // if (!PyObject_RichCompareBool((PyObject *)t1->type, (PyObject *)t2->type, Py_EQ)) goto done;
//
same = true; // same = true;
done: // done:
//
if (op == Py_EQ) { // if (op == Py_EQ) {
if (same) Py_RETURN_TRUE; else Py_RETURN_FALSE; // if (same) Py_RETURN_TRUE; else Py_RETURN_FALSE;
} else if (op == Py_NE) { // } else if (op == Py_NE) {
if (same) Py_RETURN_FALSE; else Py_RETURN_TRUE; // if (same) Py_RETURN_FALSE; else Py_RETURN_TRUE;
} else { // } else {
PyErr_SetString(PyExc_TypeError, "comparison operation not supported"); // PyErr_SetString(PyExc_TypeError, "comparison operation not supported");
Py_RETURN_NOTIMPLEMENTED; // Py_RETURN_NOTIMPLEMENTED;
} // }
} // }
//
static PyMemberDef Hypo_members[] = { // static PyMemberDef Hypo_members[] = {
{"bind_type", T_OBJECT_EX, offsetof(HypoObject, bind_type), READONLY, "bind type (explicit or implicit)"}, // {"bind_type", T_OBJECT_EX, offsetof(HypoObject, bind_type), READONLY, "bind type (explicit or implicit)"},
{"cid", T_OBJECT_EX, offsetof(HypoObject, cid), READONLY, "category name"}, // {"cid", T_OBJECT_EX, offsetof(HypoObject, cid), READONLY, "category name"},
{"type", T_OBJECT_EX, offsetof(HypoObject, type), READONLY, "type"}, // {"type", T_OBJECT_EX, offsetof(HypoObject, type), READONLY, "type"},
{NULL} /* Sentinel */ // {NULL} /* Sentinel */
}; // };
//
PyTypeObject pgf_HypoType = { // PyTypeObject pgf_HypoType = {
PyVarObject_HEAD_INIT(NULL, 0) // PyVarObject_HEAD_INIT(NULL, 0)
//0, /*ob_size*/ // //0, /*ob_size*/
"pgf.Hypo", /*tp_name*/ // "pgf.Hypo", /*tp_name*/
sizeof(HypoObject), /*tp_basicsize*/ // sizeof(HypoObject), /*tp_basicsize*/
0, /*tp_itemsize*/ // 0, /*tp_itemsize*/
(destructor) Hypo_dealloc, /*tp_dealloc*/ // (destructor) Hypo_dealloc, /*tp_dealloc*/
0, /*tp_print*/ // 0, /*tp_print*/
0, /*tp_getattr*/ // 0, /*tp_getattr*/
0, /*tp_setattr*/ // 0, /*tp_setattr*/
0, /*tp_compare*/ // 0, /*tp_compare*/
0, /*tp_repr*/ // 0, /*tp_repr*/
0, /*tp_as_number*/ // 0, /*tp_as_number*/
0, /*tp_as_sequence*/ // 0, /*tp_as_sequence*/
0, /*tp_as_mapping*/ // 0, /*tp_as_mapping*/
0, /*tp_hash */ // 0, /*tp_hash */
0, /*tp_call*/ // 0, /*tp_call*/
0, /*tp_str*/ // 0, /*tp_str*/
0, /*tp_getattro*/ // 0, /*tp_getattro*/
0, /*tp_setattro*/ // 0, /*tp_setattro*/
0, /*tp_as_buffer*/ // 0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ // Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
"hypothesis in a type", /*tp_doc*/ // "hypothesis in a type", /*tp_doc*/
0, /*tp_traverse */ // 0, /*tp_traverse */
0, /*tp_clear */ // 0, /*tp_clear */
(richcmpfunc) Hypo_richcompare, /*tp_richcompare */ // (richcmpfunc) Hypo_richcompare, /*tp_richcompare */
0, /*tp_weaklistoffset */ // 0, /*tp_weaklistoffset */
0, /*tp_iter */ // 0, /*tp_iter */
0, /*tp_iternext */ // 0, /*tp_iternext */
0, /*tp_methods */ // 0, /*tp_methods */
Hypo_members, /*tp_members */ // Hypo_members, /*tp_members */
0, /*tp_getset */ // 0, /*tp_getset */
0, /*tp_base */ // 0, /*tp_base */
0, /*tp_dict */ // 0, /*tp_dict */
0, /*tp_descr_get */ // 0, /*tp_descr_get */
0, /*tp_descr_set */ // 0, /*tp_descr_set */
0, /*tp_dictoffset */ // 0, /*tp_dictoffset */
(initproc) Hypo_init, /*tp_init */ // (initproc) Hypo_init, /*tp_init */
0, /*tp_alloc */ // 0, /*tp_alloc */
(newfunc) Hypo_new, /*tp_new */ // (newfunc) Hypo_new, /*tp_new */
}; // };
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// expressions // expressions

18
src/runtime/python/expr.h
View File

@@ -8,21 +8,21 @@
typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD
PyObject *hypos; // PyListObject of HypoObject PyObject *hypos; // PyListObject of PyTupleObject: (PyBool, PyUnicodeObject, TypeObject)
PyObject *name; // PyUnicodeObject PyObject *name; // PyUnicodeObject
PyObject *exprs; // PyListObject of ExprObject PyObject *exprs; // PyListObject of ExprObject
} TypeObject; } TypeObject;
PyTypeObject pgf_TypeType; PyTypeObject pgf_TypeType;
typedef struct { // typedef struct {
PyObject_HEAD // PyObject_HEAD
PyObject *bind_type; // PyBool // PyObject *bind_type; // PyBool
PyObject *cid; // PyUnicodeObject // PyObject *cid; // PyUnicodeObject
TypeObject *type; // TypeObject *type;
} HypoObject; // } HypoObject;
//
PyTypeObject pgf_HypoType; // PyTypeObject pgf_HypoType;
typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD

67
src/runtime/python/ffi.c
View File

@@ -64,7 +64,7 @@ PgfTypeHypo *
PyList_AsHypos(PyObject *pylist, Py_ssize_t *n_hypos) PyList_AsHypos(PyObject *pylist, Py_ssize_t *n_hypos)
{ {
if (!PyList_Check(pylist)) { if (!PyList_Check(pylist)) {
PyErr_SetString(PyExc_TypeError, "hypos must be a list"); PyErr_SetString(PyExc_TypeError, "hypotheses must be a list");
return NULL; return NULL;
} }
Py_ssize_t n = PyList_Size(pylist); Py_ssize_t n = PyList_Size(pylist);
@@ -72,15 +72,43 @@ PyList_AsHypos(PyObject *pylist, Py_ssize_t *n_hypos)
PgfTypeHypo *hypos = PyMem_RawMalloc(sizeof(PgfTypeHypo)*n); PgfTypeHypo *hypos = PyMem_RawMalloc(sizeof(PgfTypeHypo)*n);
for (Py_ssize_t i = 0; i < n; i++) { for (Py_ssize_t i = 0; i < n; i++) {
PyObject *item = PyList_GetItem(pylist, i); // PyObject *item = PyList_GetItem(pylist, i);
if (!PyObject_TypeCheck(item, &pgf_HypoType)) { // if (!PyObject_TypeCheck(item, &pgf_HypoType)) {
PyErr_SetString(PyExc_TypeError, "hypothesis must be of type Hypo"); // PyErr_SetString(PyExc_TypeError, "hypothesis must be of type Hypo");
// return NULL;
// }
// HypoObject *hypo = (HypoObject *)item;
// hypos[i].bind_type = hypo->bind_type == Py_True ? 0 : 1;
// hypos[i].cid = PyUnicode_AsPgfText(hypo->cid);
// hypos[i].type = (PgfType) hypo->type;
PyObject *tup = PyList_GetItem(pylist, i);
if (!PyTuple_Check(tup)) {
PyErr_SetString(PyExc_TypeError, "hypothesis must be a tuple");
return NULL; return NULL;
} }
HypoObject *hypo = (HypoObject *)item;
hypos[i].bind_type = hypo->bind_type == Py_True ? 0 : 1; PyObject *t0 = PyTuple_GetItem(tup, 0);
hypos[i].cid = PyUnicode_AsPgfText(hypo->cid); if (!PyLong_Check(t0)) {
hypos[i].type = (PgfType) hypo->type; PyErr_SetString(PyExc_TypeError, "hypothesis bind type must be an boolean");
return NULL;
}
hypos[i].bind_type = t0 == Py_True ? 0 : 1;
PyObject *t1 = PyTuple_GetItem(tup, 1);
if (!PyUnicode_Check(t1)) {
PyErr_SetString(PyExc_TypeError, "hypothesis variable must be a string");
return NULL;
}
hypos[i].cid = PyUnicode_AsPgfText(t1);
PyObject *t2 = PyTuple_GetItem(tup, 2);
if (!PyObject_TypeCheck(t2, &pgf_TypeType)) {
PyErr_SetString(PyExc_TypeError, "hypothesis type must be a Type");
return NULL;
}
hypos[i].type = (PgfType) t2;
Py_INCREF(hypos[i].type); Py_INCREF(hypos[i].type);
} }
@@ -96,13 +124,22 @@ PyList_FromHypos(PgfTypeHypo *hypos, const size_t n_hypos)
} }
for (size_t i = 0; i < n_hypos; i++) { for (size_t i = 0; i < n_hypos; i++) {
HypoObject *hypo = PyObject_New(HypoObject, &pgf_HypoType); // HypoObject *hypo = PyObject_New(HypoObject, &pgf_HypoType);
hypo->bind_type = hypos[i].bind_type == 0 ? Py_True : Py_False; // hypo->bind_type = hypos[i].bind_type == 0 ? Py_True : Py_False;
hypo->cid = PyUnicode_FromStringAndSize(hypos[i].cid->text, hypos[i].cid->size); // hypo->cid = PyUnicode_FromStringAndSize(hypos[i].cid->text, hypos[i].cid->size);
hypo->type = (TypeObject *)hypos[i].type; // hypo->type = (TypeObject *)hypos[i].type;
Py_INCREF(hypo->bind_type); // Py_INCREF(hypo->bind_type);
Py_INCREF(hypo->type); // Py_INCREF(hypo->type);
PyList_SetItem(pylist, i, (PyObject *)hypo); // PyList_SetItem(pylist, i, (PyObject *)hypo);
PyObject *tup = PyTuple_New(3);
PyObject *bt = hypos[i].bind_type == 0 ? Py_True : Py_False;
PyTuple_SetItem(tup, 0, bt);
PyTuple_SetItem(tup, 1, PyUnicode_FromStringAndSize(hypos[i].cid->text, hypos[i].cid->size));
PyTuple_SetItem(tup, 2, (PyObject *)hypos[i].type);
Py_INCREF(bt);
Py_INCREF(hypos[i].type);
PyList_SetItem(pylist, i, tup);
} }
if (PyErr_Occurred()) { if (PyErr_Occurred()) {
Py_DECREF(pylist); Py_DECREF(pylist);

87
src/runtime/python/pypgf.c
View File

@@ -611,60 +611,83 @@ pgf_showType(PyObject *self, PyObject *args)
return str; return str;
} }
static HypoObject * static PyObject *
pgf_mkHypo(PyObject *self, PyObject *args) pgf_mkHypo(PyObject *self, PyObject *args)
{ {
TypeObject *type; PyObject *type;
if (!PyArg_ParseTuple(args, "O!", &pgf_TypeType, &type)) if (!PyArg_ParseTuple(args, "O!", &pgf_TypeType, &type))
return NULL; return NULL;
HypoObject *hypo = PyObject_New(HypoObject, &pgf_HypoType); // HypoObject *hypo = PyObject_New(HypoObject, &pgf_HypoType);
hypo->bind_type = Py_True; // explicit // hypo->bind_type = Py_True; // explicit
hypo->cid = PyUnicode_FromStringAndSize("_", 1); // hypo->cid = PyUnicode_FromStringAndSize("_", 1);
hypo->type = type; // hypo->type = type;
Py_INCREF(hypo->bind_type); // Py_INCREF(hypo->bind_type);
Py_INCREF(hypo->cid); // Py_INCREF(hypo->cid);
Py_INCREF(hypo->type); // Py_INCREF(hypo->type);
// return hypo;
return hypo; PyObject *tup = PyTuple_New(3);
PyTuple_SetItem(tup, 0, Py_True); // explicit
PyTuple_SetItem(tup, 1, PyUnicode_FromStringAndSize("_", 1));
PyTuple_SetItem(tup, 2, type);
Py_INCREF(Py_True);
Py_INCREF(type);
return tup;
} }
static HypoObject * static PyObject *
pgf_mkDepHypo(PyObject *self, PyObject *args) pgf_mkDepHypo(PyObject *self, PyObject *args)
{ {
PyObject *var; PyObject *var;
TypeObject *type; PyObject *type;
if (!PyArg_ParseTuple(args, "UO!", &var, &pgf_TypeType, &type)) if (!PyArg_ParseTuple(args, "UO!", &var, &pgf_TypeType, &type))
return NULL; return NULL;
HypoObject *hypo = PyObject_New(HypoObject, &pgf_HypoType); // HypoObject *hypo = PyObject_New(HypoObject, &pgf_HypoType);
hypo->bind_type = Py_True; // explicit // hypo->bind_type = Py_True; // explicit
hypo->cid = var; // hypo->cid = var;
hypo->type = type; // hypo->type = type;
Py_INCREF(hypo->bind_type); // Py_INCREF(hypo->bind_type);
Py_INCREF(hypo->cid); // Py_INCREF(hypo->cid);
Py_INCREF(hypo->type); // Py_INCREF(hypo->type);
// return hypo;
return hypo; PyObject *tup = PyTuple_New(3);
PyTuple_SetItem(tup, 0, Py_True); // explicit
PyTuple_SetItem(tup, 1, var);
PyTuple_SetItem(tup, 2, type);
Py_INCREF(Py_True);
Py_INCREF(var);
Py_INCREF(type);
return tup;
} }
static HypoObject * static PyObject *
pgf_mkImplHypo(PyObject *self, PyObject *args) pgf_mkImplHypo(PyObject *self, PyObject *args)
{ {
PyObject *var; PyObject *var;
TypeObject *type; PyObject *type;
if (!PyArg_ParseTuple(args, "UO!", &var, &pgf_TypeType, &type)) if (!PyArg_ParseTuple(args, "UO!", &var, &pgf_TypeType, &type))
return NULL; return NULL;
HypoObject *hypo = PyObject_New(HypoObject, &pgf_HypoType); // HypoObject *hypo = PyObject_New(HypoObject, &pgf_HypoType);
hypo->bind_type = Py_False; // implicit // hypo->bind_type = Py_False; // implicit
hypo->cid = var; // hypo->cid = var;
hypo->type = type; // hypo->type = type;
Py_INCREF(hypo->bind_type); // Py_INCREF(hypo->bind_type);
Py_INCREF(hypo->cid); // Py_INCREF(hypo->cid);
Py_INCREF(hypo->type); // Py_INCREF(hypo->type);
// return hypo;
return hypo; PyObject *tup = PyTuple_New(3);
PyTuple_SetItem(tup, 0, Py_False); // implicit
PyTuple_SetItem(tup, 1, var);
PyTuple_SetItem(tup, 2, type);
Py_INCREF(Py_True);
Py_INCREF(var);
Py_INCREF(type);
return tup;
} }
static PyMethodDef module_methods[] = { static PyMethodDef module_methods[] = {
@@ -747,7 +770,7 @@ MOD_INIT(pgf)
TYPE_READY(pgf_ExprTypedType); TYPE_READY(pgf_ExprTypedType);
TYPE_READY(pgf_ExprImplArgType); TYPE_READY(pgf_ExprImplArgType);
TYPE_READY(pgf_TypeType); TYPE_READY(pgf_TypeType);
TYPE_READY(pgf_HypoType); // TYPE_READY(pgf_HypoType);
MOD_DEF(m, "pgf", "The Runtime for Portable Grammar Format in Python", module_methods); MOD_DEF(m, "pgf", "The Runtime for Portable Grammar Format in Python", module_methods);
if (m == NULL) if (m == NULL)
@@ -768,7 +791,7 @@ MOD_INIT(pgf)
ADD_TYPE("ExprTyped", pgf_ExprTypedType); ADD_TYPE("ExprTyped", pgf_ExprTypedType);
ADD_TYPE("ExprImplArg", pgf_ExprImplArgType); ADD_TYPE("ExprImplArg", pgf_ExprImplArgType);
ADD_TYPE("Type", pgf_TypeType); ADD_TYPE("Type", pgf_TypeType);
ADD_TYPE("Hypo", pgf_HypoType); // ADD_TYPE("Hypo", pgf_HypoType);
ADD_TYPE_DIRECT("BIND_TYPE_EXPLICIT", Py_True); ADD_TYPE_DIRECT("BIND_TYPE_EXPLICIT", Py_True);
ADD_TYPE_DIRECT("BIND_TYPE_IMPLICIT", Py_False); ADD_TYPE_DIRECT("BIND_TYPE_IMPLICIT", Py_False);

11
src/runtime/python/tests/test_basic.py
View File

@@ -113,10 +113,13 @@ def test_categoryContext_3(PGF):
cxt = PGF.categoryContext("P") cxt = PGF.categoryContext("P")
assert len(cxt) == 1 assert len(cxt) == 1
hypo = cxt[0] hypo = cxt[0]
assert isinstance(hypo, Hypo) # assert isinstance(hypo, Hypo)
assert hypo.bind_type == BIND_TYPE_EXPLICIT # assert hypo.bind_type == BIND_TYPE_EXPLICIT
assert hypo.cid == "_" # assert hypo.cid == "_"
assert hypo.type == readType("N") # assert hypo.type == readType("N")
assert hypo[0] == BIND_TYPE_EXPLICIT
assert hypo[1] == "_"
assert hypo[2] == readType("N")
def test_categoryContext_4(PGF): def test_categoryContext_4(PGF):
assert PGF.categoryContext("X") == None assert PGF.categoryContext("X") == None

8
src/runtime/python/tests/test_transactions.py
View File

@@ -15,7 +15,7 @@ def gr2(gr1):
gr = gr1 gr = gr1
t = gr.newTransaction() t = gr.newTransaction()
t.createFunction("foo", ty, 0, prob) t.createFunction("foo", ty, 0, prob)
t.createCategory("Q", [Hypo(BIND_TYPE_EXPLICIT, "x", ty)], prob) t.createCategory("Q", [(BIND_TYPE_EXPLICIT, "x", ty)], prob)
t.commit() t.commit()
yield gr yield gr
@@ -24,7 +24,7 @@ def gr3(gr1):
gr = gr1 gr = gr1
with gr.newTransaction("bar_branch") as t: with gr.newTransaction("bar_branch") as t:
t.createFunction("bar", ty, 0, prob) t.createFunction("bar", ty, 0, prob)
t.createCategory("R", [Hypo(BIND_TYPE_EXPLICIT, "x", ty)], prob) t.createCategory("R", [(BIND_TYPE_EXPLICIT, "x", ty)], prob)
yield gr yield gr
@pytest.fixture(scope="function") @pytest.fixture(scope="function")
@@ -89,7 +89,7 @@ def test_extended_categories(gr2):
assert gr2.categories == ["Float","Int","N","P","Q","S","String"] assert gr2.categories == ["Float","Int","N","P","Q","S","String"]
def test_extended_category_context(gr2): def test_extended_category_context(gr2):
assert gr2.categoryContext("Q") == [Hypo(BIND_TYPE_EXPLICIT, "x", ty)] assert gr2.categoryContext("Q") == [(BIND_TYPE_EXPLICIT, "x", ty)]
def test_extended_function_type(gr2): def test_extended_function_type(gr2):
assert gr2.functionType("foo") == ty assert gr2.functionType("foo") == ty
@@ -112,7 +112,7 @@ def test_branched_categories(gr3):
assert gr3.categories == ["Float","Int","N","P","R","S","String"] assert gr3.categories == ["Float","Int","N","P","R","S","String"]
def test_branched_category_context(gr3): def test_branched_category_context(gr3):
assert gr3.categoryContext("R") == [Hypo(BIND_TYPE_EXPLICIT, "x", ty)] assert gr3.categoryContext("R") == [(BIND_TYPE_EXPLICIT, "x", ty)]
def test_branched_function_type(gr3): def test_branched_function_type(gr3):
assert gr3.functionType("bar") == ty assert gr3.functionType("bar") == ty