docs_collection_t& collection,

strided_range_gt<ustore_key_t const> keys,

ustore_str_view_t field) {

status_t status;

ustore_length_t* found_offsets = nullptr;

ustore_length_t* found_lengths = nullptr;

ustore_bytes_ptr_t found_values = nullptr;

auto count = static_cast<ustore_size_t>(keys.size());

ustore_docs_read_t docs_read {};

docs_read.db = collection.db();

docs_read.error = status.member_ptr();

docs_read.options = ustore_option_dont_discard_memory_k;

docs_read.transaction = collection.txn();

docs_read.snapshot = collection.snap();

docs_read.arena = collection.member_arena();

docs_read.type = ustore_doc_field_json_k;

docs_read.tasks_count = count;

docs_read.collections = collection.member_ptr();

docs_read.keys = keys.begin().get();

docs_read.keys_stride = keys.stride();

docs_read.fields = &field;

docs_read.offsets = &found_offsets;

docs_read.lengths = &found_lengths;

docs_read.values = &found_values;

ustore_docs_read(&docs_read);

status.throw_unhandled();

return embedded_blobs_t {count, found_offsets, found_lengths, found_values};

strided_range_gt<ustore_key_t const> vertices,

ustore_vertex_role_t role,

ustore_str_view_t weight,

ustore_vertex_degree_t** degrees) {

status_t status;

ustore_key_t* edges_per_vertex = nullptr;

auto count = static_cast<ustore_size_t>(vertices.size());

ustore_graph_find_edges_t graph_find_edges {};

graph_find_edges.db = graph.index.db();

graph_find_edges.error = status.member_ptr();

graph_find_edges.transaction = graph.index.txn();

graph_find_edges.arena = graph.index.member_arena();

graph_find_edges.tasks_count = count;

graph_find_edges.collections = graph.index.member_ptr();

graph_find_edges.vertices = vertices.begin().get();

graph_find_edges.vertices_stride = vertices.stride();

graph_find_edges.roles = &role;

graph_find_edges.degrees_per_vertex = degrees;

graph_find_edges.edges_per_vertex = &edges_per_vertex;

ustore_graph_find_edges(&graph_find_edges);

status.throw_unhandled();

if (!weight)

return;

auto edges_begin = reinterpret_cast<edge_t*>(edges_per_vertex);

auto all_edges_count = transform_reduce_n(*degrees, count, 0ul, [](ustore_vertex_degree_t deg) {

return deg == ustore_vertex_degree_missing_k ? 0 : deg;

});

auto edges = edges_span_t {edges_begin, edges_begin + all_edges_count};

ustore_length_t* found_offsets = nullptr;

ustore_length_t* found_lengths = nullptr;

ustore_bytes_ptr_t found_values = nullptr;

auto values = read_attributes(graph.relations_attrs, edges.edge_ids.immutable(), weight);

auto value_iterator = values.begin();

for (std::size_t i = 0; i != count; ++i) {

auto edges_count = (*degrees)[i];

(*degrees)[i] = transform_reduce_n(value_iterator, edges_count, 0ul, [](value_view_t edge_weight) {

ustore_vertex_degree_t weight = 1;

std::from_chars(edge_weight.c_str(), edge_weight.c_str() + edge_weight.size(), weight);

return weight;

});

}

keys_stream_t native;

docs_collection_t& collection;

bool data;

std::string field;

std::string default_value;

embedded_blobs_t attrs;

ptr_range_gt<ustore_key_t const> nodes;

std::size_t index = 0;

nodes_stream_t(

keys_stream_t&& stream, docs_collection_t& col, bool data, std::string field, std::string default_value)

: native(std::move(stream)), collection(col), data(data), field(field), default_value(default_value) {

nodes = native.keys_batch();

if (data)

attrs = read_attributes(collection, nodes.strided(), field.size() ? field.c_str() : nullptr);

}

py::object next() {

if (index >= nodes.size()) {

if (native.is_end())

throw py::stop_iteration();

native.seek_to_next_batch();

nodes = native.keys_batch();

if (data)

attrs = read_attributes(collection, nodes.strided(), field.size() ? field.c_str() : nullptr);

index = 0;

}

py::object ret;

if (data) {

auto data = attrs[index] && !attrs[index].empty() ? attrs[index] : value_view_t(default_value);

ret = py::make_tuple(nodes[index], py::reinterpret_steal<py::object>(from_json(json_t::parse(data))));

}

else

ret = py::cast(nodes[index]);

++index;

return ret;

}

graph_stream_t native;

docs_collection_t& collection;

bool keys;

bool data;

std::string field;

std::string default_value;

embedded_blobs_t attrs;

edges_span_t edges;

std::size_t index = 0;

edges_stream_t(graph_stream_t&& stream,

docs_collection_t& col,

bool keys,

bool data,

std::string field,

std::string default_value)

: native(std::move(stream)), collection(col), keys(keys), data(data), field(field),

default_value(default_value) {

edges = native.edges_batch();

if (data)

attrs = read_attributes(collection, edges.edge_ids.immutable(), field.size() ? field.c_str() : nullptr);

}

py::object next() {

if (index >= edges.size()) {

if (native.is_end())

throw py::stop_iteration();

native.seek_to_next_batch();

edges = native.edges_batch();

if (data)

attrs = read_attributes(collection, edges.edge_ids.immutable(), field.size() ? field.c_str() : nullptr);

index = 0;

}

auto edge = edges[index];

py::object ret;

if (data) {

auto data = attrs[index] && !attrs[index].empty() ? attrs[index] : value_view_t(default_value);

py::object json = py::reinterpret_steal<py::object>(from_json(json_t::parse(data)));

ret = keys ? py::make_tuple(edge.source_id, edge.target_id, edge.id, json)

: py::make_tuple(edge.source_id, edge.target_id, json);

}

else

ret = keys ? py::make_tuple(edge.source_id, edge.target_id, edge.id)

: py::make_tuple(edge.source_id, edge.target_id);

++index;

return ret;

}

edges_span_t edges;

embedded_blobs_t attrs;

bool keys;

bool data;

std::string default_value;

std::size_t index = 0;

edges_nbunch_iter_t(

edges_span_t edges_span, embedded_blobs_t attributes, bool keys, bool data, std::string default_value)

: edges(edges_span), attrs(attributes), keys(keys), data(data), default_value(default_value) {}

py::object next() {

if (index == edges.size())

throw py::stop_iteration();

edge_t edge = edges[index];

py::object ret;

if (data) {

value_view_t data = attrs[index] && !attrs[index].empty() ? attrs[index] : value_view_t(default_value);

py::object json = py::reinterpret_steal<py::object>(from_json(json_t::parse(data)));

ret = keys ? py::make_tuple(edge.source_id, edge.target_id, edge.id, json)

: py::make_tuple(edge.source_id, edge.target_id, json);

}

else

ret = keys ? py::make_tuple(edge.source_id, edge.target_id, edge.id)

: py::make_tuple(edge.source_id, edge.target_id);

++index;

return ret;

}

keys_stream_t keys_stream;

py_graph_gt<type_ak>& graph;

std::string weight_field;

ustore_vertex_role_t vertex_role;

ptr_range_gt<ustore_key_t const> fetched_nodes;

ustore_vertex_degree_t* degrees = nullptr;

std::size_t index = 0;

degrees_stream_t(keys_stream_t&& stream, py_graph_gt<type_ak>& net, std::string field, ustore_vertex_role_t role)

: keys_stream(std::move(stream)), graph(net), weight_field(field), vertex_role(role) {

fetched_nodes = keys_stream.keys_batch();

compute_degrees(graph,

fetched_nodes,

vertex_role,

weight_field.size() ? weight_field.c_str() : nullptr,

&degrees);

}

py::object next() {

if (index >= fetched_nodes.size()) {

if (keys_stream.is_end())

throw py::stop_iteration();

keys_stream.seek_to_next_batch();

fetched_nodes = keys_stream.keys_batch();

compute_degrees(graph,

fetched_nodes,

vertex_role,

weight_field.size() ? weight_field.c_str() : nullptr,

&degrees);

index = 0;

}

auto ret = py::make_tuple(fetched_nodes[index], degrees[index]);

++index;

return ret;

}

keys_range_t native;

docs_collection_t& collection;

bool data = false;

std::string field;

std::string default_value;

nodes_range_t(keys_range_t n, docs_collection_t& c) : native(n), collection(c) {}

std::weak_ptr<py_graph_gt<type_ak>> net_ptr;

std::vector<ustore_key_t> vertices;

bool keys = false;

bool data = false;

std::string field;

std::string default_value;

std::weak_ptr<py_graph_gt<type_ak>> net_ptr;

ustore_vertex_role_t roles = ustore_vertex_role_any_k;

std::string weight = "";

py_buffer_memory_t& buf = g.last_buffer;

buf.strides[0] = range.stride();

buf.strides[1] = buf.strides[2] = 1;

buf.shape[0] = range.size();

buf.shape[1] = buf.shape[2] = 1;

// https://docs.python.org/3/c-api/buffer.html

buf.raw.buf = (void*)range.begin().get();

buf.raw.obj = NULL;

buf.raw.len = range.size() * sizeof(element_at);

buf.raw.itemsize = sizeof(element_at);

// https://docs.python.org/3/library/struct.html#format-characters

buf.raw.format = (char*)&format_code_gt<std::remove_const_t<element_at>>::value[0];

buf.raw.ndim = 1;

buf.raw.shape = &buf.shape[0];

buf.raw.strides = &buf.strides[0];

buf.raw.suboffsets = nullptr;

buf.raw.readonly = true;

buf.raw.internal = nullptr;

PyObject* obj = PyMemoryView_FromBuffer(&buf.raw);

return py::reinterpret_steal<py::object>(obj);

return nodes_stream_t<type_ak> {std::move(range.native).begin(),

range.collection,

range.data,

range.field,

range.default_value};

range.data = data;

range.default_value = "{}";

return range.shared_from_this();

range.data = true;

range.field = data;

std::string str;

to_string(def_value.ptr(), str);

range.default_value = std::move(str);

return range.shared_from_this();

py_graph_gt<type_ak>& g = *range.net_ptr.lock().get();

if (range.vertices.size()) {

auto vertices = strided_range(range.vertices).immutable();

auto role = ustore_vertex_source_k;

auto edges = g.ref().edges_containing(vertices, {{&role}, 1}).throw_or_release();

auto attrs = read_attributes(g.relations_attrs,

edges.edge_ids.immutable(),

range.field.size() ? range.field.c_str() : nullptr);

return py::cast(edges_nbunch_iter_t<type_ak>(edges, attrs, range.keys, range.data, range.default_value));

}

auto edges = g.ref().edges(ustore_vertex_source_k).throw_or_release();

return py::cast(edges_stream_t<type_ak>(std::move(edges).begin(),

g.relations_attrs,

range.keys,

range.data,

range.field,

range.default_value));

range.keys = keys;

if (type_ak == graph_k || type_ak == digraph_k)

range.keys = false;

range.data = data;

range.default_value = "{}";

return range.shared_from_this();

range.keys = keys;

if (type_ak == graph_k || type_ak == digraph_k)

range.keys = false;

range.data = true;

range.field = data;

std::string str;

to_string(def_value.ptr(), str);

range.default_value = std::move(str);

return range.shared_from_this();

range.keys = keys;

if (type_ak == graph_k || type_ak == digraph_k)

range.keys = false;

range.data = data;

range.default_value = "{}";

if (PyNumber_Check(vs.ptr()))

range.vertices.push_back(py_to_scalar<ustore_key_t>(vs.ptr()));

else {

range.vertices.resize(PySequence_Size(vs.ptr()));

py_transform_n(vs.ptr(), &py_to_scalar<ustore_key_t>, range.vertices.begin());

}

return range.shared_from_this();

edges_range_t<type_ak>& range, py::object vs, std::string data, py::object def_value, bool keys = false) {

range.keys = keys;

if (type_ak == graph_k || type_ak == digraph_k)

range.keys = false;

range.data = true;

range.field = data;

std::string str;

to_string(def_value.ptr(), str);

range.default_value = std::move(str);

if (PyNumber_Check(vs.ptr()))

range.vertices.push_back(py_to_scalar<ustore_key_t>(vs.ptr()));

else {

range.vertices.resize(PySequence_Size(vs.ptr()));

py_transform_n(vs.ptr(), &py_to_scalar<ustore_key_t>, range.vertices.begin());

}

return range.shared_from_this();

auto& g = *degs.net_ptr.lock().get();

auto result = g.ref().degree(v, degs.roles).throw_or_release();

return result;

auto& g = *degs.net_ptr.lock().get();

ustore_vertex_degree_t* degrees;

if (PyObject_CheckBuffer(vs.ptr())) {

auto vs_handle = py_buffer(vs.ptr());

auto vertices = py_strided_range<ustore_key_t const>(vs_handle);

compute_degrees(g, vertices, degs.roles, weight.size() ? weight.c_str() : nullptr, &degrees);

return wrap_into_buffer<type_ak, ustore_vertex_degree_t const>(

g,

strided_range<ustore_vertex_degree_t const>(degrees, degrees + vertices.size()));

}

if (!PySequence_Check(vs.ptr()))

throw std::invalid_argument("Nodes Must Be Sequence");

std::vector<ustore_key_t> vertices(PySequence_Size(vs.ptr()));

py_transform_n(vs.ptr(), &py_to_scalar<ustore_key_t>, vertices.begin());

compute_degrees(g,

strided_range(vertices).immutable(),

degs.roles,

weight.size() ? weight.c_str() : nullptr,

&degrees);

py::list res(vertices.size());

for (std::size_t i = 0; i != vertices.size(); ++i)

res[i] = py::make_tuple(vertices[i], degrees[i]);

return py::object(res);

auto& g = *degs.net_ptr.lock().get();

blobs_range_t members(g.index.db(), g.index.txn(), 0, g.index);

keys_stream_t stream = keys_range_t({members}).begin();

return degrees_stream_t(std::move(stream), g, degs.weight, degs.roles);

py_graph_gt<type_ak>& g,

strided_range_gt<ustore_key_t const> keys,

std::shared_ptr<arrow::Array> values,

std::string_view attr) {

auto numeric_values = std::static_pointer_cast<array_at>(values);

std::string jsons_str;

jsons_str.reserve(keys.size() * (attr.size() + 4));

std::vector<ustore_length_t> offsets(keys.size() + 1);

for (size_t idx = 0; idx != keys.size(); idx++) {

offsets[idx] = jsons_str.size();

fmt::format_to(std::back_inserter(jsons_str), "{{\"{}\": {}}}", attr.data(), numeric_values->Value(idx));

}

offsets.back() = jsons_str.size();

contents_arg_t contents {};

contents.offsets_begin = {offsets.data(), sizeof(ustore_length_t)};

auto vals_begin = reinterpret_cast<ustore_bytes_ptr_t>(jsons_str.data());

contents.contents_begin = {&vals_begin, 0};

g.relations_attrs[keys].merge(contents).throw_unhandled();

py_graph_gt<type_ak>& g,

strided_range_gt<ustore_key_t const> keys,

std::shared_ptr<arrow::Array> values,

std::string_view attr) {

auto binary_values = std::static_pointer_cast<arrow::BinaryArray>(values);

std::string jsons_str;

jsons_str.reserve(keys.size() * (attr.size() + 4));

std::vector<ustore_length_t> offsets(keys.size() + 1);

for (size_t idx = 0; idx != keys.size(); idx++) {

offsets[idx] = jsons_str.size();

auto value = binary_values->Value(idx);

fmt::format_to(std::back_inserter(jsons_str),

"{{\"{}\":\"{}\"}}",

attr.data(),

std::string_view(value.data(), value.size()));

}

offsets.back() = jsons_str.size();

contents_arg_t contents {};

contents.offsets_begin = {offsets.data(), sizeof(ustore_length_t)};

auto vals_begin = reinterpret_cast<ustore_bytes_ptr_t>(jsons_str.data());

contents.contents_begin = {&vals_begin, 0};

g.relations_attrs[keys].merge(contents).throw_unhandled();

std::optional<std::string> index,

std::optional<std::string> vertices_attrs,

std::optional<std::string> relations_attrs) {

if (!py_db)

return std::shared_ptr<py_graph_gt<type_ak>> {};

auto net_ptr = std::make_shared<py_graph_gt<type_ak>>();

net_ptr->py_db_ptr = py_db;

// Attach the primary collection

database_t& db = py_db->native;

net_ptr->index = db.find_or_create(index ? index->c_str() : "").throw_or_release();

// Attach the additional collections

if (vertices_attrs)

net_ptr->vertices_attrs = db.find_or_create<docs_collection_t>(vertices_attrs->c_str()).throw_or_release();

if (relations_attrs)

net_ptr->relations_attrs = db.find_or_create<docs_collection_t>(relations_attrs->c_str()).throw_or_release();

return net_ptr;

auto degs_ptr = std::make_unique<degree_view_t<type_ak>>();

degs_ptr->net_ptr = g.shared_from_this();

degs_ptr->roles = ustore_vertex_role_any_k;

return degs_ptr;

auto degs_ptr = std::make_unique<degree_view_t<type_ak>>();

degs_ptr->net_ptr = g.shared_from_this();

degs_ptr->roles = ustore_vertex_target_k;

return degs_ptr;

auto degs_ptr = std::make_unique<degree_view_t<type_ak>>();

degs_ptr->net_ptr = g.shared_from_this();

degs_ptr->roles = ustore_vertex_source_k;

return degs_ptr;

if (!weight.size())

return g.ref().number_of_edges();

std::size_t size = 0;

auto stream = g.ref().edges(ustore_vertex_source_k).throw_or_release().begin();

while (!stream.is_end()) {

auto edge_ids = stream.edges_batch().edge_ids.immutable();

auto attrs = read_attributes(g.relations_attrs, edge_ids, weight.c_str());

for (std::size_t i = 0; i != edge_ids.size(); ++i) {

if (attrs[i] && attrs[i].size()) {

std::size_t number = 0;

auto result = std::from_chars((char*)attrs[i].begin(), (char*)attrs[i].end(), number);

if (result.ec == std::errc())

size += number;

else if (result.ec == std::errc::invalid_argument)

throw std::runtime_error("Unsupported Type");

else

throw std::runtime_error("Failed To Read Attribute");

}

else

size += 1;

}

stream.seek_to_next_batch();

}

return size;

blobs_range_t members(g.index.db(), g.index.txn(), 0, g.index);

keys_range_t keys {members};

auto range = std::make_shared<nodes_range_t<type_ak>>(keys, g.vertices_attrs);

return range;

auto maybe = g.ref().contains(v);

maybe.throw_unhandled();

return *maybe;

if (type_ak == digraph_k || type_ak == multidigraph_k)

return g.ref().edges_between(v1, v2).throw_or_release().size() != 0;

return g.ref().edges_between(v1, v2).throw_or_release().size() != 0 ||

g.ref().edges_between(v2, v1).throw_or_release().size() != 0;

auto edges_ptr = std::make_shared<edges_range_t<type_ak>>();

edges_ptr->net_ptr = g.shared_from_this();

return edges_ptr;

if (type_ak == graph_k || type_ak == multigraph_k)

return wrap_into_buffer(g, g.ref().neighbors(n).throw_or_release());

return wrap_into_buffer(g, g.ref().neighbors(n, ustore_vertex_source_k).throw_or_release());

graph_collection_t graph = g.ref();

auto partition = best_partition(graph);

return py::cast(partition);

std::string json_to_merge;

if (PyDict_Check(obj.ptr())) {

PyObject *key, *value;

Py_ssize_t pos = 0;

while (PyDict_Next(obj.ptr(), &pos, &key, &value)) {

json_to_merge.clear();

auto vertex = py_to_scalar<ustore_key_t>(key);

if (!PyDict_Check(value)) {

fmt::format_to(std::back_inserter(json_to_merge), "{{\"{}\":", name.value());

to_string(value, json_to_merge);

json_to_merge += "}";

}

else

to_string(value, json_to_merge);

g.vertices_attrs[vertex].merge(json_to_merge.c_str());

}

}

else {

if (!name)

throw std::invalid_argument("Invalid Argument");

fmt::format_to(std::back_inserter(json_to_merge), "{{\"{}\":", name.value());

to_string(obj.ptr(), json_to_merge);

json_to_merge += "}";

auto stream = g.ref().vertex_stream().throw_or_release();

while (!stream.is_end()) {

g.vertices_attrs[stream.keys_batch().strided()].merge(json_to_merge.c_str());

stream.seek_to_next_batch();

}

}

std::unordered_map<ustore_key_t, py::object> map;

auto stream = g.ref().vertex_stream().throw_or_release();

while (!stream.is_end()) {

auto keys = stream.keys_batch().strided();

auto attrs = read_attributes(g.vertices_attrs, keys, name.c_str());

for (std::size_t i = 0; i != keys.size(); ++i)

map[keys[i]] = py::reinterpret_steal<py::object>(from_json(json_t::parse(attrs[i])));

stream.seek_to_next_batch();

}

return py::cast(map);

std::string default_value_str;

to_string(default_value.ptr(), default_value_str);

auto edges = g.ref().edges_between(v1, v2).throw_or_release();

if (!edges.size())

return py::none();

auto edge_ids = edges.edge_ids.immutable();

auto attrs = read_attributes(g.relations_attrs, edge_ids, nullptr);

if (attrs[0] && attrs[0].size())

return py::reinterpret_steal<py::object>(from_json(json_t::parse(attrs[0])));

if (default_value_str.size())

return py::reinterpret_steal<py::object>(from_json(json_t::parse(default_value_str)));

return py::dict();

auto hash = [](py::tuple const& tuple) {

return py_to_scalar<ustore_key_t>(PyTuple_GetItem(tuple.ptr(), 2));

};

std::unordered_map<py::tuple, py::object, decltype(hash)> map(0, hash);

auto stream = g.ref().edges().throw_or_release().begin();

while (!stream.is_end()) {

auto edges = stream.edges_batch();

map.reserve(edges.size());

auto sources = edges.source_ids;

auto targets = edges.target_ids;

auto edge_ids = edges.edge_ids.immutable();

auto attrs = read_attributes(g.relations_attrs, edge_ids, name.c_str());

for (std::size_t i = 0; i != edge_ids.size(); ++i) {

auto key = py::make_tuple(sources[i], targets[i], edge_ids[i]);

if (attrs[i] && attrs[i].size())

map[key] = py::reinterpret_steal<py::object>(from_json(json_t::parse(attrs[i])));

else

map[key] = py::dict();

}

stream.seek_to_next_batch();

}

return py::cast(map);

std::string json_to_merge;

if (PyDict_Check(obj.ptr())) {

PyObject *key, *value;

Py_ssize_t pos = 0;

while (PyDict_Next(obj.ptr(), &pos, &key, &value)) {

json_to_merge.clear();

if (!PyTuple_Check(key) || PyTuple_Size(key) != 3)

throw std::invalid_argument("Invalid Argument");

auto attr_key = py_to_scalar<ustore_key_t>(PyTuple_GetItem(key, 2));

if (!PyDict_Check(value)) {

fmt::format_to(std::back_inserter(json_to_merge), "{{\"{}\":", name.value());

to_string(value, json_to_merge);

json_to_merge += "}";

}

else

to_string(value, json_to_merge);

g.relations_attrs[attr_key].merge(json_to_merge.c_str());

}

}

else {

if (!name)

throw std::invalid_argument("Invalid Argument");

fmt::format_to(std::back_inserter(json_to_merge), "{{\"{}\":", name.value());

to_string(obj.ptr(), json_to_merge);

json_to_merge += "}";

auto stream = g.ref().edges().throw_or_release().begin();

while (!stream.is_end()) {

g.relations_attrs[stream.edges_batch().edge_ids].merge(json_to_merge.c_str());

stream.seek_to_next_batch();

}

}

auto ids_handle = py_buffer(vs);

auto ids = py_strided_range<ustore_key_t const>(ids_handle);

auto result = g.ref().contains(ids).throw_or_release();

py::array_t<ustore_key_t> res_array(ids.size());

size_t j = 0;

for (size_t i = 0; i < ids.size(); i++)

if (result[i])

res_array.mutable_at(j++) = ids[i];

res_array.resize(py::array::ShapeContainer({std::max<size_t>(j, 1) - 1}));

return res_array;

g.ref().upsert_vertex(v).throw_unhandled();

if (!attrs.size())

return;

std::string json_str;

to_string(attrs.ptr(), json_str);

g.vertices_attrs[v].assign(value_view_t(json_str)).throw_unhandled();

py_graph_gt<type_ak>& g, ustore_key_t v1, ustore_key_t v2, std::optional<ustore_key_t> e, py::kwargs const& attrs) {

ustore_key_t key;

if (!e) {

if (type_ak == multigraph_k || type_ak == multidigraph_k) {

key = g.get_key();

auto had_keys = g.ref().edges_between(v1, v2).throw_or_release().edge_ids;

while (std::find(had_keys.begin(), had_keys.end(), key) != std::end(had_keys))

key = g.get_key();

}

else

key = edge_id(v1, v2);

}

else

key = *e;

g.ref().upsert_edge(edge_t {v1, v2, key}).throw_unhandled();

if (!attrs.size())

return;

std::string json_str;

to_string(attrs.ptr(), json_str);

g.relations_attrs[key].merge(value_view_t(json_str)).throw_unhandled();

g.ref().remove_vertex(v).throw_unhandled();

if (g.vertices_attrs.db())

g.vertices_attrs[v].clear().throw_unhandled();

ustore_key_t key;

if (!e) {

if (type_ak == multigraph_k || type_ak == multidigraph_k) {

auto edge_ids = g.ref().edges_between(v1, v2).throw_or_release().edge_ids;

key = edge_ids[edge_ids.size() - 1];

}

else

key = edge_id(v1, v2);

}

else

key = *e;

g.ref().remove_edge(edge_t {v1, v2, key}).throw_unhandled();

if (g.relations_attrs.db())

g.relations_attrs[key].clear().throw_unhandled();

if (PyObject_CheckBuffer(vs.ptr())) {

py_buffer_t buf = py_buffer(vs.ptr());

if (!can_cast_internal_scalars<ustore_key_t>(buf))

throw std::invalid_argument("Expecting @c ustore_key_t scalars in zero-copy interface");

auto vertices = py_strided_range<ustore_key_t const>(buf);

g.ref().upsert_vertices(vertices).throw_unhandled();

if (!attrs.size())

return;

std::string json_str;

to_string(attrs.ptr(), json_str);

g.vertices_attrs[vertices].assign(value_view_t(json_str)).throw_unhandled();

}

else {

if (!PySequence_Check(vs.ptr()))

throw std::invalid_argument("Nodes Must Be Sequence");

std::vector<ustore_key_t> vertices(PySequence_Size(vs.ptr()));

py_transform_n(vs.ptr(), &py_to_scalar<ustore_key_t>, vertices.begin());

g.ref().upsert_vertices(vertices).throw_unhandled();

if (!attrs.size())

return;

std::string json_str;

to_string(attrs.ptr(), json_str);

g.vertices_attrs[vertices].assign(value_view_t(json_str)).throw_unhandled();

}

if (PyObject_CheckBuffer(vs.ptr())) {

py_buffer_t buf = py_buffer(vs.ptr());

if (!can_cast_internal_scalars<ustore_key_t>(buf))

throw std::invalid_argument("Expecting @c ustore_key_t scalars in zero-copy interface");

auto vertices = py_strided_range<ustore_key_t const>(buf);

g.ref().remove_vertices(vertices).throw_unhandled();

if (g.vertices_attrs.db())

g.vertices_attrs[vertices].clear().throw_unhandled();

}

else {

if (!PySequence_Check(vs.ptr()))

throw std::invalid_argument("Nodes Must Be Sequence");

std::vector<ustore_key_t> vertices(PySequence_Size(vs.ptr()));

py_transform_n(vs.ptr(), &py_to_scalar<ustore_key_t>, vertices.begin());

g.ref().remove_vertices(vertices).throw_unhandled();

if (g.vertices_attrs.db())

g.vertices_attrs[vertices].clear().throw_unhandled();

}

auto graph = g.ref();

edges_view_t edges = parsed_adjacency_list_t(v1s.ptr(), v2s.ptr(), Py_None);

auto length = edges.size();

std::vector<ustore_key_t> keys(length);

if (type_ak == multigraph_k || type_ak == multidigraph_k) {

for (std::size_t i = 0; i != length; ++i) {

auto key = g.get_key();

auto had_keys = graph.edges_between(edges.source_ids[i], edges.target_ids[i]).throw_or_release().edge_ids;

while (std::find(had_keys.begin(), had_keys.end(), key) != std::end(had_keys))

key = g.get_key();

keys[i] = key;

}

}

else

for (std::size_t i = 0; i != length; ++i)

keys[i] = edge_id(edges.source_ids[i], edges.target_ids[i]);