aboutsummaryrefslogtreecommitdiffstats
path: root/bindings/python/serd.pyx
diff options
context:
space:
mode:
Diffstat (limited to 'bindings/python/serd.pyx')
-rw-r--r--bindings/python/serd.pyx2315
1 files changed, 2315 insertions, 0 deletions
diff --git a/bindings/python/serd.pyx b/bindings/python/serd.pyx
new file mode 100644
index 00000000..e2ed0c6c
--- /dev/null
+++ b/bindings/python/serd.pyx
@@ -0,0 +1,2315 @@
+# cython: binding=True
+# cython: language_level=3
+# cython: warn.maybe_uninitialized=True
+# cython: warn.multiple_declarators=True
+# cython: warn.unused=True
+
+"""A lightweight library for working with RDF data."""
+
+import enum
+import logging
+import errno
+
+import cython
+
+from libc.stdint cimport uint32_t, int64_t
+
+logger = logging.getLogger(__name__)
+
+cdef extern from "stdarg.h":
+ ctypedef struct va_list:
+ pass
+
+cdef extern from "serd/serd.h":
+ ctypedef struct SerdWorld
+ ctypedef struct SerdNodes
+ ctypedef struct SerdStatement
+ ctypedef struct SerdCursor
+ ctypedef struct SerdEnv
+ ctypedef struct SerdModel
+ ctypedef struct SerdIter
+ ctypedef struct SerdRange
+ ctypedef struct SerdReader
+ ctypedef struct SerdWriter
+ ctypedef struct SerdSink
+
+ ctypedef enum SerdStatus: pass
+ ctypedef enum SerdSyntax: pass
+ ctypedef enum SerdStatementFlag: pass
+ ctypedef enum SerdSerialisationFlag: pass
+ ctypedef enum SerdNodeType: pass
+ ctypedef enum SerdNodeFlag: pass
+ ctypedef enum SerdField: pass
+ ctypedef enum SerdModelFlag: pass
+
+ ctypedef uint32_t SerdStatementFlags
+ ctypedef uint32_t SerdSerialisationFlags
+ ctypedef uint32_t SerdNodeFlags
+ ctypedef uint32_t SerdModelFlags
+
+ ctypedef struct SerdNode
+
+ ctypedef struct SerdStringView:
+ const char* buf;
+ size_t len;
+
+ ctypedef struct SerdBuffer:
+ void* buf;
+ size_t len;
+
+ ctypedef struct SerdURIView:
+ SerdStringView scheme
+ SerdStringView authority
+ SerdStringView path_prefix
+ SerdStringView path
+ SerdStringView query
+ SerdStringView fragment
+
+ ctypedef enum SerdReaderFlag : pass
+ ctypedef uint32_t SerdReaderFlags
+
+ ctypedef enum SerdWriterFlag : pass
+ ctypedef uint32_t SerdWriterFlags
+
+ void serd_free(void* ptr);
+
+ # String Utilities
+ const char* serd_strerror(SerdStatus status);
+
+ # Base64
+
+ size_t serd_base64_encoded_length(size_t size, bint wrap_lines);
+ size_t serd_base64_decoded_size(size_t len);
+
+ bint serd_base64_encode(char* str,
+ const void* buf,
+ size_t size,
+ bint wrap_lines);
+
+ SerdStatus serd_base64_decode(void* buf,
+ size_t* size,
+ const char* str,
+ size_t len);
+
+ # Byte Source
+
+ ctypedef struct SerdByteSource
+
+ ctypedef int (*SerdStreamErrorFunc)(void* stream);
+
+ ctypedef size_t (*SerdReadFunc)(void* buf,
+ size_t size,
+ size_t nmemb,
+ void* stream);
+
+ SerdByteSource* serd_byte_source_new_string(const char* string,
+ const SerdNode* name);
+
+ SerdByteSource* serd_byte_source_new_filename(const char* path,
+ size_t block_size);
+
+ SerdByteSource* serd_byte_source_new_function(
+ SerdReadFunc read_func,
+ SerdStreamErrorFunc error_func,
+ void* stream,
+ const SerdNode* name,
+ size_t block_size);
+
+ void serd_byte_source_free(SerdByteSource* source);
+
+ # Byte sink
+
+ ctypedef struct SerdByteSink
+
+ ctypedef size_t (*SerdWriteFunc)(const void* buf,
+ size_t size,
+ size_t nmemb,
+ void* stream);
+
+ SerdByteSink* serd_byte_sink_new_buffer(SerdBuffer* buffer);
+
+ SerdByteSink* serd_byte_sink_new_filename(const char* path,
+ size_t block_size);
+
+ SerdByteSink* serd_byte_sink_new_function(SerdWriteFunc write_func,
+ void* stream,
+ size_t block_size);
+
+ void serd_byte_sink_flush(SerdByteSink* sink);
+ void serd_byte_sink_close(SerdByteSink* sink);
+ void serd_byte_sink_free(SerdByteSink* sink);
+
+ # Syntax Utilities
+
+ SerdSyntax serd_syntax_by_name(const char* name);
+ SerdSyntax serd_guess_syntax(const char* filename);
+ bint serd_syntax_has_graphs(SerdSyntax syntax);
+
+ # URI
+
+ char* serd_parse_file_uri(const char* uri, char** hostname);
+ bint serd_uri_string_has_scheme(const char* utf8);
+ SerdStatus serd_parse_uri(const char* utf8, SerdURIView* out);
+
+ SerdURIView serd_resolve_uri(SerdURIView r, SerdURIView base);
+
+ size_t serd_write_uri(SerdURIView uri, SerdWriteFunc sink, void* stream);
+
+ # Node
+
+ SerdNode* serd_node_from_syntax(const char* str, SerdSyntax syntax);
+ char* serd_node_to_syntax(const SerdNode* node, SerdSyntax syntax);
+
+ SerdNode* serd_new_simple_node(SerdNodeType type, SerdStringView string);
+ SerdNode* serd_new_string(SerdStringView string);
+ SerdNode* serd_new_plain_literal(SerdStringView str, SerdStringView lang);
+ SerdNode* serd_new_typed_literal(SerdStringView str, SerdStringView datatype_uri);
+
+ SerdNode* serd_new_blank(SerdStringView string);
+ SerdNode* serd_new_curie(SerdStringView string);
+ SerdNode* serd_new_uri(SerdStringView string);
+ SerdNode* serd_new_parsed_uri(SerdURIView uri);
+ SerdNode* serd_new_file_uri(SerdStringView path, SerdStringView hostname);
+ SerdNode* serd_new_boolean(bint b);
+ SerdNode* serd_new_decimal(double d, const SerdNode* datatype);
+ SerdNode* serd_new_double(double d);
+ SerdNode* serd_new_float(float f);
+ SerdNode* serd_new_integer(int64_t i, const SerdNode* datatype);
+ SerdNode* serd_new_blob(const void* buf, size_t size, const SerdNode* datatype);
+
+ bint serd_get_boolean(const SerdNode* node);
+ double serd_get_double(const SerdNode* node);
+ float serd_get_float(const SerdNode* node);
+ int64_t serd_get_integer(const SerdNode* node);
+ SerdNode* serd_node_copy(const SerdNode* node);
+ void serd_node_free(SerdNode* node);
+ SerdNodeType serd_node_type(const SerdNode* node);
+ const char* serd_node_string(const SerdNode* node);
+ size_t serd_node_length(const SerdNode* node);
+ SerdStringView serd_node_string_view(const SerdNode* node);
+ SerdURIView serd_node_uri_view(const SerdNode* node);
+ SerdNodeFlags serd_node_flags(const SerdNode* node);
+ const SerdNode* serd_node_datatype(const SerdNode* node);
+ const SerdNode* serd_node_language(const SerdNode* node);
+ bint serd_node_equals(const SerdNode* a, const SerdNode* b);
+ int serd_node_compare(const SerdNode* a, const SerdNode* b);
+
+ # Event
+
+ ctypedef enum SerdEventType: pass
+
+ ctypedef struct SerdBaseEvent:
+ SerdEventType type;
+ const SerdNode* uri;
+
+ ctypedef struct SerdPrefixEvent:
+ SerdEventType type;
+ const SerdNode* name;
+ const SerdNode* uri;
+
+ ctypedef struct SerdStatementEvent:
+ SerdEventType type;
+ SerdStatementFlags flags;
+ const SerdStatement* statement;
+
+ ctypedef struct SerdEndEvent:
+ SerdEventType type;
+ const SerdNode* node;
+
+ ctypedef union SerdEvent:
+ SerdEventType type;
+ SerdBaseEvent base;
+ SerdPrefixEvent prefix;
+ SerdStatementEvent statement;
+ SerdEndEvent end;
+
+ ctypedef SerdStatus (*SerdEventFunc)(void* handle, const SerdEvent* event);
+
+ # World
+
+ SerdWorld* serd_world_new();
+ void serd_world_free(SerdWorld* world);
+ SerdNodes* serd_world_nodes(SerdWorld* world);
+ const SerdNode* serd_world_get_blank(SerdWorld* world);
+
+ # TODO: logging
+
+ ctypedef enum SerdLogLevel: pass
+
+ cdef struct SerdLogField:
+ const char* key;
+ const char* value;
+
+ cdef struct SerdLogEntry:
+ const char* domain;
+ const SerdLogField* fields;
+ const char* fmt;
+ va_list* args;
+ SerdLogLevel level;
+ size_t n_fields;
+
+ ctypedef SerdStatus (*SerdLogFunc)(void* handle, const SerdLogEntry* entry);
+
+ # SerdStatus serd_quiet_error_func(void* handle, const SerdLogEntry* entry);
+
+ # const char* serd_log_entry_get_field(const SerdLogEntry* entry,
+ # const char* key);
+
+ void serd_world_set_log_func(SerdWorld* world,
+ SerdLogFunc log_func,
+ void* handle);
+
+ # SerdStatus serd_world_vlogf(const SerdWorld* world,
+ # const char* domain,
+ # SerdLogLevel level,
+ # size_t n_fields,
+ # const SerdLogField* fields,
+ # const char* fmt,
+ # va_list args);
+
+ SerdStatus serd_world_logf(const SerdWorld* world,
+ const char* domain,
+ SerdLogLevel level,
+ size_t n_fields,
+ const SerdLogField* fields,
+ const char* fmt,
+ ...);
+
+ # Environment
+
+ SerdEnv* serd_env_new(const SerdStringView base_uri);
+ SerdEnv* serd_env_copy(const SerdEnv* env);
+ bint serd_env_equals(const SerdEnv* a, const SerdEnv* b);
+ void serd_env_free(SerdEnv* env);
+ const SerdNode* serd_env_base_uri(SerdEnv* env)
+ SerdStatus serd_env_set_base_uri(SerdEnv* env, SerdStringView uri);
+
+ SerdStatus serd_env_set_prefix(SerdEnv* env,
+ SerdStringView name,
+ SerdStringView uri);
+
+ SerdNode* serd_env_qualify(const SerdEnv* env, const SerdNode* uri);
+ SerdNode* serd_env_expand(const SerdEnv* env, const SerdNode* node);
+
+ void serd_env_write_prefixes(const SerdEnv* env, const SerdSink* sink);
+
+ # Inserter
+
+ SerdSink* serd_inserter_new(SerdModel* model,
+ SerdEnv* env,
+ const SerdNode* default_graph);
+
+ # Statement
+
+ SerdStatement* serd_statement_new(const SerdNode* s,
+ const SerdNode* p,
+ const SerdNode* o,
+ const SerdNode* g,
+ const SerdCursor* cursor);
+
+ SerdStatement* serd_statement_copy(const SerdStatement* statement);
+ void serd_statement_free(SerdStatement* statement);
+
+ const SerdNode* serd_statement_node(const SerdStatement* statement,
+ SerdField field);
+
+ const SerdNode* serd_statement_subject(const SerdStatement* statement);
+ const SerdNode* serd_statement_predicate(const SerdStatement* statement);
+ const SerdNode* serd_statement_object(const SerdStatement* statement);
+ const SerdNode* serd_statement_graph(const SerdStatement* statement);
+
+ const SerdCursor* serd_statement_cursor(const SerdStatement* statement);
+
+ bint serd_statement_equals(const SerdStatement* a, const SerdStatement* b);
+
+ bint serd_statement_matches(const SerdStatement* statement,
+ const SerdNode* subject,
+ const SerdNode* predicate,
+ const SerdNode* object,
+ const SerdNode* graph);
+
+ # Iter
+
+ SerdIter* serd_iter_copy(const SerdIter* iter);
+ const SerdStatement* serd_iter_get(const SerdIter* iter);
+
+ bint serd_iter_next(SerdIter* iter);
+ bint serd_iter_equals(const SerdIter* lhs, const SerdIter* rhs);
+ void serd_iter_free(SerdIter* iter);
+
+ # Range
+
+ SerdRange* serd_range_copy(const SerdRange* range);
+ void serd_range_free(SerdRange* range);
+ const SerdStatement* serd_range_front(const SerdRange* range);
+
+ bint serd_range_equals(const SerdRange* lhs, const SerdRange* rhs);
+
+ bint serd_range_next(SerdRange* range);
+ bint serd_range_empty(const SerdRange* range);
+ const SerdIter* serd_range_cbegin(const SerdRange* range);
+ const SerdIter* serd_range_cend(const SerdRange* range);
+ SerdIter* serd_range_begin(SerdRange* range);
+ SerdIter* serd_range_end(SerdRange* range);
+
+ SerdStatus serd_range_serialise(const SerdRange* range,
+ const SerdSink* sink,
+ SerdSerialisationFlags flags);
+
+
+ # Sink
+
+ ctypedef void (*SerdFreeFunc)(void* ptr);
+
+ SerdSink* serd_sink_new(void* handle,
+ SerdEventFunc event_func,
+ SerdFreeFunc free_handle);
+
+ void serd_sink_free(SerdSink* sink);
+
+ SerdStatus serd_sink_set_event_func(SerdSink* sink,
+ SerdEventFunc event_func);
+
+ SerdStatus serd_sink_write_event(const SerdSink* sink,
+ const SerdEvent* event);
+
+ SerdStatus serd_sink_write_base(const SerdSink* sink,
+ const SerdNode* uri);
+
+ SerdStatus serd_sink_write_prefix(const SerdSink* sink,
+ const SerdNode* name,
+ const SerdNode* uri);
+
+ SerdStatus serd_sink_write_statement(const SerdSink* sink,
+ SerdStatementFlags flags,
+ const SerdStatement* statement);
+
+ SerdStatus serd_sink_write(const SerdSink* sink,
+ SerdStatementFlags flags,
+ const SerdNode* subject,
+ const SerdNode* predicate,
+ const SerdNode* object,
+ const SerdNode* graph);
+
+ SerdStatus serd_sink_write_end(const SerdSink* sink, const SerdNode* node);
+
+ # Stream Processing
+
+ SerdSink* serd_canon_new(const SerdSink* target);
+
+ SerdSink* serd_filter_new(const SerdSink* target,
+ const SerdNode* subject,
+ const SerdNode* predicate,
+ const SerdNode* object,
+ const SerdNode* graph);
+
+ # Reader
+
+ SerdReader* serd_reader_new(SerdWorld* world,
+ SerdSyntax syntax,
+ SerdReaderFlags flags,
+ SerdEnv* env,
+ const SerdSink* sink,
+ size_t stack_size);
+
+ void serd_reader_add_blank_prefix(SerdReader* reader, const char* prefix);
+
+ SerdStatus serd_reader_start(SerdReader* reader, SerdByteSource* byte_source);
+ SerdStatus serd_reader_read_chunk(SerdReader* reader);
+ SerdStatus serd_reader_read_document(SerdReader* reader);
+ SerdStatus serd_reader_finish(SerdReader* reader);
+
+ void serd_reader_free(SerdReader* reader);
+
+ # Writer
+
+ SerdWriter* serd_writer_new(SerdWorld* world,
+ SerdSyntax syntax,
+ SerdWriterFlags flags,
+ SerdEnv* env,
+ SerdByteSink* byte_sink);
+
+ void serd_writer_free(SerdWriter* writer);
+ const SerdSink* serd_writer_sink(SerdWriter* writer);
+
+ size_t serd_buffer_sink(const void* buf,
+ size_t size,
+ size_t nmemb,
+ void* stream);
+
+ char* serd_buffer_sink_finish(SerdBuffer* stream);
+
+ void serd_writer_chop_blank_prefix(SerdWriter* writer, const char* prefix);
+
+ SerdStatus serd_writer_set_base_uri(SerdWriter* writer,
+ const SerdNode* uri);
+
+ SerdStatus serd_writer_set_root_uri(SerdWriter* writer,
+ const SerdNode* uri);
+
+ SerdStatus serd_writer_finish(SerdWriter* writer);
+
+ # Model
+
+ SerdModel* serd_model_new(SerdWorld* world, SerdModelFlags flags);
+ SerdModel* serd_model_copy(const SerdModel* model);
+ bint serd_model_equals(const SerdModel* a, const SerdModel* b);
+ void serd_model_free(SerdModel* model);
+ SerdWorld* serd_model_world(SerdModel* model);
+ SerdModelFlags serd_model_flags(const SerdModel* model);
+ size_t serd_model_size(const SerdModel* model);
+ bint serd_model_empty(const SerdModel* model);
+ SerdIter* serd_model_begin(const SerdModel* model);
+ const SerdIter* serd_model_end(const SerdModel* model);
+ SerdRange* serd_model_all(const SerdModel* model);
+
+ SerdIter* serd_model_find(const SerdModel* model,
+ const SerdNode* s,
+ const SerdNode* p,
+ const SerdNode* o,
+ const SerdNode* g);
+
+ SerdRange* serd_model_range(const SerdModel* model,
+ const SerdNode* s,
+ const SerdNode* p,
+ const SerdNode* o,
+ const SerdNode* g);
+
+ const SerdNode* serd_model_get(const SerdModel* model,
+ const SerdNode* s,
+ const SerdNode* p,
+ const SerdNode* o,
+ const SerdNode* g);
+
+ const SerdStatement* serd_model_get_statement(const SerdModel* model,
+ const SerdNode* s,
+ const SerdNode* p,
+ const SerdNode* o,
+ const SerdNode* g);
+
+ bint serd_model_ask(const SerdModel* model,
+ const SerdNode* s,
+ const SerdNode* p,
+ const SerdNode* o,
+ const SerdNode* g);
+
+ size_t serd_model_count(const SerdModel* model,
+ const SerdNode* s,
+ const SerdNode* p,
+ const SerdNode* o,
+ const SerdNode* g);
+
+ SerdStatus serd_model_add(SerdModel* model,
+ const SerdNode* s,
+ const SerdNode* p,
+ const SerdNode* o,
+ const SerdNode* g);
+
+ SerdStatus serd_model_insert(SerdModel* model,
+ const SerdStatement* statement);
+
+ SerdStatus serd_model_add_range(SerdModel* model, SerdRange* range);
+ SerdStatus serd_model_erase(SerdModel* model, SerdIter* iter);
+ SerdStatus serd_model_erase_range(SerdModel* model, SerdRange* range);
+ SerdStatus serd_validate(const SerdModel* model);
+
+
+ # Cursor
+
+ SerdCursor* serd_cursor_new(const SerdNode* name,
+ unsigned line,
+ unsigned col);
+
+ SerdCursor* serd_cursor_copy(const SerdCursor* cursor);
+ void serd_cursor_free(SerdCursor* cursor);
+
+ bint serd_cursor_equals(const SerdCursor* lhs, const SerdCursor* rhs);
+
+ const SerdNode* serd_cursor_name(const SerdCursor* cursor);
+ unsigned serd_cursor_line(const SerdCursor* cursor);
+ unsigned serd_cursor_column(const SerdCursor* cursor);
+
+
+class Status(enum.IntEnum):
+ """Return status code."""
+ SUCCESS = 0 # No error
+ FAILURE = 1 # Non-fatal failure
+ ERR_UNKNOWN = 2 # Unknown error
+ ERR_BAD_SYNTAX = 3 # Invalid syntax
+ ERR_BAD_ARG = 4 # Invalid argument
+ ERR_BAD_ITER = 5 # Use of invalidated iterator
+ ERR_NOT_FOUND = 6 # Not found
+ ERR_ID_CLASH = 7 # Encountered clashing blank node IDs
+ ERR_BAD_CURIE = 8 # Invalid CURIE (e.g. prefix does not exist)
+ ERR_INTERNAL = 9 # Unexpected internal error (should not happen)
+ ERR_OVERFLOW = 10 # Stack overflow
+ ERR_INVALID = 11 # Invalid data
+ ERR_NO_DATA = 12 # Unexpected end of input
+ ERR_BAD_WRITE = 13 # Error writing to file/stream
+ ERR_BAD_CALL = 14 # Invalid call
+
+
+class Syntax(enum.IntEnum):
+ """RDF syntax type."""
+ EMPTY = 0 # Empty syntax (suppress input or output)
+ TURTLE = 1 # Terse triples http://www.w3.org/TR/turtle
+ NTRIPLES = 2 # Flat triples http://www.w3.org/TR/n-triples/
+ NQUADS = 3 # Flat quads http://www.w3.org/TR/n-quads/
+ TRIG = 4 # Terse quads http://www.w3.org/TR/trig/
+
+
+class StatementFlags(enum.IntFlag):
+ """Flags indicating inline abbreviation information for a statement."""
+ EMPTY_S = 1 << 0 # Empty blank node subject
+ ANON_S = 1 << 1 # Start of anonymous subject
+ ANON_O = 1 << 2 # Start of anonymous object
+ LIST_S = 1 << 3 # Start of list subject
+ LIST_O = 1 << 4 # Start of list object
+ TERSE_S = 1 << 5 # Terse serialisation of new subject
+ TERSE_O = 1 << 6 # Terse serialisation of new object
+
+
+class SerialisationFlags(enum.IntFlag):
+ """Flags that control the style of a model serialisation."""
+ NO_INLINE_OBJECTS = 1 << 0 # Disable object inlining
+
+
+class NodeType(enum.IntEnum):
+ """Type of a node
+
+ An RDF node, in the abstract sense, can be either a resource, literal, or a
+ blank. This type is more precise, because syntactically there are two ways
+ to refer to a resource (by URI or CURIE). Serd also has support for
+ variable nodes to support some features, which are not RDF nodes.
+
+ There are also two ways to refer to a blank node in syntax (by ID or
+ anonymously), but this is handled by statement flags rather than distinct
+ node types.
+ """
+ LITERAL = 1 # Literal value
+ URI = 2 # URI (absolute or relative)
+ CURIE = 3 # CURIE (shortened URI)
+ BLANK = 4 # Blank node
+ VARIABLE = 5 # Variable node
+
+
+class NodeFlags(enum.IntFlag):
+ """Flags indicating certain string properties relevant to serialisation."""
+ IS_LONG_LITERAL = 1 << 1 # Literal uses long syntax (triple-quoted)
+ HAS_DATATYPE = 1 << 2 # Literal node has datatype
+ HAS_LANGUAGE = 1 << 3 # Literal node has language
+
+
+class Field(enum.IntEnum):
+ """Index of a statement in a field."""
+ SUBJECT = 0 # Subject
+ PREDICATE = 1 # Predicate ("key")
+ OBJECT = 2 # Object ("value")
+ GRAPH = 3 # Graph ("context")
+
+
+class ModelFlags(enum.IntFlag):
+ """Flags that control model storage and indexing."""
+ INDEX_SPO = 1 << 0 # Subject, Predicate, Object
+ INDEX_SOP = 1 << 1 # Subject, Object, Predicate
+ INDEX_OPS = 1 << 2 # Object, Predicate, Subject
+ INDEX_OSP = 1 << 3 # Object, Subject, Predicate
+ INDEX_PSO = 1 << 4 # Predicate, Subject, Object
+ INDEX_POS = 1 << 5 # Predicate, Object, Subject
+ INDEX_GRAPHS = 1 << 6 # Support multiple graphs in model
+ STORE_CURSORS = 1 << 7 # Store original cursor of statements
+
+# TODO: URI
+
+
+class ReaderFlags(enum.IntFlag):
+ """Reader support options."""
+ READ_LAX = 1 << 0 # Tolerate invalid input where possible
+ READ_VARIABLES = 1 << 1 # Support variable nodes
+
+
+class WriterFlags(enum.IntFlag):
+ """Writer style options.
+
+ These flags allow more precise control of writer output style. Note that
+ some options are only supported for some syntaxes, for example, NTriples
+ does not support abbreviation and is always ASCII.
+ """
+ WRITE_ASCII = 1 << 0 # Escape all non-ASCII characters
+ WRITE_TERSE = 1 << 1 # Write terser output without newlines
+ WRITE_LAX = 1 << 2 # Tolerate lossy output
+
+
+class EventType(enum.IntEnum):
+ """The type of a :class:`serd.Event`."""
+ BASE = 1
+ PREFIX = 2
+ STATEMENT = 3
+ END = 4
+
+
+# Private Python Bindings Utilities
+
+cdef SerdNode* _unwrap_node(node: Node):
+ if node is None:
+ return NULL
+ elif type(node) == Node:
+ return (<Node>node)._ptr
+
+ raise TypeError("Expected Node, got %s" % type(node))
+
+
+def _uri_from_param(param) -> Node:
+ if isinstance(param, type("")):
+ return uri(param)
+ elif isinstance(param, Node) and (<Node>param).type() == NodeType.URI:
+ return param
+
+ raise TypeError("Expected string or URI node, got %s" % type(param))
+
+
+def _blank_from_param(param) -> Node:
+ if isinstance(param, type("")):
+ return blank(param)
+ elif isinstance(param, Node) and (<Node>param).type() == NodeType.BLANK:
+ return param
+
+ raise TypeError("Expected string or blank node, got %s" % type(param))
+
+
+def _tocstr(s: str):
+ return s.encode('utf-8')
+
+
+def _string_view(s: str):
+ encoded = s.encode('utf-8')
+ return SerdStringView(encoded, len(encoded)) # FIXME: len?
+
+
+def _fromcstr(const char* s):
+ return s.decode('utf-8')
+
+
+# Public Python API Utilities
+
+class Namespace:
+ """Namespace prefix.
+
+ Use attribute syntax to easily create URIs within this namespace, for
+ example::
+
+ >>> world = lilv.World()
+ >>> ns = Namespace(world, "http://example.org/")
+ >>> print(ns.foo)
+ http://example.org/foo
+ """
+
+ def __init__(self, prefix):
+ self.prefix = str(_uri_from_param(prefix))
+
+ def __add__(self, suffix: str):
+ return uri(self.prefix + suffix)
+
+ def __eq__(self, other):
+ if type(other) == Namespace:
+ return self.prefix == other.prefix
+ elif type(other) == str:
+ return self.prefix == other
+ elif type(other) == Node:
+ return other.type() == NodeType.URI and other == self.prefix
+
+ def __str__(self):
+ return self.prefix
+
+ def __getattr__(self, suffix: str):
+ return uri(self.prefix + suffix)
+
+ def __getitem__(self, suffix: str):
+ return uri(self.prefix + suffix)
+
+ def name(self, uri):
+ uri = _uri_from_param(uri)
+ if uri is not None and str(uri).startswith(self.prefix):
+ return str(uri)[len(self.prefix):]
+
+ return None
+
+
+# String Utilities
+
+
+def strerror(status: Status) -> str:
+ """Return a string describing a status code."""
+ return _fromcstr(serd_strerror(status))
+
+
+# Base64
+
+
+# def base64_encode(const unsigned char[:] data, wrap_lines=False) -> str:
+# """Encode `data` to base64.
+
+# Args:
+# data: Array of arbitrary bytes to encode.
+# wrap_lines: Wrap lines at 76 characters to conform to RFC 2045.
+
+# Returns:
+# A string encoded in base64 format.
+# """
+# size = len(data)
+# length = serd_base64_encoded_length(size, wrap_lines)
+# result = bytes(length)
+# serd_base64_encode(result, &data[0], size, wrap_lines)
+
+# return result.decode("utf-8")
+
+
+# def base64_decode(string: str) -> bytes:
+# """Decode `string` from base64."""
+# length = len(string)
+# size = serd_base64_decoded_size(length)
+# result = cython.view.array(shape=(size,), itemsize=1, format="c")
+# actual_size = <size_t>0
+
+# cdef unsigned char[::1] result_view = result
+
+# serd_base64_decode(&result_view[0], &actual_size, _tocstr(string), length)
+# assert actual_size <= size
+
+# return bytes(result[0 : actual_size])
+
+
+# Syntax Utilities
+
+
+def syntax_by_name(name: str) -> Syntax:
+ """Get a syntax by name.
+
+ Case-insensitive, supports "Turtle", "NTriples", "NQuads", and "TriG".
+
+ Returns:
+ A syntax, or Syntax.EMPTY if the name is not recognized.
+ """
+ return Syntax(serd_syntax_by_name(_tocstr(name)))
+
+
+def guess_syntax(filename: str) -> Syntax:
+ """Guess a syntax from a filename.
+
+ This uses the file extension to guess the syntax of a file.
+
+ Returns:
+ A syntax, or Syntax.EMPTY if the name is not recognized.
+ """
+ return Syntax(serd_guess_syntax(_tocstr(filename)))
+
+
+def syntax_has_graphs(syntax: Syntax) -> bool:
+ """Return whether a syntax can represent multiple graphs.
+
+ Returns:
+ True for Syntax.NQUADS and Syntax.TRIG, False otherwise.
+ """
+ return serd_syntax_has_graphs(syntax)
+
+
+# World
+
+
+cdef class World:
+ """Global library state."""
+
+ cdef SerdWorld* _ptr
+
+ def __init__(self):
+ self._ptr = serd_world_new()
+
+ def __dealloc__(self):
+ serd_world_free(self._ptr)
+ self._ptr = NULL
+
+ def get_blank(self) -> Node:
+ return Node._wrap(serd_world_get_blank(self._ptr))
+
+ def load(
+ self,
+ path: str,
+ syntax: Syntax = Syntax.TURTLE,
+ reader_flags: ReaderFlags = ReaderFlags(0),
+ model_flags: ModelFlags = ModelFlags.INDEX_SPO,
+ stack_size: int = 4096,
+ ) -> Model:
+ """Load a model from a file and return it."""
+ base_uri = file_uri(path)
+ env = Env(base_uri)
+ model = Model(self, model_flags)
+ inserter = model.inserter(env)
+ byte_source = FileSource(path)
+ reader = Reader(self, syntax, reader_flags, env, inserter, stack_size)
+
+ st = reader.start(byte_source)
+ _ensure_success(st, "Failed to open file {}".format(path))
+
+ st = reader.read_document()
+ _ensure_success(st, "Failed to read file {}".format(path))
+
+ st = reader.finish()
+ _ensure_success(st, "Failed to finish reading file {}".format(path))
+
+ return model
+
+ def loads(
+ self,
+ s: str,
+ base_uri: Node = None,
+ syntax: Syntax = Syntax.TURTLE,
+ reader_flags: ReaderFlags = ReaderFlags(0),
+ model_flags: ModelFlags = ModelFlags.INDEX_SPO,
+ stack_size: int = 4096,
+ ) -> Model:
+ """Load a model from a string and return it."""
+ env = Env(base_uri)
+ model = Model(self, model_flags)
+ inserter = model.inserter(env)
+ byte_source = StringSource(s)
+ reader = Reader(self, syntax, reader_flags, env, inserter, stack_size)
+
+ st = reader.start(byte_source)
+ _ensure_success(st, "Failed to start reading string")
+
+ st = reader.read_document()
+ _ensure_success(st, "Failed to read string")
+
+ st = reader.finish()
+ _ensure_success(st, "Failed to finish reading string")
+
+ return model
+
+ def dump(
+ self,
+ model: Model,
+ path: str,
+ syntax: Syntax = Syntax.TURTLE,
+ writer_flags: WriterFlags = WriterFlags(0),
+ serialisation_flags: SerialisationFlags = SerialisationFlags(0),
+ env: Env = None,
+ ) -> None:
+ """Write a model to a file."""
+ byte_sink = FileSink(filename=path)
+ writer = Writer(self, syntax, writer_flags, env, byte_sink)
+ st = model.all().serialise(writer.sink(), serialisation_flags)
+ writer.finish()
+ byte_sink.flush()
+ _ensure_success(st)
+
+ def dumps(
+ self,
+ model: Model,
+ syntax: Syntax = Syntax.TURTLE,
+ writer_flags: WriterFlags = WriterFlags(0),
+ serialisation_flags: SerialisationFlags = SerialisationFlags(0),
+ env: Env = None,
+ ) -> str:
+ """Write a model to a string and return it."""
+ byte_sink = StringSink()
+ writer = Writer(self, syntax, writer_flags, env, byte_sink)
+ st = model.all().serialise(writer.sink(), serialisation_flags)
+ writer.finish()
+
+ _ensure_success(st)
+
+ return byte_sink.output()
+
+
+cdef class Node:
+ """An RDF node."""
+
+ cdef SerdNode* _ptr
+
+ @staticmethod
+ cdef Node _manage(SerdNode* ptr):
+ if ptr is NULL:
+ return None
+
+ cdef Node wrapper = Node.__new__(Node)
+ wrapper._ptr = ptr
+ return wrapper
+
+ @staticmethod
+ cdef Node _wrap(const SerdNode* ptr):
+ if ptr is NULL:
+ return None
+
+ cdef Node wrapper = Node.__new__(Node)
+ wrapper._ptr = serd_node_copy(ptr)
+ return wrapper
+
+ @staticmethod
+ def from_syntax(string: str, syntax: Syntax = Syntax.TURTLE):
+ """Return a new node created from a string.
+
+ The string must be a single node in the given syntax, as returned by
+ :meth:`serd.Node.to_syntax`.
+ """
+ return Node._manage(serd_node_from_syntax(_tocstr(string),
+ Syntax.TURTLE))
+
+ def __init__(self, value):
+ if isinstance(value, str):
+ value_view = _string_view(value)
+ self._ptr = serd_new_string(value_view)
+ elif isinstance(value, type(True)):
+ self._ptr = serd_new_boolean(value)
+ elif isinstance(value, type(1)):
+ if value < -9223372036854775808 or value > 9223372036854775807:
+ raise ValueError("Integer out of range for xsd:long: %s" % value)
+
+ self._ptr = serd_new_integer(value, NULL)
+ elif isinstance(value, type(1.0)):
+ self._ptr = serd_new_double(value)
+ else:
+ raise TypeError("Bad argument type for Node(): %s" % type(value))
+
+ def __dealloc__(self):
+ if self._ptr is not NULL:
+ serd_node_free(self._ptr)
+ self._ptr = NULL
+
+ def __hash__(self):
+ return (hash(self.type()) ^
+ hash(str(self)) ^
+ hash(self.datatype()) ^
+ hash(self.language()))
+
+ def __str__(self):
+ return _fromcstr(serd_node_string(self._ptr))
+
+ def __repr__(self):
+ assert self._ptr is not NULL
+ if self.type() == NodeType.LITERAL:
+ datatype = self.datatype()
+ language = self.language()
+ if datatype is None and language is None:
+ return 'serd.string("{}")'.format(self)
+ elif language is not None:
+ return 'serd.plain_literal("{}", "{}")'.format(
+ self, self.language())
+ elif datatype == "http://www.w3.org/2001/XMLSchema#boolean":
+ return 'serd.boolean({})'.format(
+ "True" if self == "true" else "False")
+
+ return 'serd.typed_literal("{}", "{}")'.format(
+ self, self.datatype())
+ if self.type() == NodeType.URI:
+ return 'serd.uri("{}")'.format(self)
+ if self.type() == NodeType.CURIE:
+ return 'serd.curie("{}")'.format(self)
+ if self.type() == NodeType.BLANK:
+ return 'serd.blank("{}")'.format(self)
+ if self.type() == NodeType.VARIABLE:
+ return 'serd.variable("{}")'.format(self)
+
+ raise NotImplementedError("Unknown node type {}".format(self.type()))
+
+ def __len__(self):
+ return serd_node_length(self._ptr)
+
+ def __eq__(self, rhs):
+ if rhs is None:
+ return False
+ elif type(rhs) == Node:
+ return serd_node_equals(self._ptr, (<Node>rhs)._ptr)
+ else:
+ return str(self) == rhs
+
+ def __lt__(self, rhs: Node):
+ return serd_node_compare(self._ptr, rhs._ptr) < 0
+
+ def __le__(self, rhs: Node):
+ return serd_node_compare(self._ptr, rhs._ptr) <= 0
+
+ def string_view(self):
+ return serd_node_string_view(self._ptr)
+
+ def type(self) -> NodeType:
+ """Return the type of this node.
+
+ This returns the fundamental "kind" of the node, for example
+ NodeType.URI or NodeType.LITERAL. Note that this is different than the
+ optional datatype URI of a literal node, which, for example, states
+ that a literal is an integer or a double.
+ """
+ return NodeType(serd_node_type(self._ptr))
+
+ def datatype(self) -> Node:
+ """Return the datatype of this literal, or None.
+
+ The returned node is always a URI, typically something like
+ `serd.uri("http://www.w3.org/2001/XMLSchema#decimal")`.
+ """
+ return Node._wrap(serd_node_datatype(self._ptr))
+
+ def language(self) -> Node:
+ """Return the language of this literal, or None.
+
+ The returned node is always a string, typically something like
+ `serd.string("en")`.
+ """
+ return Node._wrap(serd_node_language(self._ptr))
+
+ def flags(self) -> NodeFlags:
+ """Return flags that describe the basic properties of this node."""
+ return NodeFlags(serd_node_flags(self._ptr))
+
+ def to_syntax(self, syntax: Syntax = Syntax.TURTLE) -> str:
+ """Return a string representation of this node in a syntax.
+
+ The returned string represents that node as if written as an object in
+ the given syntax, without any extra quoting or punctuation. The syntax
+ should be either TURTLE or NTRIPLES (the others are redundant). Note
+ that namespaced (CURIE) nodes and relative URIs can not be expressed in
+ NTriples.
+
+ Passing the returned string to Node.from_syntax() will produce a node
+ equivalent to this one.
+ """
+ cstr = serd_node_to_syntax(self._ptr, syntax)
+ result = _fromcstr(cstr)
+ serd_free(cstr)
+ return result
+
+
+# Node constructors
+
+
+def string(s: str) -> Node:
+ s_view = _string_view(s)
+ return Node._manage(serd_new_string(s_view))
+
+
+def plain_literal(s: str, lang: str = None) -> Node:
+ s_view = _string_view(s)
+ if lang is not None:
+ s_view = _string_view(s)
+ lang_view = _string_view(lang)
+ return Node._manage(serd_new_plain_literal(s_view, lang_view))
+ else:
+ s_view = _string_view(s)
+ return Node._manage(serd_new_string(s_view))
+
+
+def typed_literal(s: str, datatype) -> Node:
+ s_view = _string_view(s)
+ datatype_node = _uri_from_param(datatype)
+ if type(datatype_node) == Node:
+ datatype_uri_view = datatype_node.string_view()
+ return Node._manage(serd_new_typed_literal(s_view, datatype_uri_view))
+
+ return None
+
+
+def blank(s: str) -> Node:
+ s_view = _string_view(s)
+ return Node._manage(serd_new_blank(s_view))
+
+
+def curie(s: str) -> Node:
+ s_view = _string_view(s)
+ return Node._manage(serd_new_curie(s_view))
+
+
+def uri(s: str) -> Node:
+ s_view = _string_view(s)
+ return Node._manage(serd_new_uri(s_view))
+
+
+# def resolved_uri(s: str, base: Node) -> Node:
+# return Node._manage(serd_new_resolved_uri(_tocstr(s), base._ptr))
+
+
+def file_uri(path: str, hostname: str = "") -> Node:
+ path_view = _string_view(path)
+ hostname_view = _string_view(hostname)
+ return Node._manage(serd_new_file_uri(path_view, hostname_view))
+
+
+
+# def relative_uri(s: str, base: Node, root: Node) -> Node:
+# return Node._manage(serd_new_relative_uri(_tocstr(s), base._ptr, root._ptr))
+
+
+def decimal(
+ d: float,
+ datatype: Node = None,
+) -> Node:
+ return Node._manage(
+ serd_new_decimal(
+ d,
+ datatype._ptr if datatype else NULL,
+ )
+ )
+
+
+def double(d: float) -> Node:
+ return Node._manage(serd_new_double(d))
+
+
+def float(f: float) -> Node:
+ return Node._manage(serd_new_float(<float>f) )
+
+
+def integer(i: int, datatype: Node = None) -> Node:
+ return Node._manage(
+ serd_new_integer(i, datatype._ptr if datatype else NULL)
+ )
+
+
+def boolean(b: bool) -> Node:
+ return Node._manage(serd_new_boolean(b))
+
+
+def blob(const unsigned char[:] buf,
+ datatype: Node = None) -> Node:
+ assert datatype is None or type(datatype) == Node
+ return Node._manage(
+ serd_new_blob(
+ &buf[0], len(buf), datatype._ptr if datatype else NULL
+ )
+ )
+
+
+def variable(s: str) -> Node:
+ s_view = _string_view(s)
+ return Node._manage(serd_new_simple_node(NodeType.VARIABLE, s_view))
+
+
+cdef SerdStringView _empty_string = SerdStringView("", 0)
+
+
+cdef class Env:
+
+ """Lexical environment for abbreviating and expanding URIs."""
+
+ cdef SerdEnv* _ptr
+
+ @staticmethod
+ cdef Env _manage(SerdEnv* ptr):
+ if ptr is NULL:
+ return None
+
+ cdef Env wrapper = Env.__new__(Node)
+ wrapper._ptr = ptr
+ return wrapper
+
+ def __init__(self, arg=None):
+ if arg is None:
+ self._ptr = serd_env_new(_empty_string)
+ elif type(arg) == Env:
+ self._ptr = serd_env_copy((<Env>arg)._ptr)
+ elif type(arg) == Node:
+ arg_view = arg.string_view()
+ self._ptr = serd_env_new(arg_view)
+ else:
+ raise TypeError("Bad argument type for Env(): %s" % type(arg))
+
+ def __dealloc__(self):
+ serd_env_free(self._ptr)
+ self._ptr = NULL
+
+ def __eq__(self, rhs):
+ return type(rhs) == Env and serd_env_equals(self._ptr, (<Env>rhs)._ptr)
+
+ def base_uri(self) -> Node:
+ """Return the current base URI."""
+ return Node._wrap(serd_env_base_uri(self._ptr))
+
+ def set_base_uri(self, uri) -> Status:
+ """Set the current base URI."""
+ if uri is None:
+ return Status(serd_env_set_base_uri(self._ptr, _empty_string))
+
+ uri_view = _uri_from_param(uri).string_view()
+ return Status(serd_env_set_base_uri(self._ptr, uri_view))
+
+ def set_prefix(self, name, uri: Node) -> Status:
+ """Set a namespace prefix.
+
+ A namespace prefix is used to expand CURIE nodes, for example, with the
+ prefix "xsd" set to "http://www.w3.org/2001/XMLSchema#", "xsd:decimal"
+ will expand to "http://www.w3.org/2001/XMLSchema#decimal".
+ """
+ name_node = string(name) if type(name) == str else name
+ name_view = name_node.string_view()
+ uri_view = uri.string_view()
+ assert type(name_node) == Node
+ return Status(serd_env_set_prefix(self._ptr, name_view, uri_view))
+
+ def qualify(self, uri: Node) -> Node:
+ """Qualify `uri` into a CURIE if possible.
+
+ Returns null if `uri` can not be qualified (usually because no
+ corresponding prefix is defined).
+ """
+ return Node._manage(serd_env_qualify(self._ptr, uri._ptr))
+
+ def expand(self, node: Node) -> Node:
+ """Expand `node`, transforming CURIEs into URIs
+
+ If `node` is a relative URI reference, it is expanded to a full URI if
+ possible. If `node` is a literal, its datatype is expanded if
+ necessary. If `node` is a CURIE, it is expanded to a full URI if
+ possible.
+
+ Returns None if `node` can not be expanded.
+ """
+ return Node._manage(serd_env_expand(self._ptr, node._ptr))
+
+
+class ReadContext(object):
+ def __init__(self, reader, source):
+ self.reader = reader
+ self.source = source
+
+ def __enter__(self):
+ _ensure_success(self.reader.start(self.source),
+ "Failed to start reading")
+ return self
+
+ def __exit__(self, type, value, traceback) -> None:
+ _ensure_success(self.reader.finish(), "Failed to finish reading")
+
+ def read_chunk(self) -> None:
+ _ensure_success(self.reader.read_chunk(), "Failed to read chunk")
+
+ def read_document(self) -> None:
+ _ensure_success(self.reader.read_document(), "Failed to read document")
+
+
+cdef class Reader:
+ """Streaming parser that reads a text stream and writes to a sink.
+
+ .. py:function:: serd.Reader(world: serd.World, syntax: serd.Syntax, flags: serd.ReaderFlags, env: serd.Env, sink, stack_size: int = 4096)
+
+ Construct a new reader.
+
+ The `sink` can be either a :class:`serd.Sink`, a built-in sink (for
+ example, from :meth:`serd.Writer.sink()` or :meth:`serd.Model.inserter`),
+ or a function that takes a :class:`serd.Event` and returns a
+ :class:`serd.Status`.
+ """
+
+ cdef SerdReader* _ptr
+ cdef __ByteSource _byte_source
+ cdef _SinkBase _sink
+ cdef object _callback
+
+ @staticmethod
+ cdef Reader _manage(SerdReader* ptr):
+ if ptr is NULL:
+ return None
+
+ cdef Reader wrapper = Reader.__new__(Reader)
+ wrapper._ptr = ptr
+ return wrapper
+
+ def __init__(self,
+ world: World,
+ syntax: Syntax,
+ flags: ReaderFlags,
+ env: Env,
+ sink,
+ stack_size: int = 4096):
+ if isinstance(sink, _SinkBase):
+ self._sink = sink
+ else:
+ self._callback = sink
+ self._sink = Sink(func=self._callback)
+
+ assert isinstance(self._sink, _SinkBase)
+ assert self._sink._cptr is not NULL
+
+ self._ptr = serd_reader_new(world._ptr,
+ syntax,
+ flags,
+ env._ptr,
+ (<_SinkBase>self._sink)._cptr,
+ stack_size)
+
+ def __dealloc__(self):
+ serd_reader_free(self._ptr)
+ self._ptr = NULL
+
+ def add_blank_prefix(self, prefix: str) -> None:
+ """Set a prefix to be added to all blank node identifiers.
+
+ This is useful when multiple files are to be parsed into the same
+ output (a model or a file). Since Serd preserves blank node IDs, this
+ could cause conflicts where two non-equivalent blank nodes are merged,
+ resulting in corrupt data. By setting a unique blank node prefix for
+ each parsed file, this can be avoided, while preserving blank node
+ names.
+ """
+ serd_reader_add_blank_prefix(self._ptr, prefix)
+
+ def start(self, byte_source: __ByteSource) -> Status:
+ """Prepare to read from a byte source."""
+ return Status(serd_reader_start(self._ptr, byte_source._ptr))
+
+ def read_chunk(self) -> Status:
+ """Read a single "chunk" of data during an incremental read.
+
+ This function will read a single top level description, and return.
+ This may be a directive, statement, or several statements; essentially
+ it reads until a '.' is encountered. This is particularly useful for
+ reading directly from a pipe or socket.
+ """
+ return Status(serd_reader_read_chunk(self._ptr))
+
+ def read_document(self) -> Status:
+ """Read a complete document from the source.
+
+ This function will continue pulling from the source until a complete
+ document has been read. Note that this may block when used with
+ streams, for incremental reading use serd_reader_read_chunk().
+ """
+ return Status(serd_reader_read_document(self._ptr))
+
+ def finish(self) -> Status:
+ """Finish reading from the source.
+
+ This should be called before starting to read from another source.
+ Finish reading from the source.
+ """
+ return Status(serd_reader_finish(self._ptr))
+
+ def open(self, source) -> ReadContext:
+ return ReadContext(self, source)
+
+
+cdef class __ByteSource:
+ """A source for bytes that provides text input."""
+ cdef SerdByteSource* _ptr
+
+ def __dealloc__(self):
+ serd_byte_source_free(self._ptr)
+ self._ptr = NULL
+
+
+cdef class FileSource(__ByteSource):
+ """A byte source for text input that reads from a file."""
+ def __init__(self, filename: str, block_size: int = 4096):
+ super().__init__()
+ self._ptr = serd_byte_source_new_filename(_tocstr(filename), block_size)
+
+
+cdef class StringSource(__ByteSource):
+ cdef bytes _bytes
+
+ """A byte source for text input that reads from a string."""
+ def __init__(self, string: str, name: Node = None):
+ super().__init__()
+ self._bytes = _tocstr(string)
+ self._ptr = serd_byte_source_new_string(self._bytes,
+ _unwrap_node(name))
+
+
+cdef class ByteSink:
+ """A sink for bytes that receives text output."""
+ cdef SerdByteSink* _ptr
+
+ def __dealloc__(self):
+ serd_byte_sink_free(self._ptr)
+ self._ptr = NULL
+
+ def flush(self) -> None:
+ """Flush any pending output to the underlying stream."""
+ serd_byte_sink_flush(self._ptr)
+
+ def close(self) -> None:
+ """Close sink, including the underlying file if necessary."""
+ serd_byte_sink_close(self._ptr)
+
+
+cdef class FileSink(ByteSink):
+ """A sink for bytes that writes text output to a file."""
+
+ def __init__(self,
+ filename: str,
+ block_size: int = 4096):
+ super().__init__()
+
+ self._ptr = serd_byte_sink_new_filename(_tocstr(filename),
+ block_size)
+
+ if self._ptr is NULL:
+ raise OSError(errno, strerror(errno), filename)
+
+
+cdef class StringSink(ByteSink):
+ cdef SerdBuffer _buffer
+
+ def __dealloc__(self):
+ serd_free(self._buffer.buf)
+ self._buffer.buf = NULL
+ self._buffer.len = 0;
+ # super().__dealloc__(self)
+
+ def __init__(self):
+ super().__init__()
+
+ self._buffer.buf = NULL
+ self._buffer.len = 0;
+ self._ptr = serd_byte_sink_new_buffer(&self._buffer)
+
+ def output(self) -> str:
+ self.flush()
+ return _fromcstr(serd_buffer_sink_finish(&self._buffer))
+
+
+cdef class Writer:
+ """Streaming serialiser that writes a text stream as statements are pushed.
+ """
+
+ cdef SerdWriter* _ptr
+
+ def __init__(self,
+ world: World,
+ syntax: Syntax,
+ flags: WriterFlags,
+ env: Env,
+ byte_sink: ByteSink):
+ self._ptr = serd_writer_new(
+ world._ptr,
+ syntax,
+ flags,
+ env._ptr if env is not None else NULL,
+ byte_sink._ptr,
+ )
+
+ def __dealloc__(self):
+ serd_writer_free(self._ptr)
+ self._ptr = NULL
+
+ def sink(self) -> SinkView:
+ """Return a sink interface that emits statements via this writer."""
+ return SinkView._wrap(serd_writer_sink(self._ptr))
+
+ def chop_blank_prefix(self, prefix: str):
+ """Set a prefix to be removed from matching blank node identifiers.
+
+ This is the counterpart to :meth:`serd.Reader.add_blank_prefix()` and
+ can be used to "undo" added prefixes.
+ """
+ serd_writer_chop_blank_prefix(self._ptr, prefix._ptr)
+
+ def set_base_uri(self, uri: Node) -> Status:
+ """Set the current output base URI, and emit a directive if applicable.
+ """
+ return Status(serd_writer_set_base_uri(self._ptr, uri._ptr))
+
+ def set_root_uri(self, uri: Node) -> Status:
+ """Set the current root URI.
+
+ The root URI should be a prefix of the base URI. The path of the root
+ URI is the highest path any relative up-reference can refer to. For
+ example, with root <file:///foo/root> and base <file:///foo/root/base>,
+ <file:///foo/root> will be written as <../>, but <file:///foo> will be
+ written non-relatively as <file:///foo>. If the root is not explicitly
+ set, it defaults to the base URI, so no up-references will be created
+ at all.
+ """
+ return Status(serd_writer_set_root_uri(self._ptr, uri._ptr))
+
+ def finish(self) -> Status:
+ """Finish a write.
+
+ This flushes any pending output, for example terminating punctuation,
+ so that the output is a complete document.
+ """
+ return Status(serd_writer_finish(self._ptr))
+
+
+class SerdError(RuntimeError):
+ def __init__(self, status: Status, message: str = ""):
+ if message:
+ super().__init__("%s (%s)" % (message, strerror(status)))
+ else:
+ super().__init__(strerror(status))
+
+ self.status = status
+
+
+def _ensure_success(status: Status, message: str = ""):
+ if status != Status.SUCCESS:
+ raise SerdError(status, message)
+
+
+cdef class Model:
+ """An indexed set of statements."""
+ cdef SerdModel* _ptr
+ cdef World _world
+
+ def __init__(self,
+ world: World,
+ flags: ModelFlags = ModelFlags.INDEX_SPO,
+ model: Model = None):
+ if model is not None:
+ self._world = world
+ self._ptr = serd_model_copy(model._ptr)
+ elif type(world) == World and type(flags) == ModelFlags:
+ self._world = world
+ self._ptr = serd_model_new(world._ptr, flags)
+ else:
+ raise TypeError("Bad arguments for Model()")
+
+ def __dealloc__(self):
+ serd_model_free(self._ptr)
+ self._world = None
+ self._ptr = NULL
+
+ def __eq__(self, rhs):
+ return (type(rhs) == Model and
+ serd_model_equals(self._ptr, (<Model>rhs)._ptr))
+
+ def __len__(self):
+ return self.size()
+
+ def __iter__(self):
+ if self.size() == 0:
+ return _Iter._end()
+
+ return _Iter._manage(serd_model_begin(self._ptr))
+
+ def __contains__(self, statement):
+ return self._find(Statement._from_param(statement)) != self._end()
+
+ def __delitem__(self, statement):
+ i = self._find(statement)
+ if i is not None:
+ self.erase(i)
+
+ def __add__(self: Model, statement_param):
+ statement = Statement._from_param(statement_param)
+ status = serd_model_insert(self._ptr, (<Statement>statement)._ptr)
+ _ensure_success(status)
+
+ return self
+
+ def world(self) -> World:
+ return self._world
+
+ def copy(self) -> Model:
+ return Model(self.world(), self.flags(), self)
+
+ def flags(self) -> ModelFlags:
+ """Get the flags enabled on this model."""
+ return ModelFlags(serd_model_flags(self._ptr))
+
+ def size(self) -> int:
+ """Return the number of statements stored in this model."""
+ return serd_model_size(self._ptr)
+
+ def empty(self) -> bool:
+ """Return true iff there are no statements in this model."""
+ return serd_model_empty(self._ptr)
+
+ def inserter(self, env: Env, default_graph: Node = None) -> Sink:
+ """Return a sink that will insert into this model when written to."""
+ return Sink._manage(serd_inserter_new(
+ self._ptr, env._ptr, _unwrap_node(default_graph)
+ ))
+
+ def insert(self, arg) -> None:
+ """Insert a Statement or Range into this model."""
+ if type(arg) == Range:
+ return Status(serd_model_add_range(self._ptr, (<Range>arg)._ptr))
+
+ statement = Statement._from_param(arg)
+ st = serd_model_insert(self._ptr, (<Statement>statement)._ptr)
+ _ensure_success(st)
+
+ def erase(self, arg) -> Status:
+ """Erase a statement or range from the model.
+
+ The argument can be a range, iterator, statement, or tuple of nodes.
+ """
+
+ if type(arg) == Range:
+ _ensure_success(
+ serd_model_erase_range(self._ptr, (<Range>arg)._ptr),
+ "Failed to erase range")
+ elif type(arg) == _Iter:
+ # FIXME: remove?
+ _ensure_success(
+ serd_model_erase(self._ptr, (<_Iter>arg)._ptr),
+ "Failed to erase iterator")
+ elif type(arg) == Statement:
+ i = self._find(arg)
+ if i == self._end():
+ raise ValueError("serd.Model.erase(): statement not in model")
+
+ self.erase(i)
+ elif type(arg) == tuple:
+ self.erase(Statement._from_param(arg))
+ else:
+ raise TypeError("Bad argument type for Model.erase: %s" % type(arg))
+
+ # def begin(self) -> _Iter:
+ # return _Iter._manage(serd_model_begin(self._ptr))
+
+ def _end(self) -> _Iter:
+ return _Iter._wrap(serd_model_end(self._ptr))
+
+ def all(self) -> Range:
+ """Return a range that contains all statements in the model."""
+ return Range._manage(serd_model_all(self._ptr))
+
+ def _find(self, statement) -> _Iter:
+ statement = Statement._from_param(statement)
+ s = statement.subject()
+ p = statement.predicate()
+ o = statement.object()
+ g = statement.graph()
+
+ c_iter = serd_model_find(
+ self._ptr,
+ _unwrap_node(s),
+ _unwrap_node(p),
+ _unwrap_node(o),
+ _unwrap_node(g)
+ )
+
+ return _Iter._manage(c_iter) if c_iter else self._end()
+
+ def range(self, pattern) -> Range:
+ """Return a range of statements that match a pattern."""
+ assert type(pattern) == tuple
+ assert len(pattern) == 3 or len(pattern) == 4
+
+ s = pattern[0]
+ p = pattern[1]
+ o = pattern[2]
+ g = pattern[3] if len(pattern) == 4 else None
+
+ return Range._manage(
+ serd_model_range(
+ self._ptr,
+ _unwrap_node(s),
+ _unwrap_node(p),
+ _unwrap_node(o),
+ _unwrap_node(g)
+ )
+ )
+
+ def get(self,
+ subject: Node = None,
+ predicate: Node = None,
+ object: Node = None,
+ graph: Node = None) -> Node:
+ return Node._wrap(
+ serd_model_get(
+ self._ptr,
+ _unwrap_node(subject),
+ _unwrap_node(predicate),
+ _unwrap_node(object),
+ _unwrap_node(graph)
+ )
+ )
+
+ def ask(self, s: Node, p: Node, o: Node, g: Node = None) -> bool:
+ """Return true iff the model contains a statement matching a pattern.
+
+ None can be used as a wildcard which matches any node.
+ """
+ return serd_model_ask(
+ self._ptr,
+ _unwrap_node(s),
+ _unwrap_node(p),
+ _unwrap_node(o),
+ _unwrap_node(g)
+ )
+
+ def count(self, s: Node, p: Node, o: Node, g: Node = None) -> int:
+ """Return the number of statements in the model that match a pattern.
+
+ None can be used as a wildcard which matches any node.
+ """
+ return serd_model_count(
+ self._ptr,
+ _unwrap_node(s),
+ _unwrap_node(p),
+ _unwrap_node(o),
+ _unwrap_node(g)
+ )
+
+
+# cdef class Inserter:
+# """A statement sink that inserts into a model."""
+# cdef SerdInserter* _ptr
+
+# @staticmethod
+# cdef Inserter _manage(SerdInserter* ptr):
+# if ptr is NULL:
+# return None
+
+# cdef Inserter wrapper = Inserter.__new__(Inserter)
+# wrapper._ptr = ptr
+# return wrapper
+
+# def __init__(self, model: Model, env: Env, default_graph: Node = None):
+# self._ptr = serd_inserter_new(
+# model._ptr, env._ptr, _unwrap_node(default_graph)
+# )
+
+# def __dealloc__(self):
+# serd_inserter_free(self._ptr)
+# self._ptr = NULL
+
+# def sink(self) -> SinkView:
+# return SinkView._wrap(serd_inserter_get_sink(self._ptr))
+
+
+cdef class Statement:
+ """An RDF statement.
+
+ .. py:function:: serd.serd.Statement(subject: serd.Node, predicate: serd.Node, object: serd.Node, graph: serd.Node = None, cursor: serd.Cursor = None)
+
+ Construct a new statement.
+ """
+
+ cdef SerdStatement* _ptr
+ cdef Node _subject
+ cdef Node _predicate
+ cdef Node _object
+ cdef Node _graph
+ cdef Cursor _cursor
+
+ @staticmethod
+ cdef Statement _manage(SerdStatement* ptr):
+ if ptr is NULL:
+ return None
+
+ cdef Statement wrapper = Statement.__new__(Statement)
+ wrapper._ptr = ptr
+ return wrapper
+
+ @staticmethod
+ cdef Statement _wrap(const SerdStatement* ptr):
+ if ptr is NULL:
+ return None
+
+ cdef Statement wrapper = Statement.__new__(Statement)
+ wrapper._subject = Node._wrap(serd_statement_subject(ptr))
+ wrapper._predicate = Node._wrap(serd_statement_predicate(ptr))
+ wrapper._object = Node._wrap(serd_statement_object(ptr))
+ wrapper._graph = Node._wrap(serd_statement_graph(ptr))
+ wrapper._cursor = Cursor._wrap(serd_statement_cursor(ptr))
+ wrapper._ptr = serd_statement_new(
+ _unwrap_node(wrapper._subject),
+ _unwrap_node(wrapper._predicate),
+ _unwrap_node(wrapper._object),
+ _unwrap_node(wrapper._graph),
+ (<Cursor>wrapper._cursor)._ptr if wrapper._cursor is not None else NULL)
+
+ return wrapper
+
+ @staticmethod
+ def _from_param(obj):
+ if type(obj) == Statement:
+ return obj
+
+ if type(obj) == tuple:
+ if len(obj) != 3 and len(obj) != 4:
+ raise ValueError("Bad number of statement fields")
+
+ for i in range(len(obj)):
+ if type(obj[i]) != Node:
+ raise TypeError("Bad type for statement field " + i)
+
+ g = obj[3] if len(obj) == 4 else None
+ return Statement(obj[0], obj[1], obj[2], g)
+
+ raise TypeError("Bad argument type for Statement: %s" % type(obj))
+
+ def __init__(
+ self,
+ subject: Node,
+ predicate: Node,
+ object: Node,
+ graph: Node = None,
+ cursor: Cursor = None,
+ ):
+ self._subject = <Node>subject
+ self._predicate = <Node>predicate
+ self._object = <Node>object
+ self._graph = <Node>graph
+ self._cursor = <Cursor>cursor
+
+ self._ptr = serd_statement_new(
+ _unwrap_node(self._subject),
+ _unwrap_node(self._predicate),
+ _unwrap_node(self._object),
+ _unwrap_node(self._graph),
+ (<Cursor>self._cursor)._ptr if self._cursor is not None else NULL,
+ )
+
+ def __dealloc__(self):
+ serd_statement_free(self._ptr)
+ self._ptr = NULL
+
+ def __getitem__(self, field):
+ if field < 0 or field > 3 or (field == 3 and self.graph() is None):
+ raise IndexError(field)
+
+ return self.node(field)
+
+ def __eq__(self, rhs):
+ return type(rhs) == Statement and serd_statement_equals(
+ self._ptr, (<Statement>rhs)._ptr
+ )
+
+ def __str__(self):
+ result = " ".join(
+ [
+ self.subject().to_syntax(),
+ self.predicate().to_syntax(),
+ self.object().to_syntax(),
+ ]
+ )
+
+ if serd_statement_graph(self._ptr) is not NULL:
+ result += " " + self.graph().to_syntax()
+
+ return result
+
+ def __repr__(self):
+ args = [repr(self.subject()),
+ repr(self.predicate()),
+ repr(self.object())]
+
+ if self.graph() is not None:
+ args += [repr(self.graph())]
+
+ if self.cursor() is not None:
+ args += [repr(self.cursor())]
+
+ return "serd.Statement({})".format(", ".join(args))
+
+ def matches(self, s: Node, p: Node, o: Node, g: Node = None):
+ """Return true iff this statement matches the given pattern.
+
+ Nodes match if they are equivalent, or if one of them is NULL. The
+ statement matches if every node matches.
+ """
+ return serd_statement_matches(
+ self._ptr,
+ s._ptr if s is not None else NULL,
+ p._ptr if p is not None else NULL,
+ o._ptr if o is not None else NULL,
+ g._ptr if g is not None else NULL,
+ )
+
+ def node(self, field: Field) -> Node:
+ """Return a node in this statement."""
+ assert field >= Field.SUBJECT and field <= Field.GRAPH
+ return Node._wrap(serd_statement_node(self._ptr, field))
+
+ def subject(self) -> Node:
+ """Return the subject node of this statement."""
+ return Node._wrap(serd_statement_subject(self._ptr))
+
+ def predicate(self) -> Node:
+ """Return the predicate node of this statement."""
+ return Node._wrap(serd_statement_predicate(self._ptr))
+
+ def object(self) -> Node:
+ """Return the object node in this statement."""
+ return Node._wrap(serd_statement_object(self._ptr))
+
+ def graph(self) -> Node:
+ """Return the graph node in this statement."""
+ return Node._wrap(serd_statement_graph(self._ptr))
+
+ def cursor(self) -> Cursor:
+ """Return the file location this statement came from, or None."""
+ return Cursor._wrap(serd_statement_cursor(self._ptr))
+
+
+cdef class _Iter:
+ """An iterator that points to a statement in a model."""
+ cdef SerdIter* _ptr
+ cdef bint _is_end
+
+ @staticmethod
+ cdef _end():
+ cdef _Iter wrapper = _Iter.__new__(_Iter)
+
+ wrapper._ptr = NULL
+ wrapper._is_end = True
+
+ return wrapper
+
+ @staticmethod
+ cdef _manage(SerdIter* ptr):
+ cdef _Iter wrapper = _Iter.__new__(_Iter)
+
+ if ptr is NULL:
+ wrapper._ptr = NULL
+ wrapper._is_end = True
+ else:
+ wrapper._ptr = ptr
+ wrapper._is_end = False
+
+ return wrapper
+
+ @staticmethod
+ cdef _wrap(const SerdIter* ptr):
+ return _Iter._manage(serd_iter_copy(ptr))
+
+ def __init__(self, iter: _Iter):
+ assert type(iter) == _Iter
+
+ self._is_end = False
+ self._ptr = serd_iter_copy(iter._ptr)
+ self._is_end = iter._is_end
+
+ def __dealloc__(self):
+ serd_iter_free(self._ptr)
+ self._ptr = NULL
+
+ def __eq__(self, rhs):
+ return type(rhs) == _Iter and serd_iter_equals(self._ptr, (<_Iter>rhs)._ptr)
+
+ def __next__(self):
+ """Move to and return the next item."""
+ if self._is_end:
+ raise StopIteration
+
+ item = serd_iter_get(self._ptr)
+ self._is_end = serd_iter_next(self._ptr)
+
+ return Statement._wrap(item)
+
+ def get(self) -> Statement:
+ """Get the current item."""
+ return Statement._wrap(serd_iter_get(self._ptr))
+
+
+cdef class Range:
+ """A range of statements in a model.
+
+ This class is iterable so it can be used like a collection. For example,
+ :meth:`serd.Model.all()` returns a range, so all the statements in a model
+ can be printed like so::
+
+ for statement in model.all():
+ print(statement)
+
+ A range is "truthy" if it is non-empty.
+ """
+ cdef SerdRange* _ptr
+
+ @staticmethod
+ cdef _manage(SerdRange* ptr):
+ if ptr is NULL:
+ return None
+
+ cdef Range wrapper = Range.__new__(Range)
+ wrapper._ptr = ptr
+ return wrapper
+
+ @staticmethod
+ cdef _wrap(const SerdRange* ptr):
+ return Range._manage(serd_range_copy(ptr))
+
+ def __init__(self, range: Range):
+ assert type(range) == Range
+ self._ptr = serd_range_copy((<Range>range)._ptr)
+
+ def __dealloc__(self):
+ serd_range_free(self._ptr)
+ self._ptr = NULL
+
+ def __bool__(self):
+ return not self.empty()
+
+ def __eq__(self, rhs):
+ return type(rhs) == Range and serd_range_equals(self._ptr, (<Range>rhs)._ptr)
+
+ def __iter__(self):
+ if self.empty():
+ return _Iter._end()
+
+ return _Iter._wrap(serd_range_begin(self._ptr))
+
+ def front(self) -> Statement:
+ """Return the first statement in this range, or None."""
+ return Statement._wrap(serd_range_front(self._ptr))
+
+ def empty(self) -> bool:
+ """Return true iff there are no statements in this range."""
+ return serd_range_empty(self._ptr)
+
+ def serialise(self, sink: _SinkBase, flags: SerialisationFlags) -> Status:
+ """Write this range to `sink`.
+
+ The serialisation style can be controlled with `flags`. The default is
+ to write statements in an order suited for pretty-printing with Turtle
+ or TriG with as many objects written inline as possible. If
+ `SerialisationFlags.NO_INLINE_OBJECTS` is given, a simple sorted stream
+ is written instead, which is significantly faster since no searching is
+ required, but can result in ugly output for Turtle or Trig.
+ """
+ return Status(serd_range_serialise(self._ptr, sink._cptr, flags))
+
+
+cdef class Cursor:
+ """The origin of a statement in a document."""
+ cdef SerdCursor* _ptr
+ cdef Node _name_node
+
+ @staticmethod
+ cdef Cursor _manage(SerdCursor* ptr):
+ if ptr is NULL:
+ return None
+
+ cdef Cursor wrapper = Cursor.__new__(Cursor)
+ wrapper._ptr = ptr
+ return wrapper
+
+ @staticmethod
+ cdef Cursor _wrap(const SerdCursor* ptr):
+ return Cursor._manage(serd_cursor_copy(ptr))
+
+ def __init__(self, name, line: uint = 1, col: uint = 0):
+ if type(name) == Node:
+ self._name_node = <Node>name
+ self._ptr = serd_cursor_new((<Node>self._name_node)._ptr, line, col)
+ elif type(name) == str:
+ self._name_node = string(name)
+ self._ptr = serd_cursor_new((<Node>self._name_node)._ptr, line, col)
+ else:
+ raise TypeError("Bad name argument type for Cursor(): %s" % type(name))
+
+
+ def __dealloc__(self):
+ serd_cursor_free(self._ptr)
+ self._ptr = NULL
+
+ def __eq__(self, rhs):
+ return (type(rhs) == Cursor and
+ serd_cursor_equals(self._ptr, (<Cursor>rhs)._ptr))
+
+ def __str__(self):
+ return "{}:{}:{}".format(self.name(), self.line(), self.column())
+
+ def __repr__(self):
+ return "serd.Cursor({})".format(
+ ", ".join([repr(self.name()), str(self.line()), str(self.column())]))
+
+ def name(self) -> Node:
+ """Return the document name.
+
+ This is typically a file URI, but may be a descriptive string node for
+ statements that originate from strings or streams.
+ """
+
+ return Node._wrap(serd_cursor_name(self._ptr))
+
+ def line(self) -> int:
+ """Return the one-relative line number in the document."""
+ return serd_cursor_line(self._ptr)
+
+ def column(self) -> int:
+ """Return the zero-relative column number in the line."""
+ return serd_cursor_column(self._ptr)
+
+
+cdef class Event:
+ """An event in a data stream.
+
+ Streams of data are represented as a series of events. Events represent
+ everything that can occur in an RDF document, and are used to plumb
+ together different components. For example, when parsing a document, a
+ reader emits a stream of events which can be sent to a writer to serialise
+ a document, or to an inserter to build a model in memory.
+ """
+
+ cdef SerdEvent* _ptr
+ cdef SerdEventType _type
+ cdef Node _name
+ cdef Node _uri
+ cdef SerdStatementFlags _flags
+ cdef Statement _statement
+ cdef Node _node
+
+ @staticmethod
+ cdef Event _wrap(const SerdEvent* ptr):
+ event = Event()
+ event._type = ptr.type
+
+ if event._type == EventType.BASE:
+ base_event = <const SerdBaseEvent*>ptr
+ event._uri = Node._wrap(base_event.uri)
+ elif event._type == EventType.PREFIX:
+ prefix_event = <const SerdPrefixEvent*>ptr
+ event._name = Node._wrap(prefix_event.name)
+ event._uri = Node._wrap(prefix_event.uri)
+ elif event._type == EventType.STATEMENT:
+ statement_event = <const SerdStatementEvent*>ptr
+ event._flags = StatementFlags(statement_event.flags)
+ event._statement = Statement._wrap(statement_event.statement)
+ elif event._type == EventType.END:
+ end_event = <const SerdEndEvent*>ptr
+ event._node = Node._wrap(end_event.node)
+ else:
+ return None
+
+ return event
+
+ @staticmethod
+ def base(base_uri):
+ """Return an event that sets the base URI."""
+ event = Event()
+ event._type = EventType.BASE
+ event._uri = _uri_from_param(base_uri)
+ return event
+
+ @staticmethod
+ def prefix(name, namespace_uri):
+ """Return an event that sets a namespace prefix."""
+ event = Event()
+ event._type = EventType.PREFIX
+ event._name = string(name)
+ event._uri = _uri_from_param(namespace_uri)
+ return event
+
+ @staticmethod
+ def statement(statement, flags: StatementFlags = StatementFlags(0)):
+ """Return an event that represents a statement."""
+ assert type(statement) == Statement
+
+ event = Event()
+ event._type = EventType.STATEMENT
+ event._statement = Statement._from_param(statement)
+ event._flags = StatementFlags(flags)
+ return event
+
+ @staticmethod
+ def end(node):
+ """Return an event that ends an anonymous node description."""
+ event = Event()
+ event._type = EventType.END
+ event._node = _blank_from_param(node)
+ return event
+
+ def __eq__(self, rhs):
+ if type(rhs) != Event:
+ return False
+
+ other = <Event>rhs
+ if self._type != other._type:
+ return False
+ elif self._type == EventType.BASE:
+ return self._uri == other._uri
+ elif self._type == EventType.PREFIX:
+ return (self._name, self._uri) == (other._name, other._uri)
+ elif self._type == EventType.STATEMENT:
+ return (self._statement, self._flags) == (other._statement, other._flags)
+ elif self._type == EventType.END:
+ return self._node == other._node
+
+ return False
+
+ def __repr__(self):
+ def flags_repr(flags):
+ active = []
+ for f in [StatementFlags.EMPTY_S,
+ StatementFlags.ANON_S,
+ StatementFlags.ANON_O,
+ StatementFlags.LIST_S,
+ StatementFlags.LIST_O,
+ StatementFlags.TERSE_S,
+ StatementFlags.TERSE_O]:
+ if flags & f:
+ active += ['serd.' + str(f)]
+
+ return ' | '.join(active)
+
+ if self._type == EventType.BASE:
+ return 'serd.Event.base("%s")' % self._uri
+ elif self._type == EventType.PREFIX:
+ return 'serd.Event.prefix("%s", "%s")' % (self._name, self._uri)
+ elif self._type == EventType.STATEMENT:
+ result = 'serd.Event.statement(%s' % repr(self._statement)
+ if self._flags:
+ result += ', %s' % flags_repr(self._flags)
+
+ return result + ')'
+ elif self._type == EventType.END:
+ return 'serd.Event.end(%s)' % repr(self._node)
+
+ return "None"
+
+
+cdef class _SinkBase:
+ cdef const SerdSink* _cptr
+
+
+cdef class SinkView(_SinkBase):
+ @staticmethod
+ cdef SinkView _wrap(const SerdSink* cptr):
+ if cptr is NULL:
+ return None
+
+ cdef SinkView wrapper = SinkView.__new__(SinkView)
+ wrapper._cptr = cptr
+ return wrapper
+
+
+cdef class Sink(_SinkBase):
+ cdef SerdSink* _ptr
+ cdef Env _env
+ cdef object _func
+
+ @staticmethod
+ cdef Sink _manage(SerdSink* ptr):
+ if ptr is NULL:
+ return None
+
+ cdef Sink wrapper = Sink.__new__(Sink)
+ wrapper._cptr = ptr
+ wrapper._ptr = ptr
+ return wrapper
+
+ def __init__(self: Sink, func: callable = None):
+ if func is not None:
+ self._env = Env()
+ self._func = func
+ self._ptr = serd_sink_new(<void*>self, Sink._c_on_event, NULL)
+ self._cptr = self._ptr
+ # TODO: get_env?
+ else:
+ self._env = Env()
+ self._func = None
+ self._ptr = serd_sink_new(<void*>self, Sink._c_on_event, NULL)
+ self._cptr = self._ptr
+ # TODO: get_env?
+
+ def __dealloc__(self):
+ serd_sink_free(self._ptr)
+ self._ptr = NULL
+ self._cptr = NULL
+
+ def on_event(self, event: Event) -> Status:
+ return Status.SUCCESS
+
+ def __call__(self, event: Event) -> Status:
+ return self._func(event) if self._func is not None else Status.SUCCESS
+
+ @staticmethod
+ cdef SerdStatus _c_on_event(void* handle, const SerdEvent* event):
+ self = <Sink>handle
+ result = self.__call__(Event._wrap(event))
+ assert result is None or type(result) == Status
+ return result if result is not None else Status.SUCCESS