Creating Factory classes with pyo3 using enums

[achapkowski]

Let's say I have multiple geometry classes and factory class in Python:

class Line: ...
class Point: ...
class Polygon: ...

and then in Python I create a factory:

class GeometryFactory(type):
   def __call__(cls, iterable=None, **kwargs):
        if iterable is None:
            iterable = {}
        if iterable['type'] == "point":
            cls = Point
        elif iterable['type'] == 'polygon':
            cls = Polygon
        elif ....:
        return type.__call__(cls, iterable, **kwargs)
class Geometry(metaclass=GeometryFactory):
   def __init__(self, iterable=None, **kwargs):
        if iterable is None:
            iterable = {}
        self.update(iterable)
        self.update(kwargs)
        self._properties = iterable
        super(Geometry, self).__init__(iterable, **kwargs)

What the code does is simply return the specific class based on something defined in the given data called iterable.

So if I give:

{'type' : "point", coords:[1,2]} it returns a Point class. It's pretty simple.

So my idea is that I wanted to do this via rust using enumeration

#[pyclass]
pub enum Geometry {
    Point(Point),
    Polyline(Polyline),
    Polygon(Polygon),
    Multipoint(Multipoint),
    Envelope(Envelope),
}

#[pymethods]
impl Geometry {
    #[new]
    fn new(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
        if let Ok(dict) = obj.downcast::<PyDict>() {
            if dict.contains("rings")? {
                return Ok(Geometry::Polygon(Polygon::from_dict(dict)?));
            } else if dict.contains("paths")? {
                return Ok(Geometry::Polyline(Polyline::from_dict(dict)?));
            } else if dict.contains("points")? {
                return Ok(Geometry::Multipoint(Multipoint::from_dict(dict)?));
            } else if dict.contains("x")? {
                return Ok(Geometry::Point(Point::from_dict(dict)?));
            } else if dict.contains("xmin")? {
                return Ok(Geometry::Envelope(Envelope::from_dict(dict)?));
            }
        }
        Err(PyBaseException::new_err(format!(
            "Could not convert object {:?} into a geometry",
            obj
        )))
    }

}

My issue is that is create an opaque object, and isn't using my defined classes. Can I use this pattern as a factory with pyo3?