Method load_edges

raphtory/src/python/graph/graph.rs:877–965

(
        &self,
        data: &Bound<PyAny>,
        time: &str,
        src: &str,
        dst: &str,
        properties: Option<Vec<PyBackedStr>>,
        metadata: Option<Vec<PyBackedStr>>,
      

        signature = (data, time, src, dst, properties = None, metadata = None, shared_metadata = None, layer = None, layer_col = None, schema = None, csv_options = None, event_id = None)
    )]
    fn load_edges(
        &self,
        data: &Bound<PyAny>,
        time: &str,
        src: &str,
        dst: &str,
        properties: Option<Vec<PyBackedStr>>,
        metadata: Option<Vec<PyBackedStr>>,
        shared_metadata: Option<HashMap<String, Prop>>,
        layer: Option<&str>,
        layer_col: Option<&str>,
        schema: Option<Bound<PyAny>>,
        csv_options: Option<CsvReadOptions>,
        event_id: Option<&str>,
    ) -> Result<(), GraphError> {
        let properties = convert_py_prop_args(properties.as_deref()).unwrap_or_default();
        let metadata = convert_py_prop_args(metadata.as_deref()).unwrap_or_default();
        let column_schema = convert_py_schema(schema)?;
        if data.hasattr("__arrow_c_stream__")? {
            load_edges_from_arrow_c_stream(
                &self.graph,
                data,
                time,
                src,
                dst,
                &properties,
                &metadata,
                shared_metadata.as_ref(),
                layer,
                layer_col,
                column_schema,
                event_id,
            )
        } else if let Ok(path) = data.extract::<PathBuf>() {
            // extracting PathBuf handles Strings too
            let is_parquet = is_parquet_path(&path)?;
            let is_csv = is_csv_path(&path)?;

            // fail before loading anything at all to avoid loading partial data
            if !is_csv && csv_options.is_some() {
                return Err(GraphError::from(PyValueError::new_err(format!(
                    "CSV options were passed but no CSV files were detected at {}.",
                    path.display()
                ))));
            }

            // wrap in Arc to avoid cloning the entire schema for Parquet, CSV, and inner loops in CSV path
            let arced_schema = column_schema.map(Arc::new);

            // if-if instead of if-else to support directories with mixed parquet and CSV files
            if is_parquet {
                load_edges_from_parquet(
                    &self.graph,
                    &path,
                    ColumnNames::new(time, event_id, src, dst, layer_col),
                    true,
                    &properties,
                    &metadata,