raise KeyError instead of ErrorStatusException(eKeyNotFound)

[gswifort]

Db.BlockTable.__getitem__() raises PyDb.ErrorStatusException(eKeyNotFound) while the getitem methods should throw KeyError or IndexError (in this case KeyError). This would be easier to use and more intuitive. Is this possible?

# now it's like this:
@command
def doit():
    db = Db.curDb()
    bt = Db.BlockTable(db.blockTableId())
    try:
        btr_id = bt["block_name"]
    except Db.ErrorStatusException as err:
        if err.code == Db.ErrorStatus.eKeyNotFound:
            print("Block not found")
        else:
            raise

# I'd like to do this:
@command
def doit():
    db = Db.curDb()
    bt = Db.BlockTable(db.blockTableId())
    try:
        btr_id = bt["block_name"]
    except KeyError:
        print("Block not found")

# I know I can do this:
@command
def doit():
    db = Db.curDb()
    bt = Db.BlockTable(db.blockTableId())
    try:
        btr_id = bt.asDict()["block_name"]
    except KeyError:
        print("Block not found")

[CEXT-Dan]

eKeyNotFound is generated from ARX, Acad::eKeyNotFound, if we change it, then users would not be able to search for similar conditions

[gswifort]

The .getAt() method will throw eKeyNotFound, which is intuitive because it is the same method as ARX. __getitem__ is a Python method, so in my opinion it should throw Python exceptions.

[CEXT-Dan]

__getitem__ calls getAt

PyRx/PyRxCore/PyDbSymbolTable.cpp

Lines 10 to 34 in 5b04fc6

	void makePyDbSymbolTableWrapper()
	{
	PyDocString DS("SymbolTable");
	class_<PyDbSymbolTable, bases<PyDbObject>>("SymbolTable", boost::python::no_init)
	.def(init<const PyDbObjectId&>())
	.def(init<const PyDbObjectId&, AcDb::OpenMode>())
	.def(init<const PyDbObjectId&, AcDb::OpenMode, bool>(DS.ARGS({ "id: PyDb.ObjectId", "mode: PyDb.OpenMode = PyDb.OpenMode.kForRead", "erased: bool=False" })))
	.def("getAt", &PyDbSymbolTable::getAt, DS.ARGS({ "val: str" }, 9072))
	.def("add", &PyDbSymbolTable::add, DS.ARGS({ "val: PyDb.SymbolTableRecord" }, 9071))
	.def("has", &PyDbSymbolTable::has1)
	.def("has", &PyDbSymbolTable::has2, DS.ARGS({ "val: str|PyDb.ObjectId" }, 9074))
	.def("asDict", &PyDbSymbolTable::toDict, DS.ARGS())
	.def("toDict", &PyDbSymbolTable::toDict, DS.ARGS())
	.def("recordIds", &PyDbSymbolTable::recordIds, DS.ARGS())
	.def("desc", &PyDbSymbolTable::desc, DS.SARGS(15560)).staticmethod("desc")
	.def("cast", &PyDbSymbolTable::cast, DS.SARGS({ "otherObject: PyRx.RxObject" })).staticmethod("cast")
	.def("className", &PyDbSymbolTable::className, DS.SARGS()).staticmethod("className")
	.def("cloneFrom", &PyDbSymbolTable::cloneFrom, DS.SARGS({ "otherObject: PyRx.RxObject" })).staticmethod("cloneFrom")
	.def("__iter__", range(&PyDbSymbolTable::begin, &PyDbBlockTable::end))
	.def("__getitem__", &PyDbSymbolTable::getAt, DS.ARGS({ "val: str" }))
	.def("__contains__", &PyDbSymbolTable::has1)
	.def("__contains__", &PyDbSymbolTable::has2, DS.ARGS({ "val: str|PyDb.ObjectId" }))
	;
	}

I’m also limited on what I can throw from C++ into Python, I have to subclass std::exception and create an exception translator

PyRx/PyRxCore/PyException.h

Lines 137 to 160 in 5b04fc6

	class PyErrorStatusException : public std::exception
	{
	public:
	PyErrorStatusException(Acad::ErrorStatus es, const std::source_location& src = std::source_location::current());
	virtual ~PyErrorStatusException() noexcept override = default;
	virtual const char* what() const noexcept override;
	std::string fullmessage() const;
	std::string message() const;
	std::string format() const;
	Acad::ErrorStatus code() const;
	static PyObject* createPyErrorStatusExceptionClass();
	static void translatePyErrorStatusException(const PyErrorStatusException& e);
	static void makePyErrorStatusExceptionWrapper();
	private:
	void generateformat();
	// TODO: This will block unloading if we ever get that working?
	inline static PyObject* PyErrorStatusExceptionType = nullptr;
	private:
	pysource_location m_src;
	std::string m_fmt;
	Acad::ErrorStatus m_es = Acad::eNotImplemented;
	};

PyRx/PyRxCore/PyException.cpp

Lines 282 to 346 in 5b04fc6

	PyErrorStatusException::PyErrorStatusException(Acad::ErrorStatus es, const std::source_location& src /*= std::source_location::current()*/)
	: m_es(es), m_src(src)
	{
	generateformat();
	}
	const char* PyErrorStatusException::what() const noexcept
	{
	return m_fmt.c_str();
	}
	std::string PyErrorStatusException::fullmessage() const
	{
	return m_fmt;
	}
	Acad::ErrorStatus PyErrorStatusException::code() const
	{
	return m_es;
	}
	PyObject* PyErrorStatusException::createPyErrorStatusExceptionClass()
	{
	PyAutoLockGIL lock;
	constexpr const char* name = "ErrorStatusException";
	constexpr const char* qualifiedName = "PyDb.ErrorStatusException";
	PyObject* typeObj = PyErr_NewException(qualifiedName, PyExc_RuntimeError, 0);
	if (!typeObj)
	throw_error_already_set();
	scope().attr(name) = handle<>(borrowed(typeObj));
	return typeObj;
	}
	void PyErrorStatusException::translatePyErrorStatusException(const PyErrorStatusException& e)
	{
	PyAutoLockGIL lock;
	boost::python::object exc_t(handle<>(borrowed(PyErrorStatusException::PyErrorStatusExceptionType)));
	exc_t.attr("code") = object(e.code());
	exc_t.attr("message") = object(e.message());
	exc_t.attr("fullmessage") = object(e.fullmessage());
	PyErr_SetString(PyErrorStatusException::PyErrorStatusExceptionType, e.what());
	}
	std::string PyErrorStatusException::message() const
	{
	return wstr_to_utf8(acadErrorStatusText(m_es));
	}
	std::string PyErrorStatusException::format() const
	{
	return m_fmt;
	}
	void PyErrorStatusException::makePyErrorStatusExceptionWrapper()
	{
	PyErrorStatusException::PyErrorStatusExceptionType = PyErrorStatusException::createPyErrorStatusExceptionClass();
	register_exception_translator<PyErrorStatusException>(&PyErrorStatusException::translatePyErrorStatusException);
	}
	void PyErrorStatusException::generateformat()
	{
	constexpr std::string_view fmtstr("Exception!({}), function {}, Line {}, File {}: ");
	const auto& fname = formatfname(m_src.function_name());
	m_fmt = std::format(fmtstr, wstr_to_utf8(acadErrorStatusText(m_es)), fname.c_str(), m_src.line(), m_src.file_name());
	}

If I were to spend the time to create a specialized exception for KeyError, I don’t know if I can make it exactly the same
https://www.boost.org/doc/libs/1_80_0/libs/python/doc/html/reference/high_level_components/boost_python_exception_translato.html

[gswifort]

Looks like what we need. PyExc_KeyError exists.

[CEXT-Dan]

I'll try

[CEXT-Dan]

side note, you can use db.getBlocks

[CEXT-Dan]

works

from pyrx import Ap, Ax, Db, Ge


@Ap.Command()
def doit():
    try:
        db = Db.curDb()
        bt = Db.BlockTable(db.blockTableId())
        try:
            btr_id = bt["block_name"]
        except KeyError as e:
            print("Block not found", e)
    except Exception as err:
        print(err)

Block not found 'KeyError(block_name), function PyDbSymbolTable::getAtEx, Line 70, File PyDbSymbolTable.cpp: '

[CEXT-Dan]

I'll add it to PyDbDictionary

[CEXT-Dan]

I only see those two classes SymbolTable and Dictionary that have __getitem__ in the context of a dictionary. The rest are a context of an array index, but I'll certainly add ones I may have missed

[gswifort]

in the context of an array, an IndexError should be thrown

[CEXT-Dan]

test

@Ap.Command()
def doit():
    try:
        pnt = Ge.Point3d.kOrigin
        pnt[4]
    except Exception as err:
        traceback.print_exception(err)

[CEXT-Dan]

Boost has built-in translators for these, so I didn't write the error messages
edit (actually I did lol throw std::out_of_range{ "IndexError " }; )
std::out_of_range -> IndexError
std::runtime_error -> RuntimeError
std::invalid_argument -> ValueError

[CEXT-Dan]

should be good, I deleted my requirement to not use exceptions for code flow, I guess it's pretty common in python.