graph_python_interface.hh 20.1 KB
Newer Older
1
2
// graph-tool -- a general graph modification and manipulation thingy
//
Tiago Peixoto's avatar
Tiago Peixoto committed
3
// Copyright (C) 2006-2016 Tiago de Paula Peixoto <tiago@skewed.de>
4
5
6
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
Tiago Peixoto's avatar
Tiago Peixoto committed
7
// as published by the Free Software Foundation; either version 3
8
9
10
11
12
13
14
15
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
16
// along with this program. If not, see <http://www.gnu.org/licenses/>.
17

18
19
#ifndef PYTHON_INTERFACE_HH
#define PYTHON_INTERFACE_HH
20

21
22
23
#include <boost/python.hpp>
#include <boost/python/type_id.hpp>

Tiago Peixoto's avatar
Tiago Peixoto committed
24
25
26
27
28
29
30
31
32
#include <functional>

namespace std
{
    template<>
    struct hash<boost::python::object>
    {
        size_t operator()(const boost::python::object& o) const
        {
33
            return std::hash<int64_t>()(boost::python::extract<int64_t>(o.attr("__hash__")()));
Tiago Peixoto's avatar
Tiago Peixoto committed
34
35
36
37
        }
    };
}

38
39
#include <boost/graph/graph_traits.hpp>
#include <boost/mpl/logical.hpp>
40
#include <boost/iterator/iterator_facade.hpp>
41

Tiago Peixoto's avatar
Tiago Peixoto committed
42
43
#include <type_traits>

44
45
#include "graph.hh"
#include "graph_filtering.hh"
46
#include "graph_selectors.hh"
47
#include "numpy_bind.hh"
48

49
50
51
#ifdef HAVE_BOOST_COROUTINE
#include <boost/coroutine/all.hpp>
#endif // HAVE_BOOST_COROUTINE
52

53
// This file includes a simple python interface for the internally kept
54
55
56
57
// graph. It defines a PythonVertex, PythonEdge and PythonIterator template
// classes, which contain the proper member functions for graph traversal. These
// types are then specialized for each version of the adapted graph (directed,
// undirected, filtered, reversed).
58

59
60
61
namespace graph_tool
{

62
63
// generic iterator adaptor which can be used to iterate vertices, edges,
// out_edges and in_edges through python
64
template <class Graph, class Descriptor, class Iterator>
65
class PythonIterator
66
{
67
public:
68
69
70
71
    PythonIterator() = delete;
    explicit PythonIterator(const std::weak_ptr<Graph>& gp,
                            const std::pair<Iterator,Iterator>& range)
        : _g(gp), _range(range) {}
72
    Descriptor next()
73
    {
74
        if (_range.first == _range.second || _g.expired())
Tiago Peixoto's avatar
Tiago Peixoto committed
75
            boost::python::objects::stop_iteration_error();
76
        return Descriptor(_g, *(_range.first++));
77
78
    }
private:
79
80
    std::weak_ptr<Graph> _g;
    std::pair<Iterator,Iterator> _range;
Tiago Peixoto's avatar
Tiago Peixoto committed
81
82
};

83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#ifdef HAVE_BOOST_COROUTINE

// generic coroutine generator adaptor

typedef boost::coroutines::asymmetric_coroutine<boost::python::object> coro_t;

class CoroGenerator
{
public:
    template <class Dispatch>
    CoroGenerator(Dispatch& dispatch)
        : _coro(std::make_shared<coro_t::pull_type>(dispatch)),
          _iter(begin(*_coro)), _end(end(*_coro)) {}
    boost::python::object next()
    {
        if (_iter == _end)
            boost::python::objects::stop_iteration_error();
        boost::python::object oe = *_iter;
        ++_iter;
        return oe;
    }
private:
    std::shared_ptr<coro_t::pull_type> _coro;
    coro_t::pull_type::iterator _iter;
    coro_t::pull_type::iterator _end;
};

#endif // HAVE_BOOST_COROUTINE
Tiago Peixoto's avatar
Tiago Peixoto committed
111

112
// forward declaration of PythonEdge
113
114
template <class Graph>
class PythonEdge;
115

116
117
class VertexBase {}; // useful to unite all vertex

118
// below are classes related to the PythonVertex type
119
120
template <class Graph>
class PythonVertex : public VertexBase
121
122
{
public:
123
    PythonVertex(std::weak_ptr<Graph> g, GraphInterface::vertex_t v):
124
        _g(g), _v(v) {}
125

126
    bool is_valid() const
127
    {
128
        if (_g.expired())
129
            return false;
130
131
132
        std::shared_ptr<Graph> gp = _g.lock();
        Graph& g = *gp.get();
        return _v < num_vertices(g);
133
    }
134

135
    void check_valid() const
136
    {
137
        if (!is_valid())
138
            throw ValueException("invalid vertex descriptor: " +
Tiago Peixoto's avatar
Tiago Peixoto committed
139
                                 boost::lexical_cast<string>(_v));
140
    }
141

142
    GraphInterface::vertex_t get_descriptor() const
143
144
145
146
    {
        return _v;
    }

147
148
149
    template <class DegSelector>
    struct get_degree
    {
150
        void operator()(const Graph& g,
Tiago Peixoto's avatar
Tiago Peixoto committed
151
                        typename boost::graph_traits<Graph>::vertex_descriptor v,
152
153
                        size_t& deg) const
        {
154
            deg = DegSelector()(v, g);
155
        }
156

157
        template<class PMap>
158
159
        void operator()(const Graph& g,
                        typename boost::graph_traits<Graph>::vertex_descriptor v,
160
                        const PMap& weight, boost::python::object& deg) const
161
        {
162
            deg = boost::python::object(DegSelector()(v, g, weight));
163
        }
164
165
    };

166
    size_t get_in_degree() const
167
    {
168
        check_valid();
169
        std::shared_ptr<Graph> gp = _g.lock();
170
        Graph& g = *gp.get();
171
        size_t in_deg;
172
        get_degree<in_degreeS>()(g, _v, in_deg);
173
        return in_deg;
174
    }
175

176
    boost::python::object get_weighted_in_degree(boost::any pmap) const
177
    {
178
179
        check_valid();
        std::shared_ptr<Graph> gp = _g.lock();
180
        Graph& g = *gp.get();
181
        boost::python::object in_deg;
182
        if (!belongs<edge_scalar_properties>()(pmap))
183
            throw ValueException("edge weight property must be of scalar type");
184
185
186
187
188
        gt_dispatch<>()(std::bind(get_degree<in_degreeS>(),
                                  std::ref(g), _v,
                                  std::placeholders::_1,
                                  std::ref(in_deg)),
                        edge_scalar_properties())(pmap);
189
190
191
        return in_deg;
    }

192
    size_t get_out_degree() const
193
    {
194
        check_valid();
195
        std::shared_ptr<Graph> gp = _g.lock();
196
        Graph& g = *gp.get();
197
        size_t out_deg;
198
        get_degree<out_degreeS>()(g, _v, out_deg);
199
        return out_deg;
Tiago Peixoto's avatar
Tiago Peixoto committed
200
201
    }

202

203
    boost::python::object get_weighted_out_degree(boost::any pmap) const
204
    {
205
206
        check_valid();
        std::shared_ptr<Graph> gp = _g.lock();
207
        Graph& g = *gp.get();
208
        boost::python::object out_deg;
209
        if (!belongs<edge_scalar_properties>()(pmap))
210
            throw ValueException("edge weight property must be of scalar type");
211
212
213
214
215
        gt_dispatch<>()(std::bind(get_degree<out_degreeS>(),
                                  std::ref(g), _v,
                                  std::placeholders::_1,
                                  std::ref(out_deg)),
                        edge_scalar_properties())(pmap);
216
217
218
        return out_deg;
    }

219
    // provide iterator support for out_edges
220
    boost::python::object out_edges() const
Tiago Peixoto's avatar
Tiago Peixoto committed
221
    {
222
        check_valid();
223
224
        std::shared_ptr<Graph> gp = _g.lock();
        Graph& g = *gp.get();
225
226
227
228
        typedef typename boost::graph_traits<Graph>::out_edge_iterator
            out_edge_iterator;
        return boost::python::object(PythonIterator<Graph,PythonEdge<Graph>,
                                                    out_edge_iterator>
229
                                     (_g, boost::out_edges(_v, g)));
230
    }
231

232
    boost::python::object in_edges() const
233
    {
234
        check_valid();
235
236
        std::shared_ptr<Graph> gp = _g.lock();
        Graph& g = *gp.get();
237
238
239
240
        typedef typename in_edge_iteratorS<Graph>::type
            in_edge_iterator;
        return boost::python::object(PythonIterator<Graph, PythonEdge<Graph>,
                                                    in_edge_iterator>
241
                                     (_g, in_edge_iteratorS<Graph>::get_edges(_v, g)));
Tiago Peixoto's avatar
Tiago Peixoto committed
242
    }
243

244
    std::string get_string() const
245
    {
246
        check_valid();
Tiago Peixoto's avatar
Tiago Peixoto committed
247
        return boost::lexical_cast<std::string>(_v);
248
249
    }

250
    size_t get_hash() const
251
    {
Tiago Peixoto's avatar
Tiago Peixoto committed
252
        return std::hash<size_t>()(_v);
253
254
    }

255
    size_t get_index() const
256
    {
257
        return _v;
258
259
    }

260
    size_t get_graph_ptr() const
261
    {
262
263
264
265
        if (_g.expired())
            return 0;
        std::shared_ptr<Graph> gp = _g.lock();
        return size_t(gp.get());
266
267
    }

268
    std::string get_graph_type() const
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
    {
        using boost::python::detail::gcc_demangle;
        return gcc_demangle(typeid(Graph).name());
    }

    template <class OGraph>
    bool operator==(const PythonVertex<OGraph>& other) const { return _v == other._v; }
    template <class OGraph>
    bool operator!=(const PythonVertex<OGraph>& other) const { return _v != other._v; }
    template <class OGraph>
    bool operator<(const PythonVertex<OGraph>& other) const { return _v < other._v; }
    template <class OGraph>
    bool operator<=(const PythonVertex<OGraph>& other) const { return _v <= other._v; }
    template <class OGraph>
    bool operator>(const PythonVertex<OGraph>& other) const { return _v > other._v; }
    template <class OGraph>
    bool operator>=(const PythonVertex<OGraph>& other) const { return _v >= other._v; }

287
private:
288
    std::weak_ptr<Graph> _g;
289
    GraphInterface::vertex_t _v;
290
};
291

292
// below are classes related to the PythonEdge type
293

294
295
class EdgeBase {}; // useful to unite all edge types

296
template <class Graph>
297
class PythonEdge : public EdgeBase
298
299
{
public:
Tiago Peixoto's avatar
Tiago Peixoto committed
300
    typedef typename boost::graph_traits<Graph>::edge_descriptor edge_descriptor;
301
    PythonEdge(std::weak_ptr<Graph> g, edge_descriptor e)
302
        : _g(g), _e(e) {}
303

304
    bool is_valid() const
Tiago Peixoto's avatar
Tiago Peixoto committed
305
    {
306
        if (_g.expired())
307
            return false;
308
309
        std::shared_ptr<Graph> gp = _g.lock();
        Graph& g = *gp.get();
310

311
312
        auto s = source(_e, g);
        auto t = target(_e, g);
313

314
        return ((s < num_vertices(g)) && (t < num_vertices(g)));
315
316
    }

317
    void check_valid() const
318
    {
319
        if (!is_valid())
Tiago Peixoto's avatar
Tiago Peixoto committed
320
            throw ValueException("invalid edge descriptor");
Tiago Peixoto's avatar
Tiago Peixoto committed
321
322
    }

323
    GraphInterface::edge_t get_descriptor() const
324
325
326
327
    {
        return _e;
    }

328
    PythonVertex<Graph> get_source() const
329
    {
330
        check_valid();
331
332
333
        std::shared_ptr<Graph> gp = _g.lock();
        Graph& g = *gp.get();
        return PythonVertex<Graph>(gp, source(_e, g));
334
    }
335

336
    PythonVertex<Graph> get_target() const
Tiago Peixoto's avatar
Tiago Peixoto committed
337
    {
338
        check_valid();
339
340
341
        std::shared_ptr<Graph> gp = _g.lock();
        Graph& g = *gp.get();
        return PythonVertex<Graph>(gp, target(_e, g));
Tiago Peixoto's avatar
Tiago Peixoto committed
342
343
    }

344
    std::string get_string() const
345
    {
346
        check_valid();
347
348
        std::shared_ptr<Graph> gp = _g.lock();
        Graph& g = *gp.get();
349
350
351
352
353
        auto s = source(_e, g);
        auto t = target(_e, g);
        return "(" + boost::lexical_cast<std::string>(s) + ", "
            + boost::lexical_cast<std::string>(t) + ")";
    }
354

355
    size_t get_hash() const
Tiago Peixoto's avatar
Tiago Peixoto committed
356
    {
357
        check_valid();
358
359
        std::shared_ptr<Graph> gp = _g.lock();
        Graph& g = *gp.get();
360
361
        auto eindex = get(boost::edge_index_t(), g);
        return std::hash<size_t>()(eindex[_e]);
Tiago Peixoto's avatar
Tiago Peixoto committed
362
363
    }

364
    size_t get_graph_ptr() const
365
    {
366
367
368
369
        if (_g.expired())
            return 0;
        std::shared_ptr<Graph> gp = _g.lock();
        return size_t(gp.get());
370
371
    }

372
    std::string get_graph_type() const
373
374
375
376
377
378
379
380
381
382
383
    {
        using boost::python::detail::gcc_demangle;
        return gcc_demangle(typeid(Graph).name());
    }

    template <class OGraph>
    bool operator==(const PythonEdge<OGraph>& other) const { return _e == other._e; }
    template <class OGraph>
    bool operator!=(const PythonEdge<OGraph>& other) const { return !(*this == other); }
    template <class OGraph>
    bool operator<(const PythonEdge<OGraph>& other)  const
Tiago Peixoto's avatar
Tiago Peixoto committed
384
    {
385
386
        check_valid();
        other.check_valid();
387
388
        Graph& g = *std::shared_ptr<Graph>(_g);
        OGraph& og = *std::shared_ptr<OGraph>(other._g);
389
390
391
        auto eindex = get(boost::edge_index_t(), g);
        auto eindex2 = get(boost::edge_index_t(), og);
        return eindex[_e] < eindex2[other._e];
Tiago Peixoto's avatar
Tiago Peixoto committed
392
    }
393
394
395
396
397
398
    template <class OGraph>
    bool operator<=(const PythonEdge<OGraph>& other) const {return *this < other || *this == other;}
    template <class OGraph>
    bool operator>(const PythonEdge<OGraph>& other) const {return !(*this < other || *this == other);}
    template <class OGraph>
    bool operator>=(const PythonEdge<OGraph>& other) const {return *this > other || *this == other;}
Tiago Peixoto's avatar
Tiago Peixoto committed
399

400
private:
401
    std::weak_ptr<Graph> _g;
402
    edge_descriptor _e;
403
404
405

    template <class OGraph>
    friend class PythonEdge;
406
407
};

408
409
410
411
412
413
414
415
416
417
// metafunction to determine wether or not to return copies or internal
// references to property types
struct return_reference
{
    template <class ValueType>
    struct apply
    {
        // return actual references only for non-string and non-python::object
        // classes

Tiago Peixoto's avatar
Tiago Peixoto committed
418
419
420
421
422
423
424
425
        typedef typename boost::mpl::if_<
            typename boost::mpl::and_<
                std::is_class<ValueType>,
                typename boost::mpl::and_<
                    typename boost::mpl::not_<std::is_same<ValueType,
                                                           string> >::type,
                    typename boost::mpl::not_<std::is_same<ValueType,
                                                           boost::python::object> >::type>::type
426
                >::type,
Tiago Peixoto's avatar
Tiago Peixoto committed
427
428
            boost::mpl::bool_<true>,
            boost::mpl::bool_<false> >::type type;
429
430
431
432
    };
};

template <class PropertyMap>
433
434
435
class PythonPropertyMap
{
public:
436
437
    PythonPropertyMap(const PropertyMap& pmap)
        : _pmap(pmap) {}
438

Tiago Peixoto's avatar
Tiago Peixoto committed
439
    typedef typename boost::property_traits<PropertyMap>::value_type value_type;
440

Tiago Peixoto's avatar
Tiago Peixoto committed
441
    typedef typename boost::mpl::if_<
442
443
444
445
        typename return_reference::apply<value_type>::type,
        value_type&,
        value_type>::type reference;

446
    template <class PythonDescriptor>
447
    reference get_value(const PythonDescriptor& key)
448
    {
449
450
        key.check_valid();
        return get(_pmap, key.get_descriptor());
451
452
    }

453
454
    // in this case, val should be a copy, not a reference. This is to avoid a
    // problem with vector-valued property maps
455
    template <class PythonDescriptor>
456
    void set_value(const PythonDescriptor& key, value_type val)
457
    {
458
459
460
        set_value_dispatch(key, val,
                           std::is_convertible<typename boost::property_traits<PropertyMap>::category,
                                               boost::writable_property_map_tag>());
461
462
    }

463
    template <class PythonDescriptor>
464
465
    void set_value_dispatch(const PythonDescriptor& key, const value_type& val,
                            std::true_type)
466
    {
467
468
        key.check_valid();
        put(_pmap, key.get_descriptor(), val);
469
470
    }

471
    template <class PythonDescriptor>
472
473
    void set_value_dispatch(const PythonDescriptor&, const value_type&,
                            std::false_type)
474
    {
Tiago Peixoto's avatar
Tiago Peixoto committed
475
        throw ValueException("property is read-only");
476
477
    }

478
    size_t get_hash() const
479
    {
Tiago Peixoto's avatar
Tiago Peixoto committed
480
        return std::hash<size_t>()(size_t(this));
481
482
    }

483
    std::string get_type() const
484
    {
Tiago Peixoto's avatar
Tiago Peixoto committed
485
486
487
        using boost::python::detail::gcc_demangle;
        if (std::is_same<typename boost::mpl::find<value_types,value_type>::type,
                         typename boost::mpl::end<value_types>::type>::value)
488
489
            return gcc_demangle(typeid(value_type).name());
        else
Tiago Peixoto's avatar
Tiago Peixoto committed
490
            return type_names[boost::mpl::find<value_types,
491
                                               value_type>::type::pos::value];
492
493
    }

494
    boost::any get_map() const
495
496
497
498
    {
        return _pmap;
    }

499
    boost::any get_dynamic_map() const
500
    {
Tiago Peixoto's avatar
Tiago Peixoto committed
501
        return (boost::dynamic_property_map*)
502
503
504
505
            (new boost::detail::dynamic_property_map_adaptor<PropertyMap>
             (_pmap));
    }

506
    boost::python::object get_array(size_t size)
507
    {
Tiago Peixoto's avatar
Tiago Peixoto committed
508
509
510
511
512
513
514
515
        typedef typename boost::mpl::or_<
            typename boost::mpl::or_<
                std::is_same<PropertyMap,
                             GraphInterface::vertex_index_map_t>,
                std::is_same<PropertyMap,
                             GraphInterface::edge_index_map_t> >::type,
            typename boost::mpl::not_<
                typename boost::mpl::has_key<numpy_types, value_type>::type >
516
            ::type>::type isnt_vector_map;
517
        return get_array_dispatch(size, isnt_vector_map());
518
519
    }

520
    boost::python::object get_array_dispatch(size_t size, boost::mpl::bool_<false>)
521
    {
522
        _pmap.resize(size);
523
524
525
        return wrap_vector_not_owned(_pmap.get_storage());
    }

526
    boost::python::object get_array_dispatch(size_t, boost::mpl::bool_<true>)
527
    {
Tiago Peixoto's avatar
Tiago Peixoto committed
528
        return boost::python::object();
529
530
    }

531
    bool is_writable() const
532
    {
Tiago Peixoto's avatar
Tiago Peixoto committed
533
534
        return std::is_convertible<typename boost::property_traits<PropertyMap>::category,
                                   boost::writable_property_map_tag>::value;
535
536
    }

537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
    void reserve(size_t size)
    {
        typename boost::mpl::or_<
            std::is_same<PropertyMap,
                         GraphInterface::vertex_index_map_t>,
            std::is_same<PropertyMap,
                         GraphInterface::edge_index_map_t> >::type is_index;
        reserve_dispatch(size, is_index);
    }

    void reserve_dispatch(size_t size, boost::mpl::bool_<false>)
    {
        _pmap.reserve(size);
    }

    void reserve_dispatch(size_t, boost::mpl::bool_<true>)
    {
    }

    void resize(size_t size)
    {
        typename boost::mpl::or_<
            std::is_same<PropertyMap,
                         GraphInterface::vertex_index_map_t>,
            std::is_same<PropertyMap,
                         GraphInterface::edge_index_map_t> >::type is_index;
        resize_dispatch(size, is_index);
    }

    void resize_dispatch(size_t size, boost::mpl::bool_<false>)
    {
        _pmap.resize(size);
    }

    void resize_dispatch(size_t, boost::mpl::bool_<true>)
    {
    }

    void shrink_to_fit()
    {
        typename boost::mpl::or_<
            std::is_same<PropertyMap,
                         GraphInterface::vertex_index_map_t>,
            std::is_same<PropertyMap,
                         GraphInterface::edge_index_map_t> >::type is_index;
        shrink_to_fit_dispatch(is_index);
    }

    void shrink_to_fit_dispatch(boost::mpl::bool_<false>)
    {
        _pmap.shrink_to_fit();
    }

    void shrink_to_fit_dispatch(boost::mpl::bool_<true>)
    {
    }

594
private:
595
    PropertyMap _pmap; // hold an internal copy, since it's cheap
596
597
598
};


599
600
601
602
603
604
605
606
//
// Create new properties
//

struct new_property_map
{
    template <class ValueType, class IndexMap>
    void operator()(ValueType, IndexMap index, const string& type_name,
Tiago Peixoto's avatar
Tiago Peixoto committed
607
                     boost::any pmap, boost::python::object& new_prop, bool& found) const
608
    {
Tiago Peixoto's avatar
Tiago Peixoto committed
609
        size_t i = boost::mpl::find<value_types,ValueType>::type::pos::value;
610
611
        if (type_name == type_names[i])
        {
612
613
            typedef typename property_map_type::apply<ValueType, IndexMap>::type
                map_t;
614
615
616
617
            map_t prop;
            if (pmap.empty())
                prop = map_t(index);
            else
Tiago Peixoto's avatar
Tiago Peixoto committed
618
                prop = boost::any_cast<map_t>(pmap);
619

Tiago Peixoto's avatar
Tiago Peixoto committed
620
            new_prop = boost::python::object(PythonPropertyMap<map_t>(prop));
621
622
623
624
625
626
            found = true;
        }
    }
};

template <class IndexMap>
Tiago Peixoto's avatar
Tiago Peixoto committed
627
628
boost::python::object new_property(const string& type, IndexMap index_map,
                                   boost::any pmap)
629
{
Tiago Peixoto's avatar
Tiago Peixoto committed
630
    boost::python::object prop;
631
    bool found = false;
Tiago Peixoto's avatar
Tiago Peixoto committed
632
633
634
635
    boost::mpl::for_each<value_types>(std::bind(new_property_map(),
                                                std::placeholders::_1, index_map,
                                                std::ref(type), pmap, std::ref(prop),
                                                std::ref(found)));
636
    if (!found)
Tiago Peixoto's avatar
Tiago Peixoto committed
637
        throw ValueException("Invalid property type: " + type);
638
639
640
    return prop;
}

641
642
643
644
645
646
647
648
649
//
// Python IO streams (minimal access to c++ streams)
//

class OStream
{
public:
    OStream(std::ostream& s): _s(s) {}

650
    void write(const std::string& s, size_t n)
651
652
653
654
    {
        _s.write(s.c_str(), long(n));
    }

655
    void flush()
656
657
658
659
660
661
662
663
664
665
666
667
668
    {
        _s.flush();
    }

private:
    std::ostream& _s;
};

class IStream
{
public:
    IStream(std::istream& s): _s(s) {}

669
    boost::python::object read(size_t n)
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
    {
        std::string buf;
        buf.resize(n);
        _s.read(&buf[0], n);
        buf.resize(_s.gcount());

#if (PY_MAJOR_VERSION >= 3)
        // in python 3 we need to construct a 'bytes' instance
        PyObject* bytes = PyBytes_FromStringAndSize(&buf[0], buf.size());
        boost::python::handle<> x(bytes);
        boost::python::object pbuf(x);
#else
        boost::python::str pbuf(buf);
#endif
        return pbuf;
    }

private:
    std::istream& _s;
};


692
693
694
} //graph_tool namespace

#endif