From 5ac5d901c4193c0744cfe7edff0b7dcafa026379 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Thu, 28 Dec 2023 19:29:57 +0100 Subject: [PATCH 01/37] Start creating Date collections --- .../time/{tstzcollection.py => timecollection.py} | 7 +++++-- pymeos/pymeos/collections/time/tstzset.py | 4 ++-- pymeos/pymeos/collections/time/tstzspan.py | 4 ++-- pymeos/pymeos/collections/time/tstzspanset.py | 4 ++-- 4 files changed, 11 insertions(+), 8 deletions(-) rename pymeos/pymeos/collections/time/{tstzcollection.py => timecollection.py} (72%) diff --git a/pymeos/pymeos/collections/time/tstzcollection.py b/pymeos/pymeos/collections/time/timecollection.py similarity index 72% rename from pymeos/pymeos/collections/time/tstzcollection.py rename to pymeos/pymeos/collections/time/timecollection.py index be631086..e047e802 100644 --- a/pymeos/pymeos/collections/time/tstzcollection.py +++ b/pymeos/pymeos/collections/time/timecollection.py @@ -1,10 +1,13 @@ from abc import ABC -from datetime import datetime +from datetime import date +from typing import TypeVar from ..base.collection import Collection +TimeClass = TypeVar("TimeClass", bound=date) -class TsTzCollection(Collection[datetime], ABC): + +class TimeCollection(Collection[TimeClass], ABC): def is_before(self, other) -> bool: return self.is_left(other) diff --git a/pymeos/pymeos/collections/time/tstzset.py b/pymeos/pymeos/collections/time/tstzset.py index 5f967ebf..137da010 100644 --- a/pymeos/pymeos/collections/time/tstzset.py +++ b/pymeos/pymeos/collections/time/tstzset.py @@ -6,7 +6,7 @@ from dateutil.parser import parse from pymeos_cffi import * -from .tstzcollection import TsTzCollection +from .timecollection import TimeCollection from ..base import Set if TYPE_CHECKING: @@ -17,7 +17,7 @@ from ...boxes import Box -class TsTzSet(Set[datetime], TsTzCollection): +class TsTzSet(Set[datetime], TimeCollection[datetime]): """ Class for representing lists of distinct timestamp values. diff --git a/pymeos/pymeos/collections/time/tstzspan.py b/pymeos/pymeos/collections/time/tstzspan.py index 5e6fd90f..2cc962ca 100644 --- a/pymeos/pymeos/collections/time/tstzspan.py +++ b/pymeos/pymeos/collections/time/tstzspan.py @@ -6,7 +6,7 @@ from dateutil.parser import parse from pymeos_cffi import * -from .tstzcollection import TsTzCollection +from .timecollection import TimeCollection from ..base.span import Span if TYPE_CHECKING: @@ -17,7 +17,7 @@ from .tstzset import TsTzSet -class TsTzSpan(Span[datetime], TsTzCollection): +class TsTzSpan(Span[datetime], TimeCollection[datetime]): """ Class for representing sets of contiguous timestamps between a lower and an upper bound. The bounds may be inclusive or not. diff --git a/pymeos/pymeos/collections/time/tstzspanset.py b/pymeos/pymeos/collections/time/tstzspanset.py index 72c3644c..4bde313e 100644 --- a/pymeos/pymeos/collections/time/tstzspanset.py +++ b/pymeos/pymeos/collections/time/tstzspanset.py @@ -6,7 +6,7 @@ from pymeos_cffi import * -from .tstzcollection import TsTzCollection +from .timecollection import TimeCollection if TYPE_CHECKING: from ...temporal import Temporal @@ -18,7 +18,7 @@ from ..base.spanset import SpanSet -class TsTzSpanSet(SpanSet[datetime], TsTzCollection): +class TsTzSpanSet(SpanSet[datetime], TimeCollection[datetime]): """ Class for representing lists of disjoint tstzspans. From 6e80eb1de737d583e4997a5fa31e93e715a60520 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Fri, 29 Dec 2023 11:40:08 +0100 Subject: [PATCH 02/37] Add date conversion functions --- .../pymeos_cffi/builder/templates/functions.py | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/pymeos_cffi/pymeos_cffi/builder/templates/functions.py b/pymeos_cffi/pymeos_cffi/builder/templates/functions.py index 28b1c985..20e61107 100644 --- a/pymeos_cffi/pymeos_cffi/builder/templates/functions.py +++ b/pymeos_cffi/pymeos_cffi/builder/templates/functions.py @@ -1,7 +1,7 @@ import os import logging -from datetime import datetime, timedelta +from datetime import datetime, timedelta, date from typing import Any, Tuple, Optional, List, Union import _meos_cffi @@ -52,16 +52,24 @@ def get_address(value: "Any") -> "Any *": return _ffi.addressof(value) -def datetime_to_timestamptz(dt: datetime) -> int: +def datetime_to_timestamptz(dt: datetime) -> "TimestampTz": return _lib.pg_timestamptz_in( dt.strftime("%Y-%m-%d %H:%M:%S%z").encode("utf-8"), -1 ) -def timestamptz_to_datetime(ts: int) -> datetime: +def timestamptz_to_datetime(ts: "TimestampTz") -> datetime: return parse(pg_timestamptz_out(ts)) +def date_to_date_adt(dt: date) -> "DateADT": + return _lib.pg_date_in(dt.strftime("%Y-%m-%d").encode("utf-8")) + + +def date_adt_to_date(ts: "DateADT") -> date: + return parse(pg_date_out(ts)).date() + + def timedelta_to_interval(td: timedelta) -> Any: return _ffi.new( "Interval *", From 52e3aabda401b24ce8092a554d218d88ef9156ac Mon Sep 17 00:00:00 2001 From: Diviloper Date: Fri, 29 Dec 2023 12:42:12 +0100 Subject: [PATCH 03/37] Add files for new date collections --- pymeos/pymeos/collections/time/dateset.py | 48 +++++++++++++++++++ pymeos/pymeos/collections/time/datespan.py | 0 pymeos/pymeos/collections/time/datespanset.py | 0 pymeos/pymeos/collections/time/time.py | 10 +++- 4 files changed, 56 insertions(+), 2 deletions(-) create mode 100644 pymeos/pymeos/collections/time/dateset.py create mode 100644 pymeos/pymeos/collections/time/datespan.py create mode 100644 pymeos/pymeos/collections/time/datespanset.py diff --git a/pymeos/pymeos/collections/time/dateset.py b/pymeos/pymeos/collections/time/dateset.py new file mode 100644 index 00000000..755ec24a --- /dev/null +++ b/pymeos/pymeos/collections/time/dateset.py @@ -0,0 +1,48 @@ +from __future__ import annotations + +from datetime import date, timedelta +from typing import Optional, List, Union, TYPE_CHECKING, overload, get_args + +from dateutil.parser import parse +from pymeos_cffi import * + +from .timecollection import TimeCollection +from ..base import Set + +if TYPE_CHECKING: + from ...temporal import Temporal + from .tstzspan import TsTzSpan + from .tstzspanset import TsTzSpanSet + from .time import Time + from ...boxes import Box + + +class DateSet(Set[date], TimeCollection[date]): + """ + Class for representing lists of distinct dates. + + ``DateSet`` objects can be created with a single argument of type + string as in MobilityDB. + + >>> DateSet(string='{2019-09-08, 2019-09-10, 2019-09-11}') + + Another possibility is to give a tuple or list of composing dates, + which can be instances of ``str`` or ``date``. The composing dates + must be given in increasing order. + + >>> DateSet(elements=['2019-09-08', '2019-09-10', '2019-09-11']) + >>> DateSet(elements=[parse('2019-09-08'), parse('2019-09-10'), parse('2019-09-11')]) + + """ + + __slots__ = ["_inner"] + + _mobilitydb_name = "dateset" + + _parse_function = dateset_in + _parse_value_function = ( + lambda x: pg_date_in(x) + if isinstance(x, str) + else date_to_date_adt(x) + ) + _make_function = dateset_make diff --git a/pymeos/pymeos/collections/time/datespan.py b/pymeos/pymeos/collections/time/datespan.py new file mode 100644 index 00000000..e69de29b diff --git a/pymeos/pymeos/collections/time/datespanset.py b/pymeos/pymeos/collections/time/datespanset.py new file mode 100644 index 00000000..e69de29b diff --git a/pymeos/pymeos/collections/time/time.py b/pymeos/pymeos/collections/time/time.py index 1437f7de..43ade70a 100644 --- a/pymeos/pymeos/collections/time/time.py +++ b/pymeos/pymeos/collections/time/time.py @@ -1,11 +1,17 @@ -from datetime import datetime +from datetime import datetime, date from typing import Union from .tstzspan import TsTzSpan from .tstzspanset import TsTzSpanSet from .tstzset import TsTzSet -Time = Union[datetime, TsTzSet, TsTzSpan, TsTzSpanSet] +Time = Union[ + datetime, + TsTzSet, + TsTzSpan, + TsTzSpanSet, + date, +] """ Union type that includes all Time types in PyMEOS: From f0a7b10a0100e9e3ed32ee00c385a6db17876bbb Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sat, 30 Dec 2023 21:04:25 +0100 Subject: [PATCH 04/37] Add DateSet --- pymeos/pymeos/collections/time/dateset.py | 635 +++++++++++++++++- pymeos/pymeos/collections/time/datespan.py | 25 + pymeos/pymeos/collections/time/datespanset.py | 25 + pymeos/pymeos/collections/time/time.py | 26 +- pymeos/pymeos/collections/time/tstzset.py | 69 +- pymeos/pymeos/plotters/time_plotter.py | 4 +- pymeos_cffi/pymeos_cffi/__init__.py | 5 + pymeos_cffi/pymeos_cffi/builder/meos.h | 3 + pymeos_cffi/pymeos_cffi/functions.py | 38 +- 9 files changed, 766 insertions(+), 64 deletions(-) diff --git a/pymeos/pymeos/collections/time/dateset.py b/pymeos/pymeos/collections/time/dateset.py index 755ec24a..e898419b 100644 --- a/pymeos/pymeos/collections/time/dateset.py +++ b/pymeos/pymeos/collections/time/dateset.py @@ -1,20 +1,47 @@ from __future__ import annotations -from datetime import date, timedelta -from typing import Optional, List, Union, TYPE_CHECKING, overload, get_args +from datetime import date, timedelta, datetime +from typing import TYPE_CHECKING, List, Optional, Union, overload from dateutil.parser import parse -from pymeos_cffi import * +from pymeos_cffi import ( + dateset_in, + pg_date_in, + date_to_date_adt, + dateset_make, + dateset_out, + date_to_tstzspan, + dateset_start_value, + date_adt_to_date, + dateset_end_value, + dateset_value_n, + dateset_values, + dateset_shift_scale, + contains_set_date, + before_set_date, + overbefore_set_date, + overafter_set_date, + after_set_date, + distance_set_date, + intersection_set_date, + intersection_set_set, + minus_set_date, + minus_set_set, + minus_date_set, + union_set_date, + union_set_set, +) from .timecollection import TimeCollection from ..base import Set if TYPE_CHECKING: - from ...temporal import Temporal + from .datespan import DateSpan + from .datespanset import DateSpanSet + from .tstzspanset import TsTzSpanSet from .tstzspan import TsTzSpan from .tstzspanset import TsTzSpanSet - from .time import Time - from ...boxes import Box + from .time import TimeDate class DateSet(Set[date], TimeCollection[date]): @@ -41,8 +68,598 @@ class DateSet(Set[date], TimeCollection[date]): _parse_function = dateset_in _parse_value_function = ( - lambda x: pg_date_in(x) - if isinstance(x, str) - else date_to_date_adt(x) + lambda x: pg_date_in(x) if isinstance(x, str) else date_to_date_adt(x) ) _make_function = dateset_make + + # ------------------------- Constructors ---------------------------------- + + # ------------------------- Output ---------------------------------------- + def __str__(self): + """ + Return the string representation of the content of ``self``. + + Returns: + A new :class:`str` instance + + MEOS Functions: + dateset_out + """ + return dateset_out(self._inner) + + # ------------------------- Conversions ----------------------------------- + def to_spanset(self) -> DateSpanSet: + """ + Returns a :class:`DateSpanSet` that contains a :class:`DateSpan` for each + date in ``self``. + + Returns: + A new :class:`DateSpanSet` instance + + MEOS Functions: + set_to_spanset + """ + from .datespanset import DateSpanSet + + return DateSpanSet(_inner=super().to_spanset()) + + def to_tstzspanset(self) -> TsTzSpanSet: + """ + Returns a TsTzSpanSet that contains a TsTzSpan for each Timestamp in + ``self``. + + Returns: + A new :class:`TsTzSpanSet` instance + + MEOS Functions: + set_to_spanset + """ + from .tstzspanset import TsTzSpanSet + from .tstzspan import TsTzSpan + + return TsTzSpanSet( + span_list=[ + TsTzSpan(_inner=date_to_tstzspan(date_to_date_adt(d))) + for d in self.elements() + ] + ) + + def to_span(self) -> DateSpan: + """ + Returns a :class:`DateSpan` that encompasses ``self``. + + Returns: + A new :class:`DateSpan` instance + + MEOS Functions: + set_span + """ + from .datespan import DateSpan + + return DateSpan(_inner=super().to_span()) + + # ------------------------- Accessors ------------------------------------- + def duration(self) -> timedelta: + """ + Returns the duration of the time ignoring gaps, i.e. the duration from + the first timestamp to the last one. + + Returns: + A :class:`datetime.timedelta` instance representing the duration of ``self`` + + MEOS Functions: + tstzspan_duration + """ + return self.to_tstzspanset().duration(ignore_gaps=True) + + def start_element(self) -> date: + """ + Returns the first date in ``self``. + Returns: + A :class:`date` instance + + MEOS Functions: + dateset_start_value + """ + return date_adt_to_date(dateset_start_value(self._inner)) + + def end_element(self) -> date: + """ + Returns the last date in ``self``. + Returns: + A :class:`date` instance + + MEOS Functions: + dateset_end_value + """ + return date_adt_to_date(dateset_end_value(self._inner)) + + def element_n(self, n: int) -> date: + """ + Returns the n-th date in ``self``. + Returns: + A :class:`date` instance + + MEOS Functions: + dateset_value_n + """ + super().element_n(n) + return date_adt_to_date(dateset_value_n(self._inner, n + 1)) + + def elements(self) -> List[date]: + """ + Returns the list of distinct dates in ``self``. + Returns: + A :class:`list[date]` instance + + MEOS Functions: + dateset_values + """ + tss = dateset_values(self._inner) + return [date_adt_to_date(tss[i]) for i in range(self.num_elements())] + + # ------------------------- Transformations ------------------------------- + def shift(self, delta: Union[timedelta, int]) -> DateSet: + """ + Returns a new :class:`DateSpanSet` that is the result of shifting ``self`` by + ``delta`` + + Examples: + >>> DateSet('{2000-01-01, 2000-01-10}').shift(timedelta(days=2)) + >>> 'DateSet({2000-01-03, 2000-01-12})' + + Args: + delta: :class:`datetime.timedelta` instance to shift + + Returns: + A new :class:`DateSpanSet` instance + + MEOS Functions: + dateset_shift_scale + """ + return self.shift_scale(shift=delta) + + def scale(self, duration: Union[timedelta, int]) -> DateSet: + """ + Returns a new :class:`DateSet` that with the scaled so that the span of + ``self`` is ``duration``. + + Examples: + >>> DateSet('{2000-01-01, 2000-01-10}').scale(timedelta(days=2)) + >>> 'DateSet({2000-01-01, 2000-01-03})' + + Args: + duration: :class:`datetime.timedelta` instance representing the + span of the new set + + Returns: + A new :class:`DateSet` instance + + MEOS Functions: + dateset_shift_scale + """ + return self.shift_scale(duration=duration) + + def shift_scale( + self, + shift: Union[int, timedelta, None] = None, + duration: Union[int, timedelta, None] = None, + ) -> DateSet: + """ + Returns a new :class:`DateSet` that is the result of shifting and scaling + ``self``. + + Examples: + >>> DateSet('{2000-01-01, 2000-01-10}').shift_scale(shift=timedelta(days=2), duration=timedelta(days=4)) + >>> 'DateSet({2000-01-03, 2000-01-07})' + + Args: + shift: :class:`datetime.timedelta` instance to shift + duration: :class:`datetime.timedelta` instance representing the + span of the new set + + Returns: + A new :class:`DateSet` instance + + MEOS Functions: + dateset_shift_scale + """ + assert ( + shift is not None or duration is not None + ), "shift and scale deltas must not be both None" + shift = ( + shift.days + if isinstance(shift, timedelta) + else int(shift) + if shift is not None + else 0 + ) + duration = ( + duration.days + if isinstance(duration, timedelta) + else int(duration) + if duration is not None + else 0 + ) + tss = dateset_shift_scale( + self._inner, shift, duration, shift != 0, duration != 0 + ) + return DateSet(_inner=tss) + + def contains(self, content: Union[date, datetime, DateSet]) -> bool: + """ + Returns whether ``self`` temporally contains ``content``. + + Examples: + >>> DateSet('{2012-01-01, 2012-01-04}').contains(parse('2012-01-01').date()) + >>> True + >>> DateSet('{2012-01-01, 2012-01-02}').contains(DateSet('{2012-01-01}')) + >>> True + >>> DateSet('{2012-01-01, 2012-01-02}').contains(DateSet('{2012-01-01, 2012-01-03}')) + >>> False + + Args: + content: temporal object to compare with + + Returns: + True if contains, False otherwise + + MEOS Functions: + contains_set_date, contains_set_set, contains_spanset_spanset + """ + + if isinstance(content, date): + return contains_set_date(self._inner, date_to_date_adt(content)) + if isinstance(content, datetime): + return contains_set_date(self._inner, date_to_date_adt(content.date())) + else: + return super().contains(content) + + def __contains__(self, item): + """ + Returns whether ``self`` temporally contains ``content``. + + Examples: + >>> DateSet('{2012-01-01, 2012-01-04}').contains(parse('2012-01-01').date()) + >>> True + >>> DateSet('{2012-01-01, 2012-01-02}').contains(DateSet('{2012-01-01}')) + >>> True + >>> DateSet('{2012-01-01, 2012-01-02}').contains(DateSet('{2012-01-01, 2012-01-03}')) + >>> False + + Args: + item: temporal object to compare with + + Returns: + True if contains, False otherwise + + MEOS Functions: + contains_set_date, contains_set_set, contains_spanset_spanset + """ + return self.contains(item) + + def overlaps(self, other: Union[date, DateSet, DateSpan, DateSpanSet]) -> bool: + """ + Returns whether ``self`` temporally overlaps ``other``. That is, both + share at least an instant + + Examples: + >>> DateSet('{2012-01-01, 2012-01-02}').overlaps(DateSet('{2012-01-02, 2012-01-03}')) + >>> True + >>> DateSet('{2012-01-01, 2012-01-02}').overlaps(DateSpan('[2012-01-02, 2012-01-03]')) + >>> True + >>> DateSet('{2012-01-01, 2012-01-02}').overlaps(DateSpan('(2012-01-02, 2012-01-03]')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if overlaps, False otherwise + + MEOS Functions: + overlaps_set_set, overlaps_span_span, overlaps_spanset_spanset + """ + + if isinstance(other, datetime): + return contains_set_date(self._inner, date_to_date_adt(other)) + elif isinstance(other, DateSpan): + return self.to_span().is_adjacent(other) + elif isinstance(other, DateSpanSet): + return self.to_spanset().is_adjacent(other) + else: + return super().overlaps(other) + + # ------------------------- Position Operations --------------------------- + def is_left(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` is strictly before ``other``. That is, + ``self`` ends before ``other`` starts. + + Examples: + >>> DateSet('{2012-01-01, 2012-01-02}').is_left(DateSet('{2012-01-03}')) + >>> True + >>> DateSet('{2012-01-01, 2012-01-02}').is_left(DateSpan('(2012-01-02, 2012-01-03]')) + >>> True + >>> DateSet('{2012-01-01, 2012-01-02}').is_left(DateSpan('[2012-01-02, 2012-01-03]')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if before, False otherwise + + MEOS Functions: + before_set_date, left_span_span + """ + + if isinstance(other, date): + return before_set_date(self._inner, date_to_date_adt(other)) + elif isinstance(other, DateSpan): + return self.to_span().is_left(other) + elif isinstance(other, DateSpanSet): + return self.to_span().is_left(other) + else: + return super().is_left(other) + + def is_over_or_left(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` is before ``other`` allowing overlap. That is, + ``self`` ends before ``other`` ends (or at the same time). + + Examples: + >>> DateSet('{2012-01-01, 2012-01-02}').is_over_or_left(DateSpan('[2012-01-02, 2012-01-03]')) + >>> True + >>> DateSet('{2012-01-01, 2012-01-02}').is_over_or_left(DateSpan('[2012-01-02, 2012-01-03]')) + >>> True + >>> DateSet('{2012-01-03, 2012-01-05}').is_over_or_left(DateSpan('[2012-01-01, 2012-01-04]')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if before, False otherwise + + MEOS Functions: + overbefore_set_date, overleft_span_span, overleft_span_spanset + """ + if isinstance(other, date): + return overbefore_set_date(self._inner, date_to_date_adt(other)) + elif isinstance(other, DateSpan): + return self.to_span().is_over_or_left(other) + elif isinstance(other, DateSpanSet): + return self.to_span().is_over_or_left(other) + else: + return super().is_over_or_left(other) + + def is_over_or_right(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` is after ``other`` allowing overlap. That is, + ``self`` starts after ``other`` starts (or at the same time). + + Examples: + >>> DateSet('{2012-01-02, 2012-01-03}').is_over_or_right(DateSpan('[2012-01-01, 2012-01-02)')) + >>> True + >>> DateSet('{2012-01-02, 2012-01-03}').is_over_or_right(DateSpan('[2012-01-01, 2012-01-02]')) + >>> True + >>> DateSet('{2012-01-02, 2012-01-03}').is_over_or_right(DateSpan('[2012-01-01, 2012-01-03]')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if overlapping or after, False otherwise + + MEOS Functions: + overafter_set_date, overright_span_span, overright_span_spanset + """ + if isinstance(other, date): + return overafter_set_date(self._inner, date_to_date_adt(other)) + elif isinstance(other, DateSpan): + return self.to_span().is_over_or_after(other) + elif isinstance(other, DateSpanSet): + return self.to_span().is_over_or_after(other) + else: + return super().is_over_or_left(other) + + def is_right(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` is strictly after ``other``. That is, the + first timestamp in ``self`` is after ``other``. + + Examples: + >>> DateSet('{2012-01-02, 2012-01-03}').is_right(DateSpan('[2012-01-01, 2012-01-02)')) + >>> True + >>> DateSet('{2012-01-02, 2012-01-03}').is_right(DateSet('{2012-01-01}')) + >>> True + >>> DateSet('{2012-01-02, 2012-01-03}').is_right(DateSpan('[2012-01-01, 2012-01-02]')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if after, False otherwise + + MEOS Functions: + after_set_date, right_span_span, right_span_spanset + """ + if isinstance(other, date): + return after_set_date(self._inner, date_to_date_adt(other)) + elif isinstance(other, DateSpan): + return self.to_span().is_after(other) + elif isinstance(other, DateSpanSet): + return self.to_span().is_after(other) + else: + return super().is_over_or_left(other) + + # ------------------------- Distance Operations --------------------------- + def distance(self, other: Union[TimeDate]) -> timedelta: + """ + Returns the temporal distance between ``self`` and ``other``. + + Args: + other: temporal object to compare with + + Returns: + A :class:`datetime.timedelta` instance + + MEOS Functions: + distance_set_timestamptz, distance_set_set, + distance_span_span, distance_spanset_span + """ + + if isinstance(other, date): + return timedelta( + seconds=distance_set_date(self._inner, date_to_date_adt(other)) + ) + else: + return timedelta(seconds=super().distance(other)) + + # ------------------------- Set Operations -------------------------------- + @overload + def intersection(self, other: date) -> Optional[date]: + ... + + @overload + def intersection(self, other: DateSet) -> Optional[DateSet]: + ... + + @overload + def intersection( + self, other: Union[DateSpan, DateSpanSet] + ) -> Optional[DateSpanSet]: + ... + + def intersection(self, other: Union[TimeDate]) -> Optional[TimeDate]: + """ + Returns the temporal intersection of ``self`` and ``other``. + + Args: + other: temporal object to intersect with + + Returns: + A :class:`TimeDate` instance. The actual class depends on ``other``. + + MEOS Functions: + intersection_set_date, intersection_set_set, intersection_spanset_span, + intersection_spanset_spanset + """ + from .datespan import DateSpan + from .datespanset import DateSpanSet + + if isinstance(other, date): + result = intersection_set_date(self._inner, date_to_date_adt(other)) + return date_adt_to_date(result) if result is not None else None + elif isinstance(other, DateSet): + result = intersection_set_set(self._inner, other._inner) + return DateSet(_inner=result) if result is not None else None + elif isinstance(other, DateSpan): + return self.to_spanset().intersection(other) + elif isinstance(other, DateSpanSet): + return self.to_spanset().intersection(other) + else: + return super().intersection(other) + + @overload + def minus(self, other: Union[date, DateSet]) -> Optional[DateSet]: + ... + + @overload + def minus(self, other: Union[DateSpan, DateSpanSet]) -> Optional[DateSpanSet]: + ... + + def minus(self, other: Union[TimeDate]) -> Optional[TimeDate]: + """ + Returns the temporal difference of ``self`` and ``other``. + + Args: + other: temporal object to diff with + + Returns: + A :class:`TimeDate` instance. The actual class depends on ``other``. + + MEOS Functions: + minus_set_date, minus_set_set, minus_spanset_span, + minus_spanset_spanset + """ + from .datespan import DateSpan + from .datespanset import DateSpanSet + + if isinstance(other, date): + result = minus_set_date(self._inner, date_to_date_adt(other)) + return DateSet(_inner=result) if result is not None else None + elif isinstance(other, DateSet): + result = minus_set_set(self._inner, other._inner) + return DateSet(_inner=result) if result is not None else None + elif isinstance(other, DateSpan): + return self.to_spanset().minus(other) + elif isinstance(other, DateSpanSet): + return self.to_spanset().minus(other) + else: + return super().minus(other) + + def subtract_from(self, other: date) -> Optional[date]: + """ + Returns the difference of ``other`` and ``self``. + + Args: + other: A :class:`date` instance + + Returns: + A :class:`datetime` instance or ``None`` if the difference is empty. + + MEOS Functions: + minus_date_set + + See Also: + :meth:`minus` + """ + return date_adt_to_date(minus_date_set(date_to_date_adt(other), self._inner)) + + @overload + def union(self, other: Union[date, DateSet]) -> DateSet: + ... + + @overload + def union(self, other: Union[DateSpan, DateSpanSet]) -> DateSpanSet: + ... + + def union(self, other: Union[TimeDate]) -> Union[DateSpanSet, DateSet]: + """ + Returns the temporal union of ``self`` and ``other``. + + Args: + other: temporal object to merge with + + Returns: + A :class:`TimeDate` instance. The actual class depends on ``other``. + + MEOS Functions: + union_set_date, union_set_set, union_spanset_span, + union_spanset_spanset + """ + from .datespan import DateSpan + from .datespanset import DateSpanSet + + if isinstance(other, date): + return DateSet(_inner=union_set_date(self._inner, date_to_date_adt(other))) + elif isinstance(other, DateSet): + return DateSet(_inner=union_set_set(self._inner, other._inner)) + elif isinstance(other, DateSpan): + return self.to_spanset().union(other) + elif isinstance(other, DateSpanSet): + return self.to_spanset().union(other) + else: + return super().union(other) + + # ------------------------- Comparisons ----------------------------------- + + # ------------------------- Plot Operations ------------------------------- + def plot(self, *args, **kwargs): + from ...plotters import TimePlotter + + return TimePlotter.plot_tstzspanset(self.to_tstzspanset(), *args, **kwargs) diff --git a/pymeos/pymeos/collections/time/datespan.py b/pymeos/pymeos/collections/time/datespan.py index e69de29b..e046fbbb 100644 --- a/pymeos/pymeos/collections/time/datespan.py +++ b/pymeos/pymeos/collections/time/datespan.py @@ -0,0 +1,25 @@ +from __future__ import annotations + +from datetime import date +from typing import TYPE_CHECKING, List + +from dateutil.parser import parse +from pymeos_cffi import ( + dateset_in, + pg_date_in, + date_to_date_adt, + dateset_make, + dateset_out, +) + +from .timecollection import TimeCollection +from ..base import Set +from ..base.set import T +from ... import Span, SpanSet + +if TYPE_CHECKING: + pass + + +class DateSpan(Span[date], TimeCollection[date]): + pass diff --git a/pymeos/pymeos/collections/time/datespanset.py b/pymeos/pymeos/collections/time/datespanset.py index e69de29b..7c1a2647 100644 --- a/pymeos/pymeos/collections/time/datespanset.py +++ b/pymeos/pymeos/collections/time/datespanset.py @@ -0,0 +1,25 @@ +from __future__ import annotations + +from datetime import date +from typing import TYPE_CHECKING, List + +from dateutil.parser import parse +from pymeos_cffi import ( + dateset_in, + pg_date_in, + date_to_date_adt, + dateset_make, + dateset_out, +) + +from .timecollection import TimeCollection +from ..base import Set +from ..base.set import T +from ... import Span, SpanSet + +if TYPE_CHECKING: + pass + + +class DateSpanSet(SpanSet[date], TimeCollection[date]): + pass diff --git a/pymeos/pymeos/collections/time/time.py b/pymeos/pymeos/collections/time/time.py index 43ade70a..bd2b3881 100644 --- a/pymeos/pymeos/collections/time/time.py +++ b/pymeos/pymeos/collections/time/time.py @@ -5,18 +5,36 @@ from .tstzspanset import TsTzSpanSet from .tstzset import TsTzSet +from .datespan import DateSpan +from .datespanset import DateSpanSet +from .dateset import DateSet + Time = Union[ datetime, TsTzSet, TsTzSpan, TsTzSpanSet, - date, ] """ -Union type that includes all Time types in PyMEOS: +Union type that includes all Time types related to timestamps in PyMEOS: - :class:`~datetime.datetime` for timestamps - :class:`~pymeos.time.tstzset.TsTzSet` for sets of timestamps -- :class:`~pymeos.time.tstzspan.TsTzSpan` for tstzspans of time -- :class:`~pymeos.time.tstzspanset.TsTzSpanSet` for sets of tstzspans of time +- :class:`~pymeos.time.tstzspan.TsTzSpan` for spans of time +- :class:`~pymeos.time.tstzspanset.TsTzSpanSet` for sets of spans of time +""" + +TimeDate = Union[ + date, + DateSet, + DateSpan, + DateSpanSet, +] +""" +Union type that includes all Time types related to dates in PyMEOS: + +- :class:`~datetime.date` for timestamps +- :class:`~pymeos.time.dateset.DateSet` for sets of dates +- :class:`~pymeos.time.datespan.DateSpan` for spans of dates +- :class:`~pymeos.time.datespanset.DateSpanSet` for sets of spans of dates """ diff --git a/pymeos/pymeos/collections/time/tstzset.py b/pymeos/pymeos/collections/time/tstzset.py index 137da010..14eaf982 100644 --- a/pymeos/pymeos/collections/time/tstzset.py +++ b/pymeos/pymeos/collections/time/tstzset.py @@ -78,19 +78,6 @@ def to_spanset(self) -> TsTzSpanSet: return TsTzSpanSet(_inner=super().to_spanset()) - def to_tstzspanset(self) -> TsTzSpanSet: - """ - Returns a TsTzSpanSet that contains a TsTzSpan for each Timestamp in - ``self``. - - Returns: - A new :class:`TsTzSpanSet` instance - - MEOS Functions: - set_to_spanset - """ - return self.to_spanset() - def to_span(self) -> TsTzSpan: """ Returns a tstzspan that encompasses ``self``. @@ -105,18 +92,6 @@ def to_span(self) -> TsTzSpan: return TsTzSpan(_inner=super().to_span()) - def to_tstzspan(self) -> TsTzSpan: - """ - Returns a tstzspan that encompasses ``self``. - - Returns: - A new :class:`TsTzSpan` instance - - MEOS Functions: - set_span - """ - return self.to_span() - # ------------------------- Accessors ------------------------------------- def duration(self) -> timedelta: """ @@ -281,7 +256,7 @@ def is_adjacent(self, other: Union[TsTzSpan, TsTzSpanSet, Temporal, Box]) -> boo if isinstance(other, Temporal): return self.is_adjacent(other.time()) elif isinstance(other, get_args(Box)): - return self.is_adjacent(other.to_tstzspan()) + return self.is_adjacent(other.to_span()) else: super().is_adjacent(other) @@ -315,7 +290,7 @@ def is_contained_in( if isinstance(container, Temporal): return self.is_contained_in(container.time()) elif isinstance(container, get_args(Box)): - return self.is_contained_in(container.to_tstzspan()) + return self.is_contained_in(container.to_span()) else: return super().is_contained_in(container) @@ -428,7 +403,7 @@ def is_same(self, other: Union[Time, Temporal, Box]) -> bool: See Also: :meth:`TsTzSpan.is_same` """ - return self.to_tstzspan().is_same(other) + return self.to_span().is_same(other) # ------------------------- Position Operations --------------------------- def is_left(self, other: Union[Time, Temporal, Box]) -> bool: @@ -461,9 +436,9 @@ def is_left(self, other: Union[Time, Temporal, Box]) -> bool: datetime_to_timestamptz(other), self._inner ) elif isinstance(other, Temporal): - return self.to_tstzspan().is_left(other) + return self.to_span().is_left(other) elif isinstance(other, get_args(Box)): - return self.to_tstzspan().is_left(other) + return self.to_span().is_left(other) else: return super().is_left(other) @@ -497,9 +472,9 @@ def is_over_or_left(self, other: Union[Time, Temporal, Box]) -> bool: datetime_to_timestamptz(other), self._inner ) elif isinstance(other, Temporal): - return self.to_tstzspan().is_over_or_left(other) + return self.to_span().is_over_or_left(other) elif isinstance(other, get_args(Box)): - return self.to_tstzspan().is_over_or_left(other.to_tstzspan()) + return self.to_span().is_over_or_left(other.to_span()) else: return super().is_over_or_left(other) @@ -533,9 +508,9 @@ def is_over_or_right(self, other: Union[Time, Temporal, Box]) -> bool: datetime_to_timestamptz(other), self._inner ) elif isinstance(other, Temporal): - return self.to_tstzspan().is_over_or_right(other) + return self.to_span().is_over_or_right(other) elif isinstance(other, get_args(Box)): - return self.to_tstzspan().is_over_or_right(other) + return self.to_span().is_over_or_right(other) else: return super().is_over_or_right(other) @@ -570,9 +545,9 @@ def is_right(self, other: Union[Time, Temporal, Box]) -> bool: datetime_to_timestamptz(other), self._inner ) elif isinstance(other, Temporal): - return self.to_tstzspan().is_right(other) + return self.to_span().is_right(other) elif isinstance(other, get_args(Box)): - return self.to_tstzspan().is_right(other) + return self.to_span().is_right(other) else: return super().is_right(other) @@ -601,9 +576,9 @@ def distance(self, other: Union[Time, Temporal, Box]) -> timedelta: ) ) elif isinstance(other, Temporal): - return self.to_tstzspan().distance(other) + return self.to_span().distance(other) elif isinstance(other, get_args(Box)): - return self.to_tstzspan().distance(other) + return self.to_span().distance(other) else: return timedelta(seconds=super().distance(other)) @@ -648,13 +623,13 @@ def intersection(self, other: Union[Time, Temporal]) -> Optional[Time]: result = intersection_set_set(self._inner, other._inner) return TsTzSet(_inner=result) if result is not None else None elif isinstance(other, TsTzSpan): - return self.to_tstzspanset().intersection(other) + return self.to_spanset().intersection(other) elif isinstance(other, TsTzSpanSet): - return self.to_tstzspanset().intersection(other) + return self.to_spanset().intersection(other) elif isinstance(other, Temporal): return self.intersection(other.time()) elif isinstance(other, get_args(Box)): - return self.intersection(other.to_tstzspan()) + return self.intersection(other.to_span()) else: return super().intersection(other) @@ -694,13 +669,13 @@ def minus(self, other: Union[Time, Temporal, Box]) -> Optional[Time]: result = minus_set_set(self._inner, other._inner) return TsTzSet(_inner=result) if result is not None else None elif isinstance(other, TsTzSpan): - return self.to_tstzspanset().minus(other) + return self.to_spanset().minus(other) elif isinstance(other, TsTzSpanSet): - return self.to_tstzspanset().minus(other) + return self.to_spanset().minus(other) elif isinstance(other, Temporal): return self.minus(other.time()) elif isinstance(other, get_args(Box)): - return self.minus(other.to_tstzspan()) + return self.minus(other.to_span()) else: return super().minus(other) @@ -760,13 +735,13 @@ def union( elif isinstance(other, TsTzSet): return TsTzSet(_inner=union_set_set(self._inner, other._inner)) elif isinstance(other, TsTzSpan): - return self.to_tstzspanset().union(other) + return self.to_spanset().union(other) elif isinstance(other, TsTzSpanSet): - return self.to_tstzspanset().union(other) + return self.to_spanset().union(other) elif isinstance(other, Temporal): return self.union(other.time()) elif isinstance(other, get_args(Box)): - return self.union(other.to_tstzspan()) + return self.union(other.to_span()) else: return super().union(other) diff --git a/pymeos/pymeos/plotters/time_plotter.py b/pymeos/pymeos/plotters/time_plotter.py index 3a6f6d63..98539aec 100644 --- a/pymeos/pymeos/plotters/time_plotter.py +++ b/pymeos/pymeos/plotters/time_plotter.py @@ -1,8 +1,10 @@ from datetime import datetime +from typing import Union from matplotlib import pyplot as plt from ..collections import TsTzSet, TsTzSpan, TsTzSpanSet +from ..collections.time.dateset import DateSet class TimePlotter: @@ -42,7 +44,7 @@ def plot_tstzset(tstzset: TsTzSet, *args, axes=None, **kwargs): List with the plotted elements. """ base = axes or plt.gca() - stamps = tstzset.timestamps() + stamps = tstzset.elements() plot = base.axvline(stamps[0], *args, **kwargs) kwargs.pop("label", None) plots = [plot] diff --git a/pymeos_cffi/pymeos_cffi/__init__.py b/pymeos_cffi/pymeos_cffi/__init__.py index af9dcb6b..e565e7cc 100644 --- a/pymeos_cffi/pymeos_cffi/__init__.py +++ b/pymeos_cffi/pymeos_cffi/__init__.py @@ -39,6 +39,8 @@ "get_address", "datetime_to_timestamptz", "timestamptz_to_datetime", + "date_to_date_adt", + "date_adt_to_date", "timedelta_to_interval", "interval_to_timedelta", "geo_to_gserialized", @@ -603,15 +605,18 @@ "distance_set_int", "distance_set_set", "distance_set_timestamptz", + "distance_set_date", "distance_span_bigint", "distance_span_float", "distance_span_int", "distance_span_span", "distance_span_timestamptz", + "distance_span_date", "distance_spanset_bigint", "distance_spanset_float", "distance_spanset_int", "distance_spanset_timestamptz", + "distance_spanset_date", "distance_spanset_span", "distance_spanset_spanset", "set_cmp", diff --git a/pymeos_cffi/pymeos_cffi/builder/meos.h b/pymeos_cffi/pymeos_cffi/builder/meos.h index dae3db17..ace5cdf2 100644 --- a/pymeos_cffi/pymeos_cffi/builder/meos.h +++ b/pymeos_cffi/pymeos_cffi/builder/meos.h @@ -1097,15 +1097,18 @@ extern double distance_set_float(const Set *s, double d); extern double distance_set_int(const Set *s, int i); extern double distance_set_set(const Set *s1, const Set *s2); extern double distance_set_timestamptz(const Set *s, TimestampTz t); +extern double distance_set_date(const Set *s, DateADT d); extern double distance_span_bigint(const Span *s, int64 i); extern double distance_span_float(const Span *s, double d); extern double distance_span_int(const Span *s, int i); extern double distance_span_span(const Span *s1, const Span *s2); extern double distance_span_timestamptz(const Span *s, TimestampTz t); +extern double distance_span_date(const Span *s, DateADT d); extern double distance_spanset_bigint(const SpanSet *ss, int64 i); extern double distance_spanset_float(const SpanSet *ss, double d); extern double distance_spanset_int(const SpanSet *ss, int i); extern double distance_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern double distance_spanset_date(const SpanSet *ss, DateADT d); extern double distance_spanset_span(const SpanSet *ss, const Span *s); extern double distance_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); diff --git a/pymeos_cffi/pymeos_cffi/functions.py b/pymeos_cffi/pymeos_cffi/functions.py index 5b4f834e..b85df228 100644 --- a/pymeos_cffi/pymeos_cffi/functions.py +++ b/pymeos_cffi/pymeos_cffi/functions.py @@ -1,7 +1,7 @@ import os import logging -from datetime import datetime, timedelta +from datetime import datetime, timedelta, date from typing import Any, Tuple, Optional, List, Union import _meos_cffi @@ -52,16 +52,24 @@ def get_address(value: "Any") -> "Any *": return _ffi.addressof(value) -def datetime_to_timestamptz(dt: datetime) -> int: +def datetime_to_timestamptz(dt: datetime) -> "TimestampTz": return _lib.pg_timestamptz_in( dt.strftime("%Y-%m-%d %H:%M:%S%z").encode("utf-8"), -1 ) -def timestamptz_to_datetime(ts: int) -> datetime: +def timestamptz_to_datetime(ts: "TimestampTz") -> datetime: return parse(pg_timestamptz_out(ts)) +def date_to_date_adt(dt: date) -> "DateADT": + return _lib.pg_date_in(dt.strftime("%Y-%m-%d").encode("utf-8")) + + +def date_adt_to_date(ts: "DateADT") -> date: + return parse(pg_date_out(ts)).date() + + def timedelta_to_interval(td: timedelta) -> Any: return _ffi.new( "Interval *", @@ -4437,6 +4445,14 @@ def distance_set_timestamptz(s: "const Set *", t: int) -> "double": return result if result != _ffi.NULL else None +def distance_set_date(s: "const Set *", d: "DateADT") -> "double": + s_converted = _ffi.cast("const Set *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.distance_set_date(s_converted, d_converted) + _check_error() + return result if result != _ffi.NULL else None + + def distance_span_bigint(s: "const Span *", i: int) -> "double": s_converted = _ffi.cast("const Span *", s) i_converted = _ffi.cast("int64", i) @@ -4475,6 +4491,14 @@ def distance_span_timestamptz(s: "const Span *", t: int) -> "double": return result if result != _ffi.NULL else None +def distance_span_date(s: "const Span *", d: "DateADT") -> "double": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.distance_span_date(s_converted, d_converted) + _check_error() + return result if result != _ffi.NULL else None + + def distance_spanset_bigint(ss: "const SpanSet *", i: int) -> "double": ss_converted = _ffi.cast("const SpanSet *", ss) i_converted = _ffi.cast("int64", i) @@ -4505,6 +4529,14 @@ def distance_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "double": return result if result != _ffi.NULL else None +def distance_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "double": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.distance_spanset_date(ss_converted, d_converted) + _check_error() + return result if result != _ffi.NULL else None + + def distance_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "double": ss_converted = _ffi.cast("const SpanSet *", ss) s_converted = _ffi.cast("const Span *", s) From ba96859b46fce1217dba4d8150abcb607d7f7c69 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 31 Dec 2023 16:21:02 +0100 Subject: [PATCH 05/37] Add DateSpan --- pymeos/pymeos/collections/base/span.py | 4 +- pymeos/pymeos/collections/time/dateset.py | 2 + pymeos/pymeos/collections/time/datespan.py | 556 ++++++++++++++++++++- pymeos/pymeos/collections/time/tstzspan.py | 12 - pymeos_cffi/pymeos_cffi/__init__.py | 8 + pymeos_cffi/pymeos_cffi/builder/meos.h | 8 + pymeos_cffi/pymeos_cffi/functions.py | 62 +++ pymeos_examples/PyMEOS_Examples/AIS.ipynb | 177 +++---- 8 files changed, 706 insertions(+), 123 deletions(-) diff --git a/pymeos/pymeos/collections/base/span.py b/pymeos/pymeos/collections/base/span.py index 5d8f2fd3..5295e8de 100644 --- a/pymeos/pymeos/collections/base/span.py +++ b/pymeos/pymeos/collections/base/span.py @@ -546,10 +546,10 @@ def union(self, other): other: temporal object to merge with Returns: - A :class:`TsTzSpanSet` instance. + A :class:`SpanSet` instance. MEOS Functions: - union_tstzspan_timestamp, union_spanset_span, union_span_span + union_spanset_span, union_span_span """ from .spanset import SpanSet diff --git a/pymeos/pymeos/collections/time/dateset.py b/pymeos/pymeos/collections/time/dateset.py index e898419b..1a65de6a 100644 --- a/pymeos/pymeos/collections/time/dateset.py +++ b/pymeos/pymeos/collections/time/dateset.py @@ -286,6 +286,8 @@ def shift_scale( ) return DateSet(_inner=tss) + # ------------------------- Topological Operations ------------------------ + def contains(self, content: Union[date, datetime, DateSet]) -> bool: """ Returns whether ``self`` temporally contains ``content``. diff --git a/pymeos/pymeos/collections/time/datespan.py b/pymeos/pymeos/collections/time/datespan.py index e046fbbb..ea67ea0a 100644 --- a/pymeos/pymeos/collections/time/datespan.py +++ b/pymeos/pymeos/collections/time/datespan.py @@ -1,25 +1,559 @@ from __future__ import annotations -from datetime import date -from typing import TYPE_CHECKING, List +from datetime import date, timedelta +from typing import TYPE_CHECKING, Union, Optional, overload from dateutil.parser import parse from pymeos_cffi import ( - dateset_in, - pg_date_in, + datespan_in, date_to_date_adt, - dateset_make, - dateset_out, + pg_date_in, + datespan_make, + datespan_out, + datespan_to_tstzspan, + date_adt_to_date, + interval_to_timedelta, + datespan_duration, + datespan_upper, + datespan_lower, + datespan_shift_scale, + union_span_date, + minus_span_date, + minus_span_span, + minus_span_spanset, + intersection_span_date, + intersection_span_span, + intersection_spanset_span, + distance_span_date, + overafter_span_date, + after_span_date, + overbefore_span_date, + before_span_date, + contains_span_date, ) from .timecollection import TimeCollection -from ..base import Set -from ..base.set import T -from ... import Span, SpanSet +from ..base import Span if TYPE_CHECKING: - pass + from .dateset import DateSet + from .datespanset import DateSpanSet + from .tstzspan import TsTzSpan + from .time import TimeDate class DateSpan(Span[date], TimeCollection[date]): - pass + """ + Class for representing sets of contiguous dates between a lower and + an upper bound. The bounds may be inclusive or not. + + ``DateSpan`` objects can be created with a single argument of type string + as in MobilityDB. + + >>> DateSpan('(2019-09-08, 2019-09-10)') + + Another possibility is to provide the ``lower`` and ``upper`` named + parameters (of type str or date), and optionally indicate whether the + bounds are inclusive or exclusive (by default, the lower bound is inclusive + and the upper is exclusive): + + >>> DateSpan(lower='2019-09-08', upper='2019-09-10') + >>> DateSpan(lower='2019-09-08', upper='2019-09-10', lower_inc=False, upper_inc=True) + >>> DateSpan(lower=parse('2019-09-08'), upper=parse('2019-09-10'), upper_inc=True) + """ + + __slots__ = ["_inner"] + + _mobilitydb_name = "datespan" + + _parse_function = datespan_in + _parse_value_function = ( + lambda x: pg_date_in(x) if isinstance(x, str) else date_to_date_adt(x) + ) + _make_function = datespan_make + + # ------------------------- Constructors ---------------------------------- + + # ------------------------- Output ---------------------------------------- + def __str__(self): + """ + Return the string representation of the content of ``self``. + + Returns: + A new :class:`str` instance + + MEOS Functions: + datespan_out + """ + return datespan_out(self._inner) + + # ------------------------- Conversions ----------------------------------- + + def to_spanset(self) -> DateSpanSet: + """ + Returns a :class:`DateSpanSet` set containing ``self``. + + Returns: + A new :class:`DateSpanSet` instance + + MEOS Functions: + span_to_spanset + """ + from .datespanset import DateSpanSet + + return DateSpanSet(_inner=super().to_spanset()) + + def to_tstzspan(self) -> TsTzSpan: + """ + Returns a :class:`TsTzSpan equivalent to ``self``. + + Returns: + A new :class:`TsTzSpan` instance + + MEOS Functions: + datespan_to_tstzspan + """ + from .tstzspan import TsTzSpan + + return TsTzSpan(_inner=datespan_to_tstzspan(self._inner)) + + # ------------------------- Accessors ------------------------------------- + def lower(self) -> date: + """ + Returns the lower bound of ``self``. + + Returns: + The lower bound of the :class:`DateSpan` as a :class:`datetime.datetime` + + MEOS Functions: + datespan_lower + """ + + return date_adt_to_date(datespan_lower(self._inner)) + + def upper(self) -> date: + """ + Returns the upper bound of ``self``. + + Returns: + The upper bound of the :class:`DateSpan` as a :class:`datetime.date` + + MEOS Functions: + datespan_upper + """ + return date_adt_to_date(datespan_upper(self._inner)) + + def duration(self) -> timedelta: + """ + Returns the duration of ``self``. + + Returns: + A :class:`datetime.timedelta` instance representing the duration of + the :class:`DateSpan` + + MEOS Functions: + datespan_duration + """ + return interval_to_timedelta(datespan_duration(self._inner)) + + def duration_in_days(self) -> float: + """ + Returns the duration of ``self``. + + Returns: + Returns a `float` representing the duration of the :class:`DateSpan` in + days + + MEOS Functions: + span_width + """ + return self.width() + + # ------------------------- Transformations ------------------------------- + def shift(self, delta: Union[timedelta, int]) -> DateSpan: + """ + Returns a new :class:`DateSpan` that is the result of shifting ``self`` by + ``delta``. + + Examples: + >>> DateSpan('[2000-01-01, 2000-01-10]').shift(timedelta(days=2)) + >>> 'DateSpan([2000-01-03, 2000-01-12])' + + Args: + delta: :class:`datetime.timedelta` instance to shift + + Returns: + A new :class:`DateSpan` instance + + MEOS Functions: + datespan_shift_scale + """ + return self.shift_scale(shift=delta) + + def scale(self, duration: Union[timedelta, int]) -> DateSpan: + """ + Returns a new :class:`DateSpan` that starts as ``self`` but has + duration ``duration``. + + Examples: + >>> DateSpan('[2000-01-01, 2000-01-10]').scale(timedelta(days=2)) + >>> 'DateSpan([2000-01-01, 2000-01-03])' + + Args: + duration: :class:`datetime.timedelta` instance representing the + duration of the new dateSpan + + Returns: + A new :class:`DateSpan` instance + + MEOS Functions: + datespan_shift_scale + """ + return self.shift_scale(duration=duration) + + def shift_scale( + self, + shift: Union[int, timedelta, None] = None, + duration: Union[int, timedelta, None] = None, + ) -> DateSpan: + """ + Returns a new :class:`DateSpan` that starts at ``self`` shifted by ``shift`` and + has duration ``duration`` + + Examples: + >>> DateSpan('[2000-01-01, 2000-01-10]').shift_scale(shift=timedelta(days=2), duration=timedelta(days=4)) + >>> 'DateSpan([2000-01-03, 2000-01-07])' + + Args: + shift: :class:`datetime.timedelta` instance to shift + duration: :class:`datetime.timedelta` instance representing the + duration of the new dateSpan + + Returns: + A new :class:`DateSpan` instance + + MEOS Functions: + datespan_shift_scale + """ + assert ( + shift is not None or duration is not None + ), "shift and scale deltas must not be both None" + + shift = ( + shift.days + if isinstance(shift, timedelta) + else int(shift) + if shift is not None + else 0 + ) + duration = ( + duration.days + if isinstance(duration, timedelta) + else int(duration) + if duration is not None + else 0 + ) + + modified = datespan_shift_scale( + self._inner, shift, duration, shift != 0, duration != 0 + ) + return DateSpan(_inner=modified) + + # ------------------------- Topological Operations ------------------------ + def contains(self, content: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` temporally contains ``content``. + + Examples: + >>> DateSpan('[2012-01-01, 2012-01-04]').contains(DateSpan('[2012-01-02, 2012-01-03]')) + >>> True + >>> DateSpan('[2012-01-01, 2012-01-02]').contains(DateSpan('(2012-01-01, 2012-01-02)')) + >>> True + >>> DateSpan('(2012-01-01, 2012-01-02)').contains(DateSpan('[2012-01-01, 2012-01-02]')) + >>> False + + Args: + content: temporal object to compare with + + Returns: + True if contains, False otherwise + + MEOS Functions: + contains_span_span, contains_span_spanset, contains_span_date + """ + + if isinstance(content, date): + return contains_span_date(self._inner, date_to_date_adt(content)) + else: + return super().contains(content) + + def overlaps(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` temporally overlaps ``other``. That is, both + share at least an instant + + Examples: + >>> DateSpan('[2012-01-01, 2012-01-02]').overlaps(DateSpan('[2012-01-02, 2012-01-03]')) + >>> True + >>> DateSpan('[2012-01-01, 2012-01-02)').overlaps(DateSpan('[2012-01-02, 2012-01-03]')) + >>> False + >>> DateSpan('[2012-01-01, 2012-01-02)').overlaps(DateSpan('(2012-01-02, 2012-01-03]')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if overlaps, False otherwise + + MEOS Functions: + overlaps_span_span, overlaps_span_spanset + """ + + if isinstance(other, date): + return self.contains(other) + else: + return super().overlaps(other) + + # ------------------------- Position Operations --------------------------- + def is_left(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` is strictly before ``other``. That is, + ``self`` ends before ``other`` starts. + + Examples: + >>> DateSpan('[2012-01-01, 2012-01-02)').is_left(DateSpan('[2012-01-02, 2012-01-03]')) + >>> True + >>> DateSpan('[2012-01-01, 2012-01-02)').is_left(DateSpan('(2012-01-02, 2012-01-03]')) + >>> True + >>> DateSpan('[2012-01-01, 2012-01-02]').is_left(DateSpan('[2012-01-02, 2012-01-03]')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if before, False otherwise + + MEOS Functions: + left_span_span, left_span_spanset, before_span_date, + """ + + if isinstance(other, date): + return before_span_date(date_to_date_adt(other), self._inner) + else: + return super().is_left(other) + + def is_over_or_left(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` is before ``other`` allowing overlap. That is, + ``self`` ends before ``other`` ends (or at the same time). + + Examples: + >>> DateSpan('[2012-01-01, 2012-01-02)').is_over_or_left(DateSpan('[2012-01-02, 2012-01-03]')) + >>> True + >>> DateSpan('[2012-01-01, 2012-01-02]').is_over_or_left(DateSpan('[2012-01-02, 2012-01-03]')) + >>> True + >>> DateSpan('[2012-01-03, 2012-01-05]').is_over_or_left(DateSpan('[2012-01-01, 2012-01-04]')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if before, False otherwise + + MEOS Functions: + overleft_span_span, overleft_span_spanset, overbefore_span_date, + """ + + if isinstance(other, date): + return overbefore_span_date(self._inner, date_to_date_adt(other)) + else: + return super().is_over_or_left(other) + + def is_right(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` is strictly after ``other``. That is, ``self`` + starts after ``other`` ends. + + Examples: + >>> DateSpan('[2012-01-02, 2012-01-03]').is_right(DateSpan('[2012-01-01, 2012-01-02)')) + >>> True + >>> DateSpan('(2012-01-02, 2012-01-03]').is_right(DateSpan('[2012-01-01, 2012-01-02)')) + >>> True + >>> DateSpan('[2012-01-02, 2012-01-03]').is_right(DateSpan('[2012-01-01, 2012-01-02]')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if after, False otherwise + + MEOS Functions: + right_span_span, right_span_spanset, after_span_date, + """ + if isinstance(other, date): + return after_span_date(self._inner, date_to_date_adt(other)) + else: + return super().is_right(other) + + def is_over_or_right(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` is after ``other`` allowing overlap. That is, + ``self`` starts after ``other`` starts (or at the same time). + + Examples: + >>> DateSpan('[2012-01-02, 2012-01-03]').is_over_or_right(DateSpan('[2012-01-01, 2012-01-02)')) + >>> True + >>> DateSpan('[2012-01-02, 2012-01-03]').is_over_or_right(DateSpan('[2012-01-01, 2012-01-02]')) + >>> True + >>> DateSpan('[2012-01-02, 2012-01-03]').is_over_or_right(DateSpan('[2012-01-01, 2012-01-03]')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if overlapping or after, False otherwise + + MEOS Functions: + overright_span_span, overright_span_spanset, overafter_span_date, + """ + + if isinstance(other, date): + return overafter_span_date(self._inner, date_to_date_adt(other)) + else: + return super().is_over_or_right(other) + + # ------------------------- Distance Operations --------------------------- + def distance(self, other: Union[TimeDate]) -> timedelta: + """ + Returns the temporal distance between ``self`` and ``other``. + + Args: + other: temporal object to compare with + + Returns: + A :class:`datetime.timedelta` instance + + MEOS Functions: + distance_span_span, distance_spanset_span, distance_span_date + """ + from .dateset import DateSet + + if isinstance(other, date): + return timedelta( + seconds=distance_span_date(self._inner, date_to_date_adt(other)) + ) + elif isinstance(other, DateSet): + return self.distance(other.to_span()) + else: + return timedelta(seconds=super().distance(other)) + + # ------------------------- Set Operations -------------------------------- + @overload + def intersection(self, other: date) -> Optional[date]: + ... + + @overload + def intersection(self, other: DateSpan) -> Optional[DateSpan]: + ... + + @overload + def intersection(self, other: Union[DateSet, DateSpanSet]) -> Optional[DateSpanSet]: + ... + + def intersection(self, other: TimeDate) -> Optional[TimeDate]: + """ + Returns the temporal intersection of ``self`` and ``other``. + + Args: + other: temporal object to intersect with + + Returns: + A :class:`TimeDate` instance. The actual class depends on ``other``. + + MEOS Functions: + intersection_span_span, intersection_spanset_span, + intersection_span_date + """ + from .datespanset import DateSpanSet + from .dateset import DateSet + + if isinstance(other, date): + result = intersection_span_date(self._inner, date_to_date_adt(other)) + return date_adt_to_date(result) if result is not None else None + elif isinstance(other, DateSet): + return self.intersection(other.to_spanset()) + elif isinstance(other, DateSpan): + result = intersection_span_span(self._inner, other._inner) + return DateSpan(_inner=result) if result is not None else None + elif isinstance(other, DateSpanSet): + result = intersection_spanset_span(other._inner, self._inner) + return DateSpanSet(_inner=result) if result is not None else None + else: + super().intersection(other) + + def minus(self, other: TimeDate) -> DateSpanSet: + """ + Returns the temporal difference of ``self`` and ``other``. + + Args: + other: temporal object to diff with + + Returns: + A :class:`DateSpanSet` instance. + + MEOS Functions: + minus_span_date, minus_span_spanset, minus_span_span + """ + from .datespanset import DateSpanSet + from .dateset import DateSet + + if isinstance(other, date): + result = minus_span_date(self._inner, date_to_date_adt(other)) + elif isinstance(other, DateSet): + return self.minus(other.to_spanset()) + elif isinstance(other, DateSpan): + result = minus_span_span(self._inner, other._inner) + elif isinstance(other, DateSpanSet): + result = minus_span_spanset(self._inner, other._inner) + else: + result = super().minus(other) + return DateSpanSet(_inner=result) if result is not None else None + + def union(self, other: TimeDate) -> DateSpanSet: + """ + Returns the temporal union of ``self`` and ``other``. + + Args: + other: temporal object to merge with + + Returns: + A :class:`DateSpanSet` instance. + + MEOS Functions: + union_span_date, union_spanset_span, union_span_span + """ + from .datespanset import DateSpanSet + from .dateset import DateSet + + if isinstance(other, date): + result = union_span_date(self._inner, date_to_date_adt(other)) + elif isinstance(other, DateSet): + result = super().union(other.to_spanset()) + elif isinstance(other, DateSpan): + result = super().union(other) + elif isinstance(other, DateSpanSet): + result = super().union(other) + else: + raise TypeError(f"Operation not supported with type {other.__class__}") + return DateSpanSet(_inner=result) if result is not None else None + + # ------------------------- Plot Operations ------------------------------- + def plot(self, *args, **kwargs): + from ...plotters import TimePlotter + + return TimePlotter.plot_tstzspan(self.to_tstzspan(), *args, **kwargs) diff --git a/pymeos/pymeos/collections/time/tstzspan.py b/pymeos/pymeos/collections/time/tstzspan.py index 2cc962ca..dc1f8fd1 100644 --- a/pymeos/pymeos/collections/time/tstzspan.py +++ b/pymeos/pymeos/collections/time/tstzspan.py @@ -80,18 +80,6 @@ def to_spanset(self) -> TsTzSpanSet: return TsTzSpanSet(_inner=super().to_spanset()) - def to_tstzspanset(self) -> TsTzSpanSet: - """ - Returns a tstzspan set containing ``self``. - - Returns: - A new :class:`TsTzSpanSet` instance - - MEOS Functions: - span_to_spanset - """ - return self.to_spanset() - # ------------------------- Accessors ------------------------------------- def lower(self) -> datetime: """ diff --git a/pymeos_cffi/pymeos_cffi/__init__.py b/pymeos_cffi/pymeos_cffi/__init__.py index e565e7cc..b40451db 100644 --- a/pymeos_cffi/pymeos_cffi/__init__.py +++ b/pymeos_cffi/pymeos_cffi/__init__.py @@ -216,6 +216,8 @@ "dateset_value_n", "dateset_values", "datespan_duration", + "datespan_lower", + "datespan_upper", "datespanset_duration", "datespanset_end_date", "datespanset_num_dates", @@ -452,12 +454,14 @@ "contains_span_span", "contains_span_spanset", "contains_span_timestamptz", + "contains_span_date", "contains_spanset_bigint", "contains_spanset_float", "contains_spanset_int", "contains_spanset_span", "contains_spanset_spanset", "contains_spanset_timestamptz", + "contains_spanset_date", "overlaps_set_set", "overlaps_span_span", "overlaps_spanset_span", @@ -514,14 +518,18 @@ "overafter_set_date", "overafter_set_timestamptz", "overafter_span_timestamptz", + "overafter_span_date", "overafter_spanset_timestamptz", + "overafter_spanset_date", "overafter_timestamptz_set", "overafter_timestamptz_span", "overafter_timestamptz_spanset", "overbefore_set_date", "overbefore_set_timestamptz", "overbefore_span_timestamptz", + "overbefore_span_date", "overbefore_spanset_timestamptz", + "overbefore_spanset_date", "overbefore_timestamptz_set", "overbefore_timestamptz_span", "overbefore_timestamptz_spanset", diff --git a/pymeos_cffi/pymeos_cffi/builder/meos.h b/pymeos_cffi/pymeos_cffi/builder/meos.h index ace5cdf2..27333be2 100644 --- a/pymeos_cffi/pymeos_cffi/builder/meos.h +++ b/pymeos_cffi/pymeos_cffi/builder/meos.h @@ -702,6 +702,8 @@ extern DateADT dateset_start_value(const Set *s); /* extern bool dateset_value_n(const Set *s, int n, DateADT *result); (undefined) */ extern DateADT *dateset_values(const Set *s); extern Interval *datespan_duration(const Span *s); +extern DateADT datespan_lower(const Span *s); +extern DateADT datespan_upper(const Span *s); extern Interval *datespanset_duration(const SpanSet *ss, bool boundspan); extern DateADT datespanset_end_date(const SpanSet *ss); extern int datespanset_num_dates(const SpanSet *ss); @@ -942,12 +944,14 @@ extern bool contains_span_int(const Span *s, int i); extern bool contains_span_span(const Span *s1, const Span *s2); extern bool contains_span_spanset(const Span *s, const SpanSet *ss); extern bool contains_span_timestamptz(const Span *s, TimestampTz t); +extern bool contains_span_date(const Span *s, DateADT d); extern bool contains_spanset_bigint(const SpanSet *ss, int64 i); extern bool contains_spanset_float(const SpanSet *ss, double d); extern bool contains_spanset_int(const SpanSet *ss, int i); extern bool contains_spanset_span(const SpanSet *ss, const Span *s); extern bool contains_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); extern bool contains_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern bool contains_spanset_date(const SpanSet *ss, DateADT d); extern bool overlaps_set_set(const Set *s1, const Set *s2); extern bool overlaps_span_span(const Span *s1, const Span *s2); extern bool overlaps_spanset_span(const SpanSet *ss, const Span *s); @@ -1005,14 +1009,18 @@ extern bool left_text_set(text *txt, const Set *s); extern bool overafter_set_date(const Set *s, DateADT d); extern bool overafter_set_timestamptz(const Set *s, TimestampTz t); extern bool overafter_span_timestamptz(const Span *s, TimestampTz t); +extern bool overafter_span_date(const Span *s, DateADT d); extern bool overafter_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern bool overafter_spanset_date(const SpanSet *ss, DateADT d); extern bool overafter_timestamptz_set(TimestampTz t, const Set *s); extern bool overafter_timestamptz_span(TimestampTz t, const Span *s); extern bool overafter_timestamptz_spanset(TimestampTz t, const SpanSet *ss); extern bool overbefore_set_date(const Set *s, DateADT d); extern bool overbefore_set_timestamptz(const Set *s, TimestampTz t); extern bool overbefore_span_timestamptz(const Span *s, TimestampTz t); +extern bool overbefore_span_date(const Span *s, DateADT d); extern bool overbefore_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern bool overbefore_spanset_date(const SpanSet *ss, DateADT d); extern bool overbefore_timestamptz_set(TimestampTz t, const Set *s); extern bool overbefore_timestamptz_span(TimestampTz t, const Span *s); extern bool overbefore_timestamptz_spanset(TimestampTz t, const SpanSet *ss); diff --git a/pymeos_cffi/pymeos_cffi/functions.py b/pymeos_cffi/pymeos_cffi/functions.py index b85df228..39b4768b 100644 --- a/pymeos_cffi/pymeos_cffi/functions.py +++ b/pymeos_cffi/pymeos_cffi/functions.py @@ -1401,6 +1401,20 @@ def datespan_duration(s: "const Span *") -> "Interval *": return result if result != _ffi.NULL else None +def datespan_lower(s: "const Span *") -> "DateADT": + s_converted = _ffi.cast("const Span *", s) + result = _lib.datespan_lower(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def datespan_upper(s: "const Span *") -> "DateADT": + s_converted = _ffi.cast("const Span *", s) + result = _lib.datespan_upper(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + def datespanset_duration(ss: "const SpanSet *", boundspan: bool) -> "Interval *": ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.datespanset_duration(ss_converted, boundspan) @@ -3273,6 +3287,14 @@ def contains_span_timestamptz(s: "const Span *", t: int) -> "bool": return result if result != _ffi.NULL else None +def contains_span_date(s: "const Span *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.contains_span_date(s_converted, d_converted) + _check_error() + return result if result != _ffi.NULL else None + + def contains_spanset_bigint(ss: "const SpanSet *", i: int) -> "bool": ss_converted = _ffi.cast("const SpanSet *", ss) i_converted = _ffi.cast("int64", i) @@ -3319,6 +3341,14 @@ def contains_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": return result if result != _ffi.NULL else None +def contains_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.contains_spanset_date(ss_converted, d_converted) + _check_error() + return result if result != _ffi.NULL else None + + def overlaps_set_set(s1: "const Set *", s2: "const Set *") -> "bool": s1_converted = _ffi.cast("const Set *", s1) s2_converted = _ffi.cast("const Set *", s2) @@ -3755,6 +3785,14 @@ def overafter_span_timestamptz(s: "const Span *", t: int) -> "bool": return result if result != _ffi.NULL else None +def overafter_span_date(s: "const Span *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.overafter_span_date(s_converted, d_converted) + _check_error() + return result if result != _ffi.NULL else None + + def overafter_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": ss_converted = _ffi.cast("const SpanSet *", ss) t_converted = _ffi.cast("TimestampTz", t) @@ -3763,6 +3801,14 @@ def overafter_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": return result if result != _ffi.NULL else None +def overafter_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.overafter_spanset_date(ss_converted, d_converted) + _check_error() + return result if result != _ffi.NULL else None + + def overafter_timestamptz_set(t: int, s: "const Set *") -> "bool": t_converted = _ffi.cast("TimestampTz", t) s_converted = _ffi.cast("const Set *", s) @@ -3811,6 +3857,14 @@ def overbefore_span_timestamptz(s: "const Span *", t: int) -> "bool": return result if result != _ffi.NULL else None +def overbefore_span_date(s: "const Span *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.overbefore_span_date(s_converted, d_converted) + _check_error() + return result if result != _ffi.NULL else None + + def overbefore_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": ss_converted = _ffi.cast("const SpanSet *", ss) t_converted = _ffi.cast("TimestampTz", t) @@ -3819,6 +3873,14 @@ def overbefore_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": return result if result != _ffi.NULL else None +def overbefore_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.overbefore_spanset_date(ss_converted, d_converted) + _check_error() + return result if result != _ffi.NULL else None + + def overbefore_timestamptz_set(t: int, s: "const Set *") -> "bool": t_converted = _ffi.cast("TimestampTz", t) s_converted = _ffi.cast("const Set *", s) diff --git a/pymeos_examples/PyMEOS_Examples/AIS.ipynb b/pymeos_examples/PyMEOS_Examples/AIS.ipynb index d2b9664b..5c590acc 100644 --- a/pymeos_examples/PyMEOS_Examples/AIS.ipynb +++ b/pymeos_examples/PyMEOS_Examples/AIS.ipynb @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 12, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -49,8 +49,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-23T21:44:07.086546700Z", - "start_time": "2023-10-23T21:44:06.416988800Z" + "end_time": "2023-12-11T22:36:10.601257Z", + "start_time": "2023-12-11T22:36:10.514258Z" } } }, @@ -76,22 +76,22 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 13, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 19.1 s, sys: 901 ms, total: 20 s\n", - "Wall time: 20.1 s\n" + "CPU times: user 16.1 s, sys: 629 ms, total: 16.7 s\n", + "Wall time: 16.9 s\n" ] }, { "data": { - "text/plain": " t mmsi lat lon sog\n0 2023-08-01 219020187 56.795448 8.864770 0.0\n1 2023-08-01 219000873 56.990862 10.304587 0.0\n2 2023-08-01 219008746 56.609180 10.300487 0.0\n4 2023-08-01 219005496 57.754300 10.151212 0.2\n5 2023-08-01 219014072 54.918928 9.597852 0.0", - "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
tmmsilatlonsog
02023-08-0121902018756.7954488.8647700.0
12023-08-0121900087356.99086210.3045870.0
22023-08-0121900874656.60918010.3004870.0
42023-08-0121900549657.75430010.1512120.2
52023-08-0121901407254.9189289.5978520.0
\n
" + "text/plain": " t mmsi lat lon sog\n0 2023-10-19 219029699 57.137907 9.127860 0.0\n1 2023-10-19 219005827 56.803713 9.020183 0.0\n2 2023-10-19 219006283 56.764315 8.863167 0.0\n3 2023-10-19 220466000 56.970548 9.257460 0.1\n4 2023-10-19 210731000 54.220680 11.386588 7.5", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
tmmsilatlonsog
02023-10-1921902969957.1379079.1278600.0
12023-10-1921900582756.8037139.0201830.0
22023-10-1921900628356.7643158.8631670.0
32023-10-1922046600056.9705489.2574600.1
42023-10-1921073100054.22068011.3865887.5
\n
" }, - "execution_count": 8, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -99,7 +99,7 @@ "source": [ "%%time\n", "ais = pd.read_csv(\n", - " \"./data/aisdk-2023-08-01.zip\",\n", + " \"./data/aisdk-2023-10-19.zip\",\n", " usecols=[\"# Timestamp\", \"MMSI\", \"Latitude\", \"Longitude\", \"SOG\"],\n", ")\n", "ais.columns = [\"t\", \"mmsi\", \"lat\", \"lon\", \"sog\"]\n", @@ -116,8 +116,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-12-11T22:33:35.446745500Z", - "start_time": "2023-12-11T22:33:15.218746200Z" + "end_time": "2023-12-11T22:36:27.399785700Z", + "start_time": "2023-12-11T22:36:10.523258200Z" } } }, @@ -132,15 +132,15 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 14, "outputs": [ { "data": { - "text/plain": " 0%| | 0/11046773 [00:00\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
tmmsisoginstant
001/08/2023 00:00:002190201870@2023-01-08 00:00:00+01POINT(8.86477 56.795448)@2023-01-08 00:00:00+01
101/08/2023 00:00:002190008730@2023-01-08 00:00:00+01POINT(10.304587 56.990862)@2023-01-08 00:00:00+01
201/08/2023 00:00:002190087460@2023-01-08 00:00:00+01POINT(10.300487 56.60918)@2023-01-08 00:00:00+01
401/08/2023 00:00:002190054960.2@2023-01-08 00:00:00+01POINT(10.151212 57.7543)@2023-01-08 00:00:00+01
501/08/2023 00:00:002190140720@2023-01-08 00:00:00+01POINT(9.597852 54.918928)@2023-01-08 00:00:00+01
\n" + "text/plain": " t mmsi sog \\\n0 2023-10-19 219029699 0@2023-10-19 00:00:00+02 \n1 2023-10-19 219005827 0@2023-10-19 00:00:00+02 \n2 2023-10-19 219006283 0@2023-10-19 00:00:00+02 \n3 2023-10-19 220466000 0.1@2023-10-19 00:00:00+02 \n4 2023-10-19 210731000 7.5@2023-10-19 00:00:00+02 \n\n instant \n0 POINT(9.12786 57.137907)@2023-10-19 00:00:00+02 \n1 POINT(9.020183 56.803713)@2023-10-19 00:00:00+02 \n2 POINT(8.863167 56.764315)@2023-10-19 00:00:00+02 \n3 POINT(9.25746 56.970548)@2023-10-19 00:00:00+02 \n4 POINT(11.386588 54.22068)@2023-10-19 00:00:00+02 ", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
tmmsisoginstant
02023-10-192190296990@2023-10-19 00:00:00+02POINT(9.12786 57.137907)@2023-10-19 00:00:00+02
12023-10-192190058270@2023-10-19 00:00:00+02POINT(9.020183 56.803713)@2023-10-19 00:00:00+02
22023-10-192190062830@2023-10-19 00:00:00+02POINT(8.863167 56.764315)@2023-10-19 00:00:00+02
32023-10-192204660000.1@2023-10-19 00:00:00+02POINT(9.25746 56.970548)@2023-10-19 00:00:00+02
42023-10-192107310007.5@2023-10-19 00:00:00+02POINT(11.386588 54.22068)@2023-10-19 00:00:00+02
\n
" }, - "execution_count": 20, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -197,8 +197,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-23T22:04:24.299519400Z", - "start_time": "2023-10-23T22:04:23.779518200Z" + "end_time": "2023-12-11T22:42:18.378503800Z", + "start_time": "2023-12-11T22:42:17.996081200Z" } } }, @@ -215,22 +215,22 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 16, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 43.9 s, sys: 712 ms, total: 44.6 s\n", - "Wall time: 44.6 s\n" + "CPU times: user 32.1 s, sys: 188 ms, total: 32.3 s\n", + "Wall time: 32.3 s\n" ] }, { "data": { - "text/plain": " trajectory \\\nmmsi \n148 [POINT(12.606613 55.684455)@2023-01-08 00:01:3... \n5322 [POINT(12.606042 55.684293)@2023-01-08 00:00:0... \n100046 [POINT(4.164757 58.76664)@2023-01-08 19:20:52+... \n2190045 [POINT(8.423332 55.47179)@2023-01-08 00:00:07+... \n9132759 [POINT(8.310862 56.552482)@2023-01-08 17:32:00... \n\n sog distance \nmmsi \n148 [0.8@2023-01-08 00:01:34+01, 0@2023-01-08 00:0... 31191.067480 \n5322 [0.1@2023-01-08 00:00:00+01, 0.2@2023-01-08 00... 39797.594133 \n100046 [148@2023-01-08 19:20:52+01, 148@2023-01-08 19... 46476.358005 \n2190045 [0@2023-01-08 00:00:07+01, 0@2023-01-08 02:51:... 2436.943448 \n9132759 [0@2023-01-08 17:32:00+01, 0@2023-01-08 17:44:... 368.171260 ", - "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
trajectorysogdistance
mmsi
148[POINT(12.606613 55.684455)@2023-01-08 00:01:3...[0.8@2023-01-08 00:01:34+01, 0@2023-01-08 00:0...31191.067480
5322[POINT(12.606042 55.684293)@2023-01-08 00:00:0...[0.1@2023-01-08 00:00:00+01, 0.2@2023-01-08 00...39797.594133
100046[POINT(4.164757 58.76664)@2023-01-08 19:20:52+...[148@2023-01-08 19:20:52+01, 148@2023-01-08 19...46476.358005
2190045[POINT(8.423332 55.47179)@2023-01-08 00:00:07+...[0@2023-01-08 00:00:07+01, 0@2023-01-08 02:51:...2436.943448
9132759[POINT(8.310862 56.552482)@2023-01-08 17:32:00...[0@2023-01-08 17:32:00+01, 0@2023-01-08 17:44:...368.171260
\n
" + "text/plain": " trajectory \\\nmmsi \n2190045 [POINT(8.44805 55.464272)@2023-10-19 00:00:10+... \n9109416 [POINT(9.785182 54.909655)@2023-10-19 05:21:13... \n111219504 [POINT(9.838743 57.103408)@2023-10-19 07:32:04... \n111219508 [POINT(12.121327 55.591252)@2023-10-19 11:52:4... \n111219512 [POINT(9.286713 55.220503)@2023-10-19 09:44:07... \n\n sog distance \nmmsi \n2190045 [0@2023-10-19 00:00:10+02, 0.1@2023-10-19 00:0... 4196.237335 \n9109416 [1.4@2023-10-19 05:21:13+02, 0.2@2023-10-19 05... 48.376014 \n111219504 [0@2023-10-19 07:32:04+02, 0@2023-10-19 07:34:... 249300.505518 \n111219508 [1.7@2023-10-19 11:52:43+02, 7.5@2023-10-19 11... 463414.183253 \n111219512 [16.9@2023-10-19 09:44:07+02, 54.2@2023-10-19 ... 122854.298352 ", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
trajectorysogdistance
mmsi
2190045[POINT(8.44805 55.464272)@2023-10-19 00:00:10+...[0@2023-10-19 00:00:10+02, 0.1@2023-10-19 00:0...4196.237335
9109416[POINT(9.785182 54.909655)@2023-10-19 05:21:13...[1.4@2023-10-19 05:21:13+02, 0.2@2023-10-19 05...48.376014
111219504[POINT(9.838743 57.103408)@2023-10-19 07:32:04...[0@2023-10-19 07:32:04+02, 0@2023-10-19 07:34:...249300.505518
111219508[POINT(12.121327 55.591252)@2023-10-19 11:52:4...[1.7@2023-10-19 11:52:43+02, 7.5@2023-10-19 11...463414.183253
111219512[POINT(9.286713 55.220503)@2023-10-19 09:44:07...[16.9@2023-10-19 09:44:07+02, 54.2@2023-10-19 ...122854.298352
\n
" }, - "execution_count": 21, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -253,8 +253,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-23T22:05:08.933258100Z", - "start_time": "2023-10-23T22:04:24.286520400Z" + "end_time": "2023-12-11T22:42:50.706548900Z", + "start_time": "2023-12-11T22:42:18.371504800Z" } } }, @@ -269,14 +269,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 17, "outputs": [ { "data": { - "text/plain": " original #points PyMEOS #points Points kept (%)\nmmsi \n148 3882 3625 93.379701\n5322 8224 8008 97.373541\n100046 3 3 100.000000\n2190045 8824 4732 53.626473\n9132759 159 103 64.779874\n... ... ... ...\n970010921 638 378 59.247649\n970021666 2 2 100.000000\n970021790 3 2 66.666667\n970100094 8 3 37.500000\n972609012 6 3 50.000000\n\n[6064 rows x 3 columns]", - "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
original #pointsPyMEOS #pointsPoints kept (%)
mmsi
1483882362593.379701
53228224800897.373541
10004633100.000000
21900458824473253.626473
913275915910364.779874
............
97001092163837859.247649
97002166622100.000000
9700217903266.666667
9701000948337.500000
9726090126350.000000
\n

6064 rows × 3 columns

\n
" + "text/plain": " original #points PyMEOS #points Points kept (%)\nmmsi \n2190045 8849 7180 81.139112\n9109416 63 58 92.063492\n111219504 3162 3058 96.710942\n111219508 5830 5760 98.799314\n111219512 799 773 96.745932\n... ... ... ...\n677064088 696 636 91.379310\n826500702 370 286 77.297297\n887222300 867 548 63.206459\n912190064 85 83 97.647059\n912191373 750 2 0.266667\n\n[2884 rows x 3 columns]", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
original #pointsPyMEOS #pointsPoints kept (%)
mmsi
21900458849718081.139112
9109416635892.063492
1112195043162305896.710942
1112195085830576098.799314
11121951279977396.745932
............
67706408869663691.379310
82650070237028677.297297
88722230086754863.206459
912190064858397.647059
91219137375020.266667
\n

2884 rows × 3 columns

\n
" }, - "execution_count": 6, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -299,8 +299,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-23T21:50:18.873208200Z", - "start_time": "2023-10-23T21:50:18.467714900Z" + "end_time": "2023-12-11T22:42:50.865103300Z", + "start_time": "2023-12-11T22:42:50.698549500Z" } } }, @@ -315,12 +315,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 18, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -337,8 +337,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-23T21:50:28.083572Z", - "start_time": "2023-10-23T21:50:18.872207400Z" + "end_time": "2023-12-11T22:43:00.690388300Z", + "start_time": "2023-12-11T22:42:50.818102100Z" } } }, @@ -365,8 +365,22 @@ }, { "cell_type": "code", - "execution_count": 23, - "outputs": [], + "execution_count": 19, + "outputs": [ + { + "ename": "OperationalError", + "evalue": "connection failed: Connection refused\n\tIs the server running on that host and accepting TCP/IP connections?", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mOperationalError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[19], line 9\u001B[0m\n\u001B[1;32m 6\u001B[0m user \u001B[38;5;241m=\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mdocker\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 7\u001B[0m password \u001B[38;5;241m=\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mdocker\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m----> 9\u001B[0m connection \u001B[38;5;241m=\u001B[39m \u001B[43mMobilityDB\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mconnect\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 10\u001B[0m \u001B[43m \u001B[49m\u001B[43mhost\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mhost\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mport\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mport\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mdbname\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdb\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43muser\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43muser\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mpassword\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mpassword\u001B[49m\n\u001B[1;32m 11\u001B[0m \u001B[43m)\u001B[49m\n\u001B[1;32m 12\u001B[0m cursor \u001B[38;5;241m=\u001B[39m connection\u001B[38;5;241m.\u001B[39mcursor()\n", + "File \u001B[0;32m~/.virtualenvs/pymeos_examples/lib/python3.10/site-packages/pymeos/db/psycopg.py:46\u001B[0m, in \u001B[0;36mMobilityDB.connect\u001B[0;34m(cls, *args, **kwargs)\u001B[0m\n\u001B[1;32m 29\u001B[0m \u001B[38;5;129m@classmethod\u001B[39m\n\u001B[1;32m 30\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mconnect\u001B[39m(\u001B[38;5;28mcls\u001B[39m, \u001B[38;5;241m*\u001B[39margs, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs):\n\u001B[1;32m 31\u001B[0m \u001B[38;5;250m \u001B[39m\u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 32\u001B[0m \u001B[38;5;124;03m Establishes a connection to a MobilityDB server.\u001B[39;00m\n\u001B[1;32m 33\u001B[0m \n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 44\u001B[0m \n\u001B[1;32m 45\u001B[0m \u001B[38;5;124;03m \"\"\"\u001B[39;00m\n\u001B[0;32m---> 46\u001B[0m connection \u001B[38;5;241m=\u001B[39m \u001B[43mconnect\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 47\u001B[0m \u001B[38;5;28mcls\u001B[39m\u001B[38;5;241m.\u001B[39mregister(connection)\n\u001B[1;32m 48\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m connection\n", + "File \u001B[0;32m~/.virtualenvs/pymeos_examples/lib/python3.10/site-packages/psycopg/connection.py:729\u001B[0m, in \u001B[0;36mConnection.connect\u001B[0;34m(cls, conninfo, autocommit, prepare_threshold, row_factory, cursor_factory, context, **kwargs)\u001B[0m\n\u001B[1;32m 724\u001B[0m rv \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mcls\u001B[39m\u001B[38;5;241m.\u001B[39m_wait_conn(\n\u001B[1;32m 725\u001B[0m \u001B[38;5;28mcls\u001B[39m\u001B[38;5;241m.\u001B[39m_connect_gen(conninfo, autocommit\u001B[38;5;241m=\u001B[39mautocommit),\n\u001B[1;32m 726\u001B[0m timeout\u001B[38;5;241m=\u001B[39mparams[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mconnect_timeout\u001B[39m\u001B[38;5;124m\"\u001B[39m],\n\u001B[1;32m 727\u001B[0m )\n\u001B[1;32m 728\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m e\u001B[38;5;241m.\u001B[39m_NO_TRACEBACK \u001B[38;5;28;01mas\u001B[39;00m ex:\n\u001B[0;32m--> 729\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m ex\u001B[38;5;241m.\u001B[39mwith_traceback(\u001B[38;5;28;01mNone\u001B[39;00m)\n\u001B[1;32m 731\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m row_factory:\n\u001B[1;32m 732\u001B[0m rv\u001B[38;5;241m.\u001B[39mrow_factory \u001B[38;5;241m=\u001B[39m row_factory\n", + "\u001B[0;31mOperationalError\u001B[0m: connection failed: Connection refused\n\tIs the server running on that host and accepting TCP/IP connections?" + ] + } + ], "source": [ "from pymeos.db.psycopg import MobilityDB\n", "\n", @@ -384,8 +398,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-23T22:07:20.209410900Z", - "start_time": "2023-10-23T22:07:20.172442100Z" + "end_time": "2023-12-11T22:43:00.810387100Z", + "start_time": "2023-12-11T22:43:00.689387900Z" } } }, @@ -400,7 +414,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "outputs": [], "source": [ "cursor.execute(\"DROP TABLE IF EXISTS public.PyMEOS_demo;\")\n", @@ -413,8 +427,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-23T22:07:21.599202700Z", - "start_time": "2023-10-23T22:07:21.552202800Z" + "end_time": "2023-12-11T22:43:00.827387900Z", + "start_time": "2023-12-11T22:43:00.814386700Z" } } }, @@ -429,7 +443,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "outputs": [], "source": [ "query = \"INSERT INTO public.PyMEOS_demo(MMSI, trajectory, SOG) VALUES\"\n", @@ -440,24 +454,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-23T22:07:45.042786100Z", - "start_time": "2023-10-23T22:07:33.525339200Z" + "start_time": "2023-12-11T22:43:00.816386300Z" } } }, { "cell_type": "code", - "execution_count": 26, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 4.55 s, sys: 917 ms, total: 5.46 s\n", - "Wall time: 1min 2s\n" - ] - } - ], + "execution_count": null, + "outputs": [], "source": [ "%%time\n", "cursor.execute(query)\n", @@ -466,8 +470,7 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-23T22:08:48.624809Z", - "start_time": "2023-10-23T22:07:46.489132100Z" + "start_time": "2023-12-11T22:43:00.818386900Z" } } }, @@ -482,17 +485,8 @@ }, { "cell_type": "code", - "execution_count": 14, - "outputs": [ - { - "data": { - "text/plain": "6064" - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "outputs": [], "source": [ "cursor.execute(\"SELECT COUNT(*) FROM public.PyMEOS_demo;\")\n", "cursor.fetchone()[0]" @@ -500,8 +494,7 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-23T21:53:11.130172200Z", - "start_time": "2023-10-23T21:53:11.083649100Z" + "start_time": "2023-12-11T22:43:00.822386300Z" } } }, @@ -516,7 +509,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "outputs": [], "source": [ "cursor.execute(\"SELECT * FROM public.PyMEOS_demo WHERE MMSI = 97000050;\")\n", @@ -525,24 +518,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-23T21:53:44.308699100Z", - "start_time": "2023-10-23T21:53:44.288701100Z" + "start_time": "2023-12-11T22:43:00.823388100Z" } } }, { "cell_type": "code", - "execution_count": 16, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "outputs": [], "source": [ "fig, axes = plt.subplots(1, 2, figsize=(20, 10))\n", "trajectory.plot(axes=axes[0])\n", @@ -553,8 +536,7 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-23T21:53:45.524484600Z", - "start_time": "2023-10-23T21:53:45.237188200Z" + "start_time": "2023-12-11T22:43:00.824386700Z" } } }, @@ -569,7 +551,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "outputs": [], "source": [ "connection.commit()\n", @@ -579,8 +561,7 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-23T21:53:49.554089800Z", - "start_time": "2023-10-23T21:53:49.534092600Z" + "start_time": "2023-12-11T22:43:00.824386700Z" } } } From bd4e93b1abb05569467e91ac3c5f7f091a4978be Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 31 Dec 2023 16:43:03 +0100 Subject: [PATCH 06/37] Add DateSpanSet --- pymeos/pymeos/collections/base/spanset.py | 1 + pymeos/pymeos/collections/time/datespanset.py | 602 +++++++++++++++++- pymeos/pymeos/collections/time/tstzspanset.py | 61 +- 3 files changed, 594 insertions(+), 70 deletions(-) diff --git a/pymeos/pymeos/collections/base/spanset.py b/pymeos/pymeos/collections/base/spanset.py index 43b56fce..81da72f6 100644 --- a/pymeos/pymeos/collections/base/spanset.py +++ b/pymeos/pymeos/collections/base/spanset.py @@ -450,6 +450,7 @@ def distance(self, other) -> float: A :class:`float` instance MEOS Functions: + distance_spanset_span, distance_spanset_spanset """ from .span import Span diff --git a/pymeos/pymeos/collections/time/datespanset.py b/pymeos/pymeos/collections/time/datespanset.py index 7c1a2647..bbdcb6bb 100644 --- a/pymeos/pymeos/collections/time/datespanset.py +++ b/pymeos/pymeos/collections/time/datespanset.py @@ -1,25 +1,603 @@ from __future__ import annotations -from datetime import date -from typing import TYPE_CHECKING, List +from datetime import timedelta, date +from typing import Optional, Union, List, overload +from typing import TYPE_CHECKING -from dateutil.parser import parse from pymeos_cffi import ( - dateset_in, - pg_date_in, + datespanset_in, + datespan_in, + datespanset_out, + datespanset_to_tstzspanset, + interval_to_timedelta, + datespanset_duration, + datespanset_num_dates, + date_adt_to_date, + datespanset_start_date, + datespanset_end_date, + datespanset_date_n, + datespanset_dates, + datespanset_shift_scale, date_to_date_adt, - dateset_make, - dateset_out, + contains_spanset_date, + before_spanset_date, + overbefore_spanset_date, + overafter_spanset_date, + after_spanset_date, + distance_spanset_date, + intersection_spanset_date, + minus_spanset_date, + union_spanset_date, ) from .timecollection import TimeCollection -from ..base import Set -from ..base.set import T -from ... import Span, SpanSet +from ..base.spanset import SpanSet if TYPE_CHECKING: - pass + from .tstzspan import TsTzSpan + from .tstzspanset import TsTzSpanSet + from .datespan import DateSpan + from .time import TimeDate class DateSpanSet(SpanSet[date], TimeCollection[date]): - pass + """ + Class for representing lists of disjoint tstzspans. + + :class:``DateSpanSet`` objects can be created with a single argument of type string + as in MobilityDB. + + >>> DateSpanSet(string='{[2019-09-08, 2019-09-10], [2019-09-11, 2019-09-12]}') + + Another possibility is to give a list specifying the composing + tstzspans, which can be instances of :class:``str`` or :class:``DateSpan``. + The composing datespans must be given in increasing order. + + >>> DateSpanSet(span_list=['[2019-09-08, 2019-09-10]', '[2019-09-11, 2019-09-12']) + >>> DateSpanSet(span_list=[TsTzSpan('[2019-09-08, 2019-09-10]'), TsTzSpan('[2019-09-11, 2019-09-12]')]) + + """ + + __slots__ = ["_inner"] + + _mobilitydb_name = "dateSpanSet" + + _parse_function = datespanset_in + _parse_value_function = ( + lambda tstzspan: datespan_in(tstzspan)[0] + if isinstance(tstzspan, str) + else tstzspan._inner[0] + ) + + # ------------------------- Output ---------------------------------------- + def __str__(self): + """ + Return the string representation of the content of ``self``. + + Returns: + A new :class:`str` instance + + MEOS Functions: + datespanset_out + """ + return datespanset_out(self._inner) + + # ------------------------- Conversions ----------------------------------- + + def to_span(self) -> DateSpan: + """ + Returns a :class:`DateSpan` that encompasses ``self``. + + Returns: + A new :class:`DateSpan` instance + + MEOS Functions: + spanset_span + """ + from .dateset import DateSpan + + return DateSpan(_inner=super().to_span()) + + def to_tstzspanset(self) -> TsTzSpanSet: + """ + Returns a :class:`TsTzSpanSet` equivalent to ``self``. + + Returns: + A new :class:`TsTzSpanSet` instance + + MEOS Functions: + datespanset_to_tstzspanset + """ + from .tstzspanset import TsTzSpanSet + + return TsTzSpanSet(_inner=datespanset_to_tstzspanset(self._inner)) + + # ------------------------- Accessors ------------------------------------- + def duration(self, ignore_gaps: Optional[bool] = False) -> timedelta: + """ + Returns the duration of ``self``. By default, i.e., when ``ignore_gaps`` is + ``False``, the function takes into account the gaps between the + spans, i.e., returns the sum of the durations of the composing datespans. + Otherwise, the function returns the duration of ``self`` ignoring + any gap, i.e., the duration from the lower bound of the first datespan to + the upper bound of the last datespan. + + Parameters: + ignore_gaps: Whether to take into account potential time gaps in + ``self``. + + Returns: + A :class:`datetime.timedelta` instance representing the duration of + the datespanset + + MEOS Functions: + datespanset_duration + """ + return interval_to_timedelta(datespanset_duration(self._inner, ignore_gaps)) + + def num_dates(self) -> int: + """ + Returns the number of dates in ``self``. + Returns: + An :class:`int` + + MEOS Functions: + datespanset_num_dates + """ + return datespanset_num_dates(self._inner) + + def start_date(self) -> date: + """ + Returns the first date in ``self``. + Returns: + A :class:`date` instance + + MEOS Functions: + datespanset_start_date + """ + return date_adt_to_date(datespanset_start_date(self._inner)) + + def end_date(self) -> date: + """ + Returns the last date in ``self``. + Returns: + A :class:`date` instance + + MEOS Functions: + datespanset_end_date + """ + return date_adt_to_date(datespanset_end_date(self._inner)) + + def date_n(self, n: int) -> date: + """ + Returns the n-th date in ``self``. + Returns: + A :class:`date` instance + + MEOS Functions: + datespanset_date_n + """ + if n < 0 or n >= self.num_dates(): + raise IndexError(f"Index {n} out of bounds") + return date_adt_to_date(datespanset_date_n(self._inner, n + 1)) + + def dates(self) -> List[date]: + """ + Returns the list of distinct dates in ``self``. + Returns: + A :class:`list[date]` instance + + MEOS Functions: + datespanset_dates + """ + ds, count = datespanset_dates(self._inner) + return [date_adt_to_date(ds[i]) for i in range(count)] + + def start_span(self) -> DateSpan: + """ + Returns the first :class:`DateSpan` in ``self``. + Returns: + A :class:`DateSpan` instance + + MEOS Functions: + spanset_start_span + """ + from .datespan import DateSpan + + return DateSpan(_inner=super().start_span()) + + def end_span(self) -> DateSpan: + """ + Returns the last :class:`DateSpan` in ``self``. + Returns: + A :class:`DateSpan` instance + + MEOS Functions: + spanset_end_span + """ + from .datespan import DateSpan + + return DateSpan(_inner=super().end_span()) + + def span_n(self, n: int) -> DateSpan: + """ + Returns the n-th :class:`DateSpan` in ``self``. + Returns: + A :class:`DateSpan` instance + + MEOS Functions: + spanset_span_n + """ + from .datespan import DateSpan + + return DateSpan(_inner=super().span_n(n)) + + def spans(self) -> List[DateSpan]: + """ + Returns the list of :class:`DateSpan` in ``self``. + Returns: + A :class:`list[DateSpan]` instance + + MEOS Functions: + spanset_spans + """ + from .datespan import DateSpan + + ps = super().spans() + return [DateSpan(_inner=ps[i]) for i in range(self.num_spans())] + + # ------------------------- Transformations ------------------------------- + def shift(self, delta: Union[timedelta, int]) -> DateSpanSet: + """ + Returns a new :class:`DateSpanSet` that is the result of shifting ``self`` by + ``delta`` + + Examples: + >>> DateSpanSet('{[2000-01-01, 2000-01-10]}').shift(timedelta(days=2)) + >>> 'DateSpanSet({[2000-01-03 00:00:00+01, 2000-01-12 00:00:00+01]})' + + Args: + delta: :class:`datetime.timedelta` instance to shift + + Returns: + A new :class:`DateSpanSet` instance + + MEOS Functions: + datespanset_shift_scale + """ + return self.shift_scale(shift=delta) + + def scale(self, duration: Union[timedelta, int]) -> DateSpanSet: + """ + Returns a new :class:`DateSpanSet` that starts as ``self`` but has duration + ``duration`` + + Examples: + >>> DateSpanSet('{[2000-01-01, 2000-01-10]}').scale(timedelta(days=2)) + >>> 'DateSpanSet({[2000-01-01 00:00:00+01, 2000-01-03 00:00:00+01]})' + + Args: + duration: :class:`datetime.timedelta` instance representing the + duration of the new tstzspan + + Returns: + A new :class:`DateSpanSet` instance + + MEOS Functions: + datespanset_shift_scale + """ + return self.shift_scale(duration=duration) + + def shift_scale( + self, + shift: Union[timedelta, int, None] = None, + duration: Union[timedelta, int, None] = None, + ) -> DateSpanSet: + """ + Returns a new :class:`DateSpanSet` that starts at ``self`` shifted by ``shift`` + and has duration ``duration`` + + Examples: + >>> DateSpanSet('{[2000-01-01, 2000-01-10]}').shift_scale(shift=timedelta(days=2), duration=timedelta(days=4)) + >>> 'DateSpanSet({[2000-01-03 00:00:00+01, 2000-01-07 00:00:00+01]})' + + Args: + shift: :class:`datetime.timedelta` instance to shift + duration: :class:`datetime.timedelta` instance representing the + duration of the new tstzspan + + Returns: + A new :class:`DateSpanSet` instance + + MEOS Functions: + datespanset_shift_scale + """ + assert ( + shift is not None or duration is not None + ), "shift and scale deltas must not be both None" + + shift = ( + shift.days + if isinstance(shift, timedelta) + else int(shift) + if shift is not None + else 0 + ) + duration = ( + duration.days + if isinstance(duration, timedelta) + else int(duration) + if duration is not None + else 0 + ) + + modified = datespanset_shift_scale( + self._inner, shift, duration, shift != 0, duration != 0 + ) + return DateSpanSet(_inner=modified) + + # ------------------------- Topological Operations ------------------------ + + def contains(self, content: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` temporally contains ``content``. + + Examples: + >>> DateSpanSet('{[2012-01-01, 2012-01-04]}').contains(DateSpanSet('{[2012-01-02, 2012-01-03]}')) + >>> True + >>> DateSpanSet('{[2012-01-01, 2012-01-02]}').contains(DateSpanSet('{(2012-01-01, 2012-01-02)}')) + >>> True + >>> DateSpanSet('{(2012-01-01, 2012-01-02)}').contains(DateSpanSet('{[2012-01-01, 2012-01-02]}')) + >>> False + + Args: + content: temporal object to compare with + + Returns: + True if contains, False otherwise + + MEOS Functions: + contains_spanset_span, contains_spanset_spanset, + contains_spanset_date + """ + + if isinstance(content, date): + return contains_spanset_date(self._inner, date_to_date_adt(content)) + else: + return super().contains(content) + + def overlaps(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` temporally overlaps ``other``. That is, both + share at least an instant + + Examples: + >>> DateSpanSet('{[2012-01-01, 2012-01-02]}').overlaps(DateSpanSet('{[2012-01-02, 2012-01-03]}')) + >>> True + >>> DateSpanSet('{[2012-01-01, 2012-01-02)}').overlaps(DateSpanSet('{[2012-01-02, 2012-01-03]}')) + >>> False + >>> DateSpanSet('{[2012-01-01, 2012-01-02)}').overlaps(DateSpanSet('{(2012-01-02, 2012-01-03]}')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if overlaps, False otherwise + + MEOS Functions: + overlaps_spanset_span, overlaps_spanset_spanset + """ + if isinstance(other, date): + return self.contains(other) + else: + return super().overlaps(other) + + # ------------------------- Position Operations --------------------------- + def is_left(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` is strictly before ``other``. That is, + ``self`` ends before ``other`` starts. + + Examples: + >>> DateSpanSet('{[2012-01-01, 2012-01-02)}').is_left(DateSpanSet('{[2012-01-02, 2012-01-03]}')) + >>> True + >>> DateSpanSet('{[2012-01-01, 2012-01-02)}').is_left(DateSpanSet('{(2012-01-02, 2012-01-03]}')) + >>> True + >>> DateSpanSet('{[2012-01-01, 2012-01-02]}').is_left(DateSpanSet('{[2012-01-02, 2012-01-03]}')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if before, False otherwise + + MEOS Functions: + before_spanset_date, left_spanset_span, left_spanset_spanset + """ + if isinstance(other, date): + return before_spanset_date(self._inner, date_to_date_adt(other)) + else: + return super().is_left(other) + + def is_over_or_left(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` is before ``other`` allowing overlap. That is, + ``self`` ends before ``other`` ends (or at the same time). + + Examples: + >>> DateSpanSet('{[2012-01-01, 2012-01-02)}').is_over_or_left(DateSpanSet('{[2012-01-02, 2012-01-03]}')) + >>> True + >>> DateSpanSet('{[2012-01-01, 2012-01-02]}').is_over_or_left(DateSpanSet('{[2012-01-02, 2012-01-03]}')) + >>> True + >>> DateSpanSet('{[2012-01-03, 2012-01-05]}').is_over_or_left(DateSpanSet('{[2012-01-01, 2012-01-04]}')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if before, False otherwise + + MEOS Functions: + overleft_spanset_span, overleft_spanset_spanset, + overbefore_spanset_date + """ + if isinstance(other, date): + return overbefore_spanset_date(self._inner, date_to_date_adt(other)) + else: + return super().is_over_or_left(other) + + def is_over_or_right(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` is after ``other`` allowing overlap. That is, + ``self`` starts after ``other`` starts (or at the same time). + + Examples: + >>> DateSpanSet('{[2012-01-02, 2012-01-03]}').is_over_or_right(DateSpanSet('{[2012-01-01, 2012-01-02)}')) + >>> True + >>> DateSpanSet('{[2012-01-02, 2012-01-03]}').is_over_or_right(DateSpanSet('{[2012-01-01, 2012-01-02]}')) + >>> True + >>> DateSpanSet('{[2012-01-02, 2012-01-03]}').is_over_or_right(DateSpanSet('{[2012-01-01, 2012-01-03]}')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if overlapping or after, False otherwise + + MEOS Functions: + overright_spanset_span, overright_spanset_spanset, + overafter_spanset_date + """ + if isinstance(other, date): + return overafter_spanset_date(self._inner, date_to_date_adt(other)) + else: + return super().is_over_or_right(other) + + def is_right(self, other: Union[TimeDate]) -> bool: + """ + Returns whether ``self`` is strictly after ``other``.That is, ``self`` + starts after ``other`` ends. + + Examples: + >>> DateSpanSet('{[2012-01-02, 2012-01-03]}').is_right(DateSpanSet('{[2012-01-01, 2012-01-02)}')) + >>> True + >>> DateSpanSet('{(2012-01-02, 2012-01-03]}').is_right(DateSpanSet('{[2012-01-01, 2012-01-02)}')) + >>> True + >>> DateSpanSet('{[2012-01-02, 2012-01-03]}').is_right(DateSpanSet('{[2012-01-01, 2012-01-02]}')) + >>> False + + Args: + other: temporal object to compare with + + Returns: + True if after, False otherwise + + MEOS Functions: + right_spanset_span, right_spanset_spanset, + overbefore_timestamp_tstzspanset + """ + if isinstance(other, date): + return after_spanset_date(self._inner, date_to_date_adt(other)) + else: + return super().is_right(other) + + # ------------------------- Distance Operations --------------------------- + def distance(self, other: Union[TimeDate]) -> timedelta: + """ + Returns the temporal distance between ``self`` and ``other``. + + Args: + other: temporal object to compare with + + Returns: + A :class:`datetime.timedelta` instance + + MEOS Functions: + distance_spanset_span, distance_spanset_spanset, distance_spanset_date + """ + + if isinstance(other, date): + return timedelta( + seconds=distance_spanset_date(self._inner, date_to_date_adt(other)) + ) + else: + return timedelta(seconds=super().distance(other)) + + # ------------------------- Set Operations -------------------------------- + + @overload + def intersection(self, other: date) -> date: + ... + + @overload + def intersection(self, other: Union[DateSpan, DateSpanSet]) -> DateSpanSet: + ... + + def intersection(self, other: TimeDate) -> Union[date, DateSpanSet]: + """ + Returns the temporal intersection of ``self`` and ``other``. + + Args: + other: temporal object to intersect with + + Returns: + A :class:`TimeDate` instance. The actual class depends on ``other``. + + MEOS Functions: + intersection_spanset_timestamptz, intersection_spanset_spanset, + intersection_spanset_span + """ + if isinstance(other, date): + result = intersection_spanset_date(self._inner, date_to_date_adt(other)) + return date_adt_to_date(result) if result is not None else None + else: + result = super().intersection(other) + return DateSpanSet(_inner=result) if result is not None else None + + def minus(self, other: TimeDate) -> DateSpanSet: + """ + Returns the temporal difference of ``self`` and ``other``. + + Args: + other: temporal object to diff with + + Returns: + A :class:`DateSpanSet` instance. + + MEOS Functions: + minus_spanset_span, minus_spanset_spanset, minus_spanset_timestamptz + """ + if isinstance(other, date): + result = minus_spanset_date(self._inner, date_to_date_adt(other)) + else: + result = super().minus(other) + return DateSpanSet(_inner=result) if result is not None else None + + def union(self, other: TimeDate) -> DateSpanSet: + """ + Returns the temporal union of ``self`` and ``other``. + + Args: + other: temporal object to merge with + + Returns: + A :class:`DateSpanSet` instance. + + MEOS Functions: + union_spanset_date, union_spanset_spanset, union_spanset_span + """ + if isinstance(other, date): + result = union_spanset_date(self._inner, date_to_date_adt(other)) + else: + result = super().union(other) + return DateSpanSet(_inner=result) if result is not None else None + + # ------------------------- Plot Operations ------------------------------- + def plot(self, *args, **kwargs): + from ...plotters import TimePlotter + + return TimePlotter.plot_tstzspanset(self.to_tstzspanset(), *args, **kwargs) diff --git a/pymeos/pymeos/collections/time/tstzspanset.py b/pymeos/pymeos/collections/time/tstzspanset.py index 68937028..ecf98c7a 100644 --- a/pymeos/pymeos/collections/time/tstzspanset.py +++ b/pymeos/pymeos/collections/time/tstzspanset.py @@ -22,7 +22,7 @@ class TsTzSpanSet(SpanSet[datetime], TimeCollection[datetime]): """ Class for representing lists of disjoint tstzspans. - ``TsTzSpanSet`` objects can be created with a single argument of type string + :class:``TsTzSpanSet`` objects can be created with a single argument of type string as in MobilityDB. >>> TsTzSpanSet(string='{[2019-09-08 00:00:00+01, 2019-09-10 00:00:00+01], [2019-09-11 00:00:00+01, 2019-09-12 00:00:00+01]}') @@ -169,17 +169,6 @@ def timestamps(self) -> List[datetime]: ts, count = tstzspanset_timestamps(self._inner) return [timestamptz_to_datetime(ts[i]) for i in range(count)] - def num_tstzspans(self) -> int: - """ - Returns the number of tstzspans in ``self``. - Returns: - An :class:`int` - - MEOS Functions: - spanset_num_spans - """ - return self.num_spans() - def start_span(self) -> TsTzSpan: """ Returns the first tstzspan in ``self``. @@ -193,17 +182,6 @@ def start_span(self) -> TsTzSpan: return TsTzSpan(_inner=super().start_span()) - def start_tstzspan(self) -> TsTzSpan: - """ - Returns the first tstzspan in ``self``. - Returns: - A :class:`TsTzSpan` instance - - MEOS Functions: - spanset_start_span - """ - return self.start_span() - def end_span(self) -> TsTzSpan: """ Returns the last tstzspan in ``self``. @@ -217,17 +195,6 @@ def end_span(self) -> TsTzSpan: return TsTzSpan(_inner=super().end_span()) - def end_tstzspan(self) -> TsTzSpan: - """ - Returns the last tstzspan in ``self``. - Returns: - A :class:`TsTzSpan` instance - - MEOS Functions: - spanset_end_span - """ - return self.end_span() - def span_n(self, n: int) -> TsTzSpan: """ Returns the n-th tstzspan in ``self``. @@ -241,17 +208,6 @@ def span_n(self, n: int) -> TsTzSpan: return TsTzSpan(_inner=super().span_n(n)) - def tstzspan_n(self, n: int) -> TsTzSpan: - """ - Returns the n-th tstzspan in ``self``. - Returns: - A :class:`TsTzSpan` instance - - MEOS Functions: - spanset_span_n - """ - return self.span_n(n) - def spans(self) -> List[TsTzSpan]: """ Returns the list of tstzspans in ``self``. @@ -266,21 +222,10 @@ def spans(self) -> List[TsTzSpan]: ps = super().spans() return [TsTzSpan(_inner=ps[i]) for i in range(self.num_spans())] - def tstzspans(self) -> List[TsTzSpan]: - """ - Returns the list of tstzspans in ``self``. - Returns: - A :class:`list[TsTzSpan]` instance - - MEOS Functions: - spanset_spans - """ - return self.spans() - # ------------------------- Transformations ------------------------------- def shift(self, delta: timedelta) -> TsTzSpanSet: """ - Returns a new tstzspanset that is the result of shifting ``self`` by + Returns a new :class:`TsTzSpanSet` that is the result of shifting ``self`` by ``delta`` Examples: @@ -291,7 +236,7 @@ def shift(self, delta: timedelta) -> TsTzSpanSet: delta: :class:`datetime.timedelta` instance to shift Returns: - A new :class:`PeriodSet` instance + A new :class:`TsTzSpanSet` instance MEOS Functions: tstzspanset_shift_scale From a49e4211d9de69a2f52cdcbe6288afb5919f220b Mon Sep 17 00:00:00 2001 From: Diviloper Date: Wed, 3 Jan 2024 08:23:14 +0100 Subject: [PATCH 07/37] Add VSCode folders to .gitignore --- pymeos/.gitignore | 6 ++++++ pymeos_cffi/.gitignore | 6 ++++++ 2 files changed, 12 insertions(+) diff --git a/pymeos/.gitignore b/pymeos/.gitignore index da795a12..14d951a7 100644 --- a/pymeos/.gitignore +++ b/pymeos/.gitignore @@ -1,9 +1,15 @@ .idea +.vscode + +.micromamba/ +d/** + build dist docs/_build *.egg-info .pytest_cache +*.pyc sandbox.py \ No newline at end of file diff --git a/pymeos_cffi/.gitignore b/pymeos_cffi/.gitignore index f964f10d..3966c9fd 100644 --- a/pymeos_cffi/.gitignore +++ b/pymeos_cffi/.gitignore @@ -1,4 +1,9 @@ .idea +.vscode + +.micromamba/ +d/** + .eggs build dist @@ -6,6 +11,7 @@ dist *.egg-info *.c +*.pyc *.o *.so From b95e0ffce7f910b27a5025c2b7b42eb89d69aee0 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Wed, 3 Jan 2024 08:25:15 +0100 Subject: [PATCH 08/37] Update .gitignores --- pymeos/.gitignore | 4 ++-- pymeos_cffi/.gitignore | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/pymeos/.gitignore b/pymeos/.gitignore index 14d951a7..c540b1ee 100644 --- a/pymeos/.gitignore +++ b/pymeos/.gitignore @@ -1,8 +1,8 @@ .idea .vscode -.micromamba/ -d/** +.micromamba +d build dist diff --git a/pymeos_cffi/.gitignore b/pymeos_cffi/.gitignore index 3966c9fd..a8a6cd33 100644 --- a/pymeos_cffi/.gitignore +++ b/pymeos_cffi/.gitignore @@ -1,8 +1,8 @@ .idea .vscode -.micromamba/ -d/** +.micromamba +d .eggs build From e7523693fc62bf1bc6780b214acc7eb4242a745f Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 31 Dec 2023 16:50:20 +0100 Subject: [PATCH 09/37] Update time collections tests --- .../{timestampset_test.py => tstzset_test.py} | 29 +++++++--------- .../time/{period_test.py => tstzspan_test.py} | 26 +++++++------- ...{periodset_test.py => tstzspanset_test.py} | 34 +++++++++---------- 3 files changed, 41 insertions(+), 48 deletions(-) rename pymeos/tests/collections/time/{timestampset_test.py => tstzset_test.py} (93%) rename pymeos/tests/collections/time/{period_test.py => tstzspan_test.py} (96%) rename pymeos/tests/collections/time/{periodset_test.py => tstzspanset_test.py} (94%) diff --git a/pymeos/tests/collections/time/timestampset_test.py b/pymeos/tests/collections/time/tstzset_test.py similarity index 93% rename from pymeos/tests/collections/time/timestampset_test.py rename to pymeos/tests/collections/time/tstzset_test.py index 21bfb2c5..c9263996 100644 --- a/pymeos/tests/collections/time/timestampset_test.py +++ b/pymeos/tests/collections/time/tstzset_test.py @@ -8,16 +8,11 @@ TsTzSpan, TsTzSpanSet, TsTzSet, - TFloatInst, - TFloatSeq, - STBox, - TFloatSeqSet, - TBox, ) from tests.conftest import TestPyMEOS -class TestTimestampSet(TestPyMEOS): +class TestTsTzSet(TestPyMEOS): ts_set = TsTzSet( "{2019-09-01 00:00:00+0, 2019-09-02 00:00:00+0, 2019-09-03 00:00:00+0}" ) @@ -28,7 +23,7 @@ def assert_tstzset_equality(ts_set: TsTzSet, timestamps: List[datetime]): assert ts_set.elements() == timestamps -class TestTimestampSetConstructors(TestTimestampSet): +class TestTsTzSetConstructors(TestTsTzSet): def test_string_constructor(self): self.assert_tstzset_equality( self.ts_set, @@ -86,7 +81,7 @@ def test_copy_constructor(self): assert self.ts_set is not ts_set_copy -class TestTimestampSetOutputs(TestTimestampSet): +class TestTsTzSetOutputs(TestTsTzSet): def test_str(self): assert ( str(self.ts_set) @@ -103,21 +98,21 @@ def test_as_hexwkb(self): assert self.ts_set == TsTzSet.from_hexwkb(self.ts_set.as_hexwkb()) -class TestTimestampConversions(TestTimestampSet): +class TestTimestampConversions(TestTsTzSet): def test_to_tstzspanset(self): - assert self.ts_set.to_tstzspanset() == TsTzSpanSet( + assert self.ts_set.to_spanset() == TsTzSpanSet( "{[2019-09-01 00:00:00+00, 2019-09-01 00:00:00+00], " "[2019-09-02 00:00:00+00, 2019-09-02 00:00:00+00], " "[2019-09-03 00:00:00+00, 2019-09-03 00:00:00+00]}" ) -class TestTimestampSetAccessors(TestTimestampSet): +class TestTsTzSetAccessors(TestTsTzSet): def test_duration(self): assert self.ts_set.duration() == timedelta(days=2) def test_tstzspan(self): - assert self.ts_set.to_tstzspan() == TsTzSpan( + assert self.ts_set.to_span() == TsTzSpan( "[2019-09-01 00:00:00+00, 2019-09-03 00:00:00+00]" ) @@ -155,7 +150,7 @@ def test_hash(self): assert hash(self.ts_set) == 527267058 -class TestTimestampSetPositionFunctions(TestTimestampSet): +class TestTsTzSetPositionFunctions(TestTsTzSet): timestamp = datetime(year=2020, month=1, day=1) tstzset = TsTzSet("{2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0}") @@ -205,7 +200,7 @@ def test_distance(self, other): self.ts_set.distance(other) -class TestTimestampSetSetFunctions(TestTimestampSet): +class TestTsTzSetSetFunctions(TestTsTzSet): timestamp = datetime(year=2020, month=1, day=1) tstzset = TsTzSet("{2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0}") tstzspan = TsTzSpan("(2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0)") @@ -241,7 +236,7 @@ def test_minus(self, other): self.tstzset - other -class TestTimestampSetComparisons(TestTimestampSet): +class TestTsTzSetComparisons(TestTsTzSet): tstzset = TsTzSet("{2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0}") other = TsTzSet("{2020-01-02 00:00:00+0, 2020-03-31 00:00:00+0}") @@ -264,7 +259,7 @@ def test_ge(self): _ = self.tstzset >= self.other -class TestTimestampSetFunctionsFunctions(TestTimestampSet): +class TestTsTzSetFunctionsFunctions(TestTsTzSet): tstzset = TsTzSet( "{2020-01-01 00:00:00+0, 2020-01-02 00:00:00+0, 2020-01-04 00:00:00+0}" ) @@ -349,7 +344,7 @@ def test_shift_scale(self): ) -class TestTimestampSetMiscFunctions(TestTimestampSet): +class TestTsTzSetMiscFunctions(TestTsTzSet): tstzset = TsTzSet( "{2020-01-01 00:00:00+0, 2020-01-02 00:00:00+0, 2020-01-04 00:00:00+0}" ) diff --git a/pymeos/tests/collections/time/period_test.py b/pymeos/tests/collections/time/tstzspan_test.py similarity index 96% rename from pymeos/tests/collections/time/period_test.py rename to pymeos/tests/collections/time/tstzspan_test.py index da070065..478a3357 100644 --- a/pymeos/tests/collections/time/period_test.py +++ b/pymeos/tests/collections/time/tstzspan_test.py @@ -6,18 +6,16 @@ from pymeos import ( TsTzSpan, TsTzSpanSet, - TsTzSet, TBox, STBox, TFloatInst, TFloatSeq, TFloatSeqSet, ) - from tests.conftest import TestPyMEOS -class TestPeriod(TestPyMEOS): +class TestTsTzSpan(TestPyMEOS): tstzspan = TsTzSpan("(2019-09-08 00:00:00+0, 2019-09-10 00:00:00+0)") @staticmethod @@ -38,7 +36,7 @@ def assert_tstzspan_equality( assert tstzspan.upper_inc() == upper_inc -class TestPeriodConstructors(TestPeriod): +class TestTsTzSpanConstructors(TestTsTzSpan): @pytest.mark.parametrize( "source, params", [ @@ -129,7 +127,7 @@ def test_copy_constructor(self): assert self.tstzspan is not other -class TestPeriodOutputs(TestPeriod): +class TestTsTzSpanOutputs(TestTsTzSpan): def test_str(self): assert str(self.tstzspan) == "(2019-09-08 00:00:00+00, 2019-09-10 00:00:00+00)" @@ -143,15 +141,15 @@ def test_hexwkb(self): assert self.tstzspan == TsTzSpan.from_hexwkb(self.tstzspan.as_hexwkb()) -class TestPeriodConversions(TestPeriod): +class TestTsTzSpanConversions(TestTsTzSpan): def test_to_tstzspanset(self): - tstzspanset = self.tstzspan.to_tstzspanset() + tstzspanset = self.tstzspan.to_spanset() assert isinstance(tstzspanset, TsTzSpanSet) - assert tstzspanset.num_tstzspans() == 1 - assert tstzspanset.start_tstzspan() == self.tstzspan + assert tstzspanset.num_spans() == 1 + assert tstzspanset.start_span() == self.tstzspan -class TestPeriodAccessors(TestPeriod): +class TestTsTzSpanAccessors(TestTsTzSpan): tstzspan2 = TsTzSpan("[2019-09-08 02:03:00+0, 2019-09-10 02:03:00+0]") def test_lower(self): @@ -182,7 +180,7 @@ def test_hash(self): assert hash(self.tstzspan) -class TestPeriodTransformations(TestPeriod): +class TestTsTzSpanTransformations(TestTsTzSpan): @pytest.mark.parametrize( "delta,result", [ @@ -268,7 +266,7 @@ def test_shift_scale(self): ) -class TestPeriodTopologicalPositionFunctions(TestPeriod): +class TestTsTzSpanTopologicalPositionFunctions(TestTsTzSpan): tstzspan = TsTzSpan("(2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0)") tstzspanset = TsTzSpanSet( "{(2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0), (2021-01-01 00:00:00+0, 2021-01-31 00:00:00+0)}" @@ -595,7 +593,7 @@ def test_distance(self, other): self.tstzspan.distance(other) -class TestPeriodSetFunctions(TestPeriod): +class TestTsTzSpanSetFunctions(TestTsTzSpan): tstzspan = TsTzSpan("(2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0)") tstzspanset = TsTzSpanSet( "{(2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0), (2021-01-01 00:00:00+0, 2021-01-31 00:00:00+0)}" @@ -630,7 +628,7 @@ def test_minus(self, other): self.tstzspan - other -class TestPeriodComparisons(TestPeriod): +class TestTsTzSpanComparisons(TestTsTzSpan): tstzspan = TsTzSpan("(2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0)") other = TsTzSpan("(2020-01-02 00:00:00+0, 2020-03-31 00:00:00+0)") diff --git a/pymeos/tests/collections/time/periodset_test.py b/pymeos/tests/collections/time/tstzspanset_test.py similarity index 94% rename from pymeos/tests/collections/time/periodset_test.py rename to pymeos/tests/collections/time/tstzspanset_test.py index 254b599b..f7dd9458 100644 --- a/pymeos/tests/collections/time/periodset_test.py +++ b/pymeos/tests/collections/time/tstzspanset_test.py @@ -16,18 +16,18 @@ from tests.conftest import TestPyMEOS -class TestPeriodSet(TestPyMEOS): +class TestTsTzSpanSet(TestPyMEOS): tstzspanset = TsTzSpanSet("{[2019-09-01, 2019-09-02], [2019-09-03, 2019-09-04]}") @staticmethod def assert_tstzspanset_equality( tstzspanset: TsTzSpanSet, tstzspans: List[TsTzSpan] ): - assert tstzspanset.num_tstzspans() == len(tstzspans) - assert tstzspanset.tstzspans() == tstzspans + assert tstzspanset.num_spans() == len(tstzspans) + assert tstzspanset.spans() == tstzspans -class TestPeriodSetConstructors(TestPeriodSet): +class TestTsTzSpanSetConstructors(TestTsTzSpanSet): def test_string_constructor(self): self.assert_tstzspanset_equality( self.tstzspanset, @@ -63,7 +63,7 @@ def test_copy_constructor(self): assert self.tstzspanset is not copied -class TestPeriodSetOutputs(TestPeriodSet): +class TestTsTzSpanSetOutputs(TestTsTzSpanSet): def test_str(self): assert ( str(self.tstzspanset) @@ -82,12 +82,12 @@ def test_hexwkb(self): assert self.tstzspanset == TsTzSpanSet.from_hexwkb(self.tstzspanset.as_hexwkb()) -class TestPeriodSetConversions(TestPeriodSet): +class TestTsTzSpanSetConversions(TestTsTzSpanSet): def test_to_tstzspan(self): assert self.tstzspanset.to_tstzspan() == TsTzSpan("[2019-09-01, 2019-09-04]") -class TestPeriodSetAccessors(TestPeriodSet): +class TestTsTzSpanSetAccessors(TestTsTzSpanSet): tstzspanset2 = TsTzSpanSet("{[2019-09-01, 2019-09-02), (2019-09-02, 2019-09-04]}") def test_duration(self): @@ -131,20 +131,20 @@ def test_timestamps(self): ] def test_num_tstzspans(self): - assert self.tstzspanset.num_tstzspans() == 2 + assert self.tstzspanset.num_spans() == 2 def test_start_tstzspan(self): - assert self.tstzspanset.start_tstzspan() == TsTzSpan("[2019-09-01, 2019-09-02]") + assert self.tstzspanset.start_span() == TsTzSpan("[2019-09-01, 2019-09-02]") def test_end_tstzspan(self): - assert self.tstzspanset.end_tstzspan() == TsTzSpan("[2019-09-03, 2019-09-04]") + assert self.tstzspanset.end_span() == TsTzSpan("[2019-09-03, 2019-09-04]") def test_tstzspan_n(self): - assert self.tstzspanset.tstzspan_n(0) == TsTzSpan("[2019-09-01, 2019-09-02]") - assert self.tstzspanset.tstzspan_n(1) == TsTzSpan("[2019-09-03, 2019-09-04]") + assert self.tstzspanset.span_n(0) == TsTzSpan("[2019-09-01, 2019-09-02]") + assert self.tstzspanset.span_n(1) == TsTzSpan("[2019-09-03, 2019-09-04]") def test_tstzspans(self): - assert self.tstzspanset.tstzspans() == [ + assert self.tstzspanset.spans() == [ TsTzSpan("[2019-09-01, 2019-09-02]"), TsTzSpan("[2019-09-03, 2019-09-04]"), ] @@ -153,7 +153,7 @@ def test_hash(self): assert hash(self.tstzspanset) -class TestPeriodSetTransformations(TestPeriodSet): +class TestTsTzSpanSetTransformations(TestTsTzSpanSet): @pytest.mark.parametrize( "delta,result", [ @@ -229,7 +229,7 @@ def test_shift_scale(self): ) -class TestPeriodSetTopologicalPositionFunctions(TestPeriodSet): +class TestTsTzSpanSetTopologicalPositionFunctions(TestTsTzSpanSet): tstzspan = TsTzSpan("(2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0)") tstzspanset = TsTzSpanSet( "{(2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0), (2021-01-01 00:00:00+0, 2021-01-31 00:00:00+0)}" @@ -550,7 +550,7 @@ def test_distance(self, other): self.tstzspanset.distance(other) -class TestPeriodSetSetFunctions(TestPeriodSet): +class TestTsTzSpanSetSetFunctions(TestTsTzSpanSet): tstzspan = TsTzSpan("(2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0)") tstzspanset = TsTzSpanSet( "{(2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0), (2021-01-01 00:00:00+0, 2021-01-31 00:00:00+0)}" @@ -585,7 +585,7 @@ def test_minus(self, other): self.tstzspanset - other -class TestPeriodSetComparisons(TestPeriodSet): +class TestTsTzSpanSetComparisons(TestTsTzSpanSet): tstzspanset = TsTzSpanSet( "{(2020-01-01 00:00:00+0, 2020-01-31 00:00:00+0), (2021-01-01 00:00:00+0, 2021-01-31 00:00:00+0)}" ) From 8539323a4df69c59e03b40ec7aea007f99b28629 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 31 Dec 2023 16:55:31 +0100 Subject: [PATCH 10/37] Update from_base_time type annotations in tfloat and tpoint --- pymeos/pymeos/main/tfloat.py | 23 +++++++++++---- pymeos/pymeos/main/tpoint.py | 54 ++++++++++++++++++++++++++---------- 2 files changed, 57 insertions(+), 20 deletions(-) diff --git a/pymeos/pymeos/main/tfloat.py b/pymeos/pymeos/main/tfloat.py index 876366a4..8329c0b9 100644 --- a/pymeos/pymeos/main/tfloat.py +++ b/pymeos/pymeos/main/tfloat.py @@ -54,17 +54,30 @@ def from_base_temporal( @staticmethod @overload - def from_base_time(value: float, base: datetime) -> TFloatInst: + def from_base_time( + value: float, base: datetime, interpolation: None = None + ) -> TFloatInst: + ... + + @staticmethod + @overload + def from_base_time( + value: float, base: TsTzSet, interpolation: None = None + ) -> TFloatSeq: ... @staticmethod @overload - def from_base_time(value: float, base: Union[TsTzSet, TsTzSpan]) -> TFloatSeq: + def from_base_time( + value: float, base: TsTzSpan, interpolation: TInterpolation = None + ) -> TFloatSeq: ... @staticmethod @overload - def from_base_time(value: float, base: TsTzSpanSet) -> TFloatSeqSet: + def from_base_time( + value: float, base: TsTzSpanSet, interpolation: TInterpolation = None + ) -> TFloatSeqSet: ... @staticmethod @@ -92,9 +105,7 @@ def from_base_time( _inner=tfloatinst_make(value, datetime_to_timestamptz(base)) ) elif isinstance(base, TsTzSet): - return TFloatSeq( - _inner=tfloatseq_from_base_tstzset(value, base._inner) - ) + return TFloatSeq(_inner=tfloatseq_from_base_tstzset(value, base._inner)) elif isinstance(base, TsTzSpan): return TFloatSeq( _inner=tfloatseq_from_base_tstzspan(value, base._inner, interpolation) diff --git a/pymeos/pymeos/main/tpoint.py b/pymeos/pymeos/main/tpoint.py index 20ad7e13..71e39975 100644 --- a/pymeos/pymeos/main/tpoint.py +++ b/pymeos/pymeos/main/tpoint.py @@ -1408,19 +1408,32 @@ def from_base_temporal(value: shpb.BaseGeometry, base: Temporal) -> TGeomPoint: @staticmethod @overload - def from_base_time(value: shpb.BaseGeometry, base: datetime) -> TGeomPointInst: + def from_base_time( + value: shpb.BaseGeometry, base: datetime, interpolation: None = None + ) -> TGeomPointInst: + ... + + @staticmethod + @overload + def from_base_time( + value: shpb.BaseGeometry, base: TsTzSet, interpolation: None = None + ) -> TGeomPointSeq: ... @staticmethod @overload def from_base_time( - value: shpb.BaseGeometry, base: Union[TsTzSet, TsTzSpan] + value: shpb.BaseGeometry, base: TsTzSpan, interpolation: TInterpolation = None ) -> TGeomPointSeq: ... @staticmethod @overload - def from_base_time(value: shpb.BaseGeometry, base: TsTzSpanSet) -> TGeomPointSeqSet: + def from_base_time( + value: shpb.BaseGeometry, + base: TsTzSpanSet, + interpolation: TInterpolation = None, + ) -> TGeomPointSeqSet: ... @staticmethod @@ -1448,16 +1461,16 @@ def from_base_time( _inner=tpointinst_make(gs, datetime_to_timestamptz(base)) ) elif isinstance(base, TsTzSet): - return TGeomPointSeq( - _inner=tpointseq_from_base_tstzset(gs, base._inner) - ) + return TGeomPointSeq(_inner=tpointseq_from_base_tstzset(gs, base._inner)) elif isinstance(base, TsTzSpan): return TGeomPointSeq( _inner=tpointseq_from_base_tstzspan(gs, base._inner, interpolation) ) elif isinstance(base, TsTzSpanSet): return TGeomPointSeqSet( - _inner=tpointseqset_from_base_tstzspanset(gs, base._inner, interpolation) + _inner=tpointseqset_from_base_tstzspanset( + gs, base._inner, interpolation + ) ) raise TypeError(f"Operation not supported with type {base.__class__}") @@ -1690,19 +1703,32 @@ def from_base_temporal(value: shpb.BaseGeometry, base: Temporal) -> TGeogPoint: @staticmethod @overload - def from_base_time(value: shpb.BaseGeometry, base: datetime) -> TGeogPointInst: + def from_base_time( + value: shpb.BaseGeometry, base: datetime, interpolation: TInterpolation = None + ) -> TGeogPointInst: + ... + + @staticmethod + @overload + def from_base_time( + value: shpb.BaseGeometry, base: TsTzSet, interpolation: TInterpolation = None + ) -> TGeogPointSeq: ... @staticmethod @overload def from_base_time( - value: shpb.BaseGeometry, base: Union[TsTzSet, TsTzSpan] + value: shpb.BaseGeometry, base: TsTzSpan, interpolation: TInterpolation = None ) -> TGeogPointSeq: ... @staticmethod @overload - def from_base_time(value: shpb.BaseGeometry, base: TsTzSpanSet) -> TGeogPointSeqSet: + def from_base_time( + value: shpb.BaseGeometry, + base: TsTzSpanSet, + interpolation: TInterpolation = None, + ) -> TGeogPointSeqSet: ... @staticmethod @@ -1730,16 +1756,16 @@ def from_base_time( _inner=tpointinst_make(gs, datetime_to_timestamptz(base)) ) elif isinstance(base, TsTzSet): - return TGeogPointSeq( - _inner=tpointseq_from_base_tstzset(gs, base._inner) - ) + return TGeogPointSeq(_inner=tpointseq_from_base_tstzset(gs, base._inner)) elif isinstance(base, TsTzSpan): return TGeogPointSeq( _inner=tpointseq_from_base_tstzspan(gs, base._inner, interpolation) ) elif isinstance(base, TsTzSpanSet): return TGeogPointSeqSet( - _inner=tpointseqset_from_base_tstzspanset(gs, base._inner, interpolation) + _inner=tpointseqset_from_base_tstzspanset( + gs, base._inner, interpolation + ) ) raise TypeError(f"Operation not supported with type {base.__class__}") From 9eda840ac1d718c8a25a72e26069eb4949d88c56 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 31 Dec 2023 18:08:42 +0100 Subject: [PATCH 11/37] Update pymeos_cffi enum with new date types --- pymeos_cffi/pymeos_cffi/enums.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/pymeos_cffi/pymeos_cffi/enums.py b/pymeos_cffi/pymeos_cffi/enums.py index 6e6a9343..18b29030 100644 --- a/pymeos_cffi/pymeos_cffi/enums.py +++ b/pymeos_cffi/pymeos_cffi/enums.py @@ -5,6 +5,12 @@ class MeosType(IntEnum): T_UNKNOWN = _lib.T_UNKNOWN T_BOOL = _lib.T_BOOL + T_DATE = _lib.T_DATE + T_DATEMULTIRANGE = _lib.T_DATEMULTIRANGE + T_DATERANGE = _lib.T_DATERANGE + T_DATESET = _lib.T_DATESET + T_DATESPAN = _lib.T_DATESPAN + T_DATESPANSET = _lib.T_DATESPANSET T_DOUBLE2 = _lib.T_DOUBLE2 T_DOUBLE3 = _lib.T_DOUBLE3 T_DOUBLE4 = _lib.T_DOUBLE4 @@ -13,8 +19,8 @@ class MeosType(IntEnum): T_FLOATSPAN = _lib.T_FLOATSPAN T_FLOATSPANSET = _lib.T_FLOATSPANSET T_INT4 = _lib.T_INT4 - T_INT4RANGE = _lib.T_INT4RANGE T_INT4MULTIRANGE = _lib.T_INT4MULTIRANGE + T_INT4RANGE = _lib.T_INT4RANGE T_INTSET = _lib.T_INTSET T_INTSPAN = _lib.T_INTSPAN T_INTSPANSET = _lib.T_INTSPANSET From cfd262b64558408cfe4084acd724ca8d599180cd Mon Sep 17 00:00:00 2001 From: Diviloper Date: Wed, 3 Jan 2024 11:37:06 +0100 Subject: [PATCH 12/37] Add new factory for Collection types --- pymeos/pymeos/collections/__init__.py | 7 ++- pymeos/pymeos/collections/time/__init__.py | 21 ++++++- pymeos/pymeos/factory.py | 73 +++++++++++++++++++++- 3 files changed, 95 insertions(+), 6 deletions(-) diff --git a/pymeos/pymeos/collections/__init__.py b/pymeos/pymeos/collections/__init__.py index 69c530d1..23a0bd61 100644 --- a/pymeos/pymeos/collections/__init__.py +++ b/pymeos/pymeos/collections/__init__.py @@ -9,11 +9,16 @@ "Set", "Span", "SpanSet", + "TimeDate", + "date", + "DateSet", + "DateSpan", + "DateSpanSet", "Time", + "datetime", "TsTzSet", "TsTzSpan", "TsTzSpanSet", - "datetime", "timedelta", "TextSet", "GeoSet", diff --git a/pymeos/pymeos/collections/time/__init__.py b/pymeos/pymeos/collections/time/__init__.py index 47f266f5..88b53ae9 100644 --- a/pymeos/pymeos/collections/time/__init__.py +++ b/pymeos/pymeos/collections/time/__init__.py @@ -1,7 +1,22 @@ from .tstzset import TsTzSet +from .dateset import DateSet from .tstzspan import TsTzSpan +from .datespan import DateSpan from .tstzspanset import TsTzSpanSet -from .time import Time -from datetime import datetime, timedelta +from .datespanset import DateSpanSet +from .time import Time, TimeDate +from datetime import datetime, timedelta, date -__all__ = ["Time", "TsTzSet", "TsTzSpan", "TsTzSpanSet", "datetime", "timedelta"] +__all__ = [ + "TimeDate", + "date", + "DateSet", + "DateSpan", + "DateSpanSet", + "Time", + "datetime", + "TsTzSet", + "TsTzSpan", + "TsTzSpanSet", + "timedelta", +] diff --git a/pymeos/pymeos/factory.py b/pymeos/pymeos/factory.py index ee7d1233..1bed983e 100644 --- a/pymeos/pymeos/factory.py +++ b/pymeos/pymeos/factory.py @@ -20,13 +20,31 @@ TGeogPointSeq, TGeogPointSeqSet, ) +from .collections import ( + GeometrySet, + GeographySet, + IntSet, + IntSpan, + IntSpanSet, + FloatSet, + FloatSpan, + FloatSpanSet, + TextSet, + DateSet, + DateSpan, + DateSpanSet, + TsTzSet, + TsTzSpan, + TsTzSpanSet, +) class _TemporalFactory: """ Factory class to create the proper PyMEOS class from a MEOS object. - This class is used internally by PyMEOS classes and there shouldn't be any need to be used outside of them. + This class is used internally by PyMEOS classes and there shouldn't be any need to + be used outside of them. """ _mapper = { @@ -59,9 +77,60 @@ def create_temporal(inner): inner: MEOS object. Returns: - An appropriate subclass of :class:`Temporal` wrapping `inner`. + An instance of the appropriate subclass of :class:`Temporal` wrapping + `inner`. """ if inner is None: return None temp_type = (inner.temptype, inner.subtype) return _TemporalFactory._mapper[temp_type](_inner=inner) + + +class _CollectionFactory: + """ + Factory class to create the proper PyMEOS collection class from a MEOS object. + + This class is used internally by PyMEOS classes and there shouldn't be any need + to be used outside of them. + """ + + _mapper = { + MeosType.T_GEOMSET: GeometrySet, + MeosType.T_GEOGSET: GeographySet, + MeosType.T_INTSET: IntSet, + MeosType.T_INTSPAN: IntSpan, + MeosType.T_INTSPANSET: IntSpanSet, + MeosType.T_FLOATSET: FloatSet, + MeosType.T_FLOATSPAN: FloatSpan, + MeosType.T_FLOATSPANSET: FloatSpanSet, + MeosType.T_TEXTSET: TextSet, + MeosType.T_DATESET: DateSet, + MeosType.T_DATESPAN: DateSpan, + MeosType.T_DATESPANSET: DateSpanSet, + MeosType.T_TSTZSET: TsTzSet, + MeosType.T_TSTZSPAN: TsTzSpan, + MeosType.T_TSTZSPANSET: TsTzSpanSet, + } + + @staticmethod + def create_collection(inner): + """ + Creates the appropriate PyMEOS Collection class from a meos object. + + Args: + inner: MEOS object. + + Returns: + An instance of the appropriate subclass of :class:`Collection` wrapping + `inner`. + """ + if inner is None: + return None + + attributes = ["spansettype", "spantype", "settype"] + collection_type = next( + getattr(inner, attribute) + for attribute in attributes + if hasattr(inner, attribute) + ) + return _CollectionFactory._mapper[collection_type](_inner=inner) From 807180a924f16766c17ac6ac43f61511454fde1d Mon Sep 17 00:00:00 2001 From: Diviloper Date: Wed, 3 Jan 2024 11:42:41 +0100 Subject: [PATCH 13/37] Add polymorphic typings in base class instead of overriding the method in every subclass just for the typing. But it's ugly. Probably it will be moved into a new .pyi file, once I discover how to do so. --- pymeos/pymeos/collections/base/collection.py | 12 ++-- pymeos/pymeos/collections/base/set.py | 59 ++++++++++++++------ pymeos/pymeos/collections/number/floatset.py | 2 +- pymeos/pymeos/collections/number/intset.py | 32 +---------- pymeos/pymeos/collections/time/tstzset.py | 29 ---------- 5 files changed, 50 insertions(+), 84 deletions(-) diff --git a/pymeos/pymeos/collections/base/collection.py b/pymeos/pymeos/collections/base/collection.py index afb3ae46..b0960748 100644 --- a/pymeos/pymeos/collections/base/collection.py +++ b/pymeos/pymeos/collections/base/collection.py @@ -1,10 +1,10 @@ from __future__ import annotations from abc import ABC, abstractmethod -from typing import Generic, TypeVar +from typing import Generic, TypeVar, Type T = TypeVar("T") -Self = TypeVar("Self", bound="Set[Any]") +Self = TypeVar("Self") class Collection(Generic[T], ABC): @@ -29,10 +29,6 @@ def __contains__(self, item): def overlaps(self, other) -> bool: raise NotImplementedError() - # @abstractmethod - # def is_same(self, other) -> bool: - # raise NotImplementedError() - # ------------------------- Position Operations --------------------------- @abstractmethod def is_left(self, other) -> bool: @@ -54,9 +50,9 @@ def is_right(self, other) -> bool: # ------------------------- Database Operations --------------------------- @classmethod - def read_from_cursor(cls, value, _=None): + def read_from_cursor(cls: Type[Self], value, _=None): """ - Reads a :class:`STBox` from a database cursor. Used when automatically + Reads a :class:`Collection` from a database cursor. Used when automatically loading objects from the database. Users should use the class constructor instead. """ diff --git a/pymeos/pymeos/collections/base/set.py b/pymeos/pymeos/collections/base/set.py index 73cc7fc8..5e25bc06 100644 --- a/pymeos/pymeos/collections/base/set.py +++ b/pymeos/pymeos/collections/base/set.py @@ -1,7 +1,7 @@ from __future__ import annotations from abc import ABC, abstractmethod -from typing import Optional, Union, List +from typing import Optional, Union, List, overload from typing import TypeVar, Type, Callable, Any, TYPE_CHECKING, Iterable from pymeos_cffi import * @@ -12,6 +12,9 @@ from .spanset import SpanSet from .span import Span + from ..number import IntSet, IntSpan, IntSpanSet, FloatSet, FloatSpan, FloatSpanSet + from ..time import DateSet, DateSpan, DateSpanSet, TsTzSet, TsTzSpan, TsTzSpanSet + T = TypeVar("T") Self = TypeVar("Self", bound="Set[Any]") @@ -75,7 +78,9 @@ def from_wkb(cls: Type[Self], wkb: bytes) -> Self: MEOS Functions: set_from_wkb """ - return cls(_inner=set_from_wkb(wkb)) + from ...factory import _CollectionFactory + + return _CollectionFactory.create_collection(set_from_wkb(wkb)) @classmethod def from_hexwkb(cls: Type[Self], hexwkb: str) -> Self: @@ -90,11 +95,13 @@ def from_hexwkb(cls: Type[Self], hexwkb: str) -> Self: MEOS Functions: set_from_hexwkb """ - return cls(_inner=(set_from_hexwkb(hexwkb))) + from ...factory import _CollectionFactory + + return _CollectionFactory.create_collection((set_from_hexwkb(hexwkb))) # ------------------------- Output ---------------------------------------- @abstractmethod - def __str__(self): + def __str__(self) -> str: """ Return the string representation of the content of ``self``. @@ -103,7 +110,7 @@ def __str__(self): """ raise NotImplementedError() - def __repr__(self): + def __repr__(self) -> str: """ Return the string representation of ``self``. @@ -138,20 +145,22 @@ def as_hexwkb(self) -> str: return set_as_hexwkb(self._inner, -1)[0] # ------------------------- Conversions ----------------------------------- - @abstractmethod - def to_spanset(self) -> SpanSet: - """ - Returns a SpanSet that contains a Span for each element in ``self``. + @overload + def to_span(self: Type[IntSet]) -> IntSpan: + ... - Returns: - A new :class:`SpanSet` instance + @overload + def to_span(self: Type[FloatSet]) -> FloatSpan: + ... - MEOS Functions: - set_to_spanset - """ - return set_to_spanset(self._inner) + @overload + def to_span(self: Type[TsTzSet]) -> TsTzSpan: + ... + + @overload + def to_span(self: Type[DateSet]) -> DateSpan: + ... - @abstractmethod def to_span(self) -> Span: """ Returns a span that encompasses ``self``. @@ -162,7 +171,23 @@ def to_span(self) -> Span: MEOS Functions: set_span """ - return set_span(self._inner) + from ...factory import _CollectionFactory + + return _CollectionFactory.create_collection(set_span(self._inner)) + + def to_spanset(self) -> SpanSet: + """ + Returns a SpanSet that contains a Span for each element in ``self``. + + Returns: + A new :class:`SpanSet` instance + + MEOS Functions: + set_to_spanset + """ + from ...factory import _CollectionFactory + + return _CollectionFactory.create_collection(set_to_spanset(self._inner)) # ------------------------- Accessors ------------------------------------- diff --git a/pymeos/pymeos/collections/number/floatset.py b/pymeos/pymeos/collections/number/floatset.py index dcd5624f..b789d2bf 100644 --- a/pymeos/pymeos/collections/number/floatset.py +++ b/pymeos/pymeos/collections/number/floatset.py @@ -100,7 +100,7 @@ def to_span(self) -> FloatSpan: MEOS Functions: set_span """ - return FloatSpan(_inner=super().to_span()) + return super().to_span() def to_intset(self) -> IntSet: """ diff --git a/pymeos/pymeos/collections/number/intset.py b/pymeos/pymeos/collections/number/intset.py index e2650c75..2317a1ba 100644 --- a/pymeos/pymeos/collections/number/intset.py +++ b/pymeos/pymeos/collections/number/intset.py @@ -36,19 +36,18 @@ class IntSet(Set[int]): """ - Class for representing a set of text values. + Class for representing a set of integer values. - ``TextSet`` objects can be created with a single argument of type string as + ``IntSet`` objects can be created with a single argument of type string as in MobilityDB. >>> IntSet(string='{1, 3, 56}') - Another possibility is to create a ``TextSet`` object from a list of + Another possibility is to create a ``IntSet`` object from a list of strings or integers. >>> IntSet(elements=[1, '2', 3, '56']) - """ __slots__ = ["_inner"] @@ -77,31 +76,6 @@ def __str__(self): # ------------------------- Conversions ----------------------------------- - def to_spanset(self) -> IntSpanSet: - """ - Returns a SpanSet that contains a Span for each element in ``self``. - - Returns: - A new :class:`IntSpanSet` instance - - MEOS Functions: - set_to_spanset - """ - - return IntSpanSet(_inner=super().to_spanset()) - - def to_span(self) -> IntSpan: - """ - Returns a span that encompasses ``self``. - - Returns: - A new :class:`IntSpan` instance - - MEOS Functions: - set_span - """ - return IntSpan(_inner=super().to_span()) - def to_floatset(self) -> FloatSet: """ Converts ``self`` to a :class:`FloatSet` instance. diff --git a/pymeos/pymeos/collections/time/tstzset.py b/pymeos/pymeos/collections/time/tstzset.py index 14eaf982..bf887efd 100644 --- a/pymeos/pymeos/collections/time/tstzset.py +++ b/pymeos/pymeos/collections/time/tstzset.py @@ -63,35 +63,6 @@ def __str__(self): return tstzset_out(self._inner) # ------------------------- Conversions ----------------------------------- - def to_spanset(self) -> TsTzSpanSet: - """ - Returns a TsTzSpanSet that contains a TsTzSpan for each Timestamp in - ``self``. - - Returns: - A new :class:`TsTzSpanSet` instance - - MEOS Functions: - set_to_spanset - """ - from .tstzspanset import TsTzSpanSet - - return TsTzSpanSet(_inner=super().to_spanset()) - - def to_span(self) -> TsTzSpan: - """ - Returns a tstzspan that encompasses ``self``. - - Returns: - A new :class:`TsTzSpan` instance - - MEOS Functions: - set_span - """ - from .tstzspan import TsTzSpan - - return TsTzSpan(_inner=super().to_span()) - # ------------------------- Accessors ------------------------------------- def duration(self) -> timedelta: """ From 879fa7be1d7316d9c6278df851dd14976dd86613 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Wed, 3 Jan 2024 11:40:24 +0300 Subject: [PATCH 14/37] Format --- pymeos_cffi/setup.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pymeos_cffi/setup.py b/pymeos_cffi/setup.py index 19d492a6..8d234f42 100644 --- a/pymeos_cffi/setup.py +++ b/pymeos_cffi/setup.py @@ -1,7 +1,7 @@ from setuptools import setup setup( - packages=['pymeos_cffi', 'pymeos_cffi.builder'], - setup_requires=['cffi'], - cffi_modules=['pymeos_cffi/builder/build_pymeos.py:ffibuilder'], + packages=["pymeos_cffi", "pymeos_cffi.builder"], + setup_requires=["cffi"], + cffi_modules=["pymeos_cffi/builder/build_pymeos.py:ffibuilder"], ) From 6f904f66ace8fcde114d0193b117212172d35fd6 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Wed, 3 Jan 2024 16:26:42 +0300 Subject: [PATCH 15/37] Start adding test for date collections --- pymeos/.gitignore | 4 +- pymeos/pymeos/collections/time/tstzset.py | 20 +- pymeos/pymeos/collections/time/tstzspan.py | 4 +- pymeos/pymeos/main/tint.py | 4 +- pymeos/pymeos/plotters/box_plotter.py | 4 +- pymeos/pymeos/temporal/temporal.py | 8 +- pymeos/tests/boxes/tbox_test.py | 20 +- pymeos/tests/collections/time/dateset_test.py | 297 + .../tests/collections/time/tstzspan_test.py | 14 +- pymeos/tests/main/tbool_test.py | 9 +- pymeos/tests/main/tfloat_test.py | 6 +- pymeos/tests/main/tgeogpoint_test.py | 20 +- pymeos/tests/main/tgeompoint_test.py | 20 +- pymeos/tests/main/ttext_test.py | 9 +- pymeos_cffi/pymeos_cffi/__init__.py | 3811 ++--- pymeos_cffi/pymeos_cffi/functions.py | 11680 +++++++--------- 16 files changed, 7471 insertions(+), 8459 deletions(-) create mode 100644 pymeos/tests/collections/time/dateset_test.py diff --git a/pymeos/.gitignore b/pymeos/.gitignore index c540b1ee..7b4555d8 100644 --- a/pymeos/.gitignore +++ b/pymeos/.gitignore @@ -12,4 +12,6 @@ docs/_build .pytest_cache *.pyc -sandbox.py \ No newline at end of file +sandbox.py + +coverage.xml \ No newline at end of file diff --git a/pymeos/pymeos/collections/time/tstzset.py b/pymeos/pymeos/collections/time/tstzset.py index bf887efd..105ebd1f 100644 --- a/pymeos/pymeos/collections/time/tstzset.py +++ b/pymeos/pymeos/collections/time/tstzset.py @@ -350,9 +350,7 @@ def overlaps( from ...boxes import Box if isinstance(other, datetime): - return contains_set_timestamptz( - self._inner, datetime_to_timestamptz(other) - ) + return contains_set_timestamptz(self._inner, datetime_to_timestamptz(other)) elif isinstance(other, Temporal): return self.to_spanset().overlaps(other) elif isinstance(other, get_args(Box)): @@ -403,9 +401,7 @@ def is_left(self, other: Union[Time, Temporal, Box]) -> bool: from ...boxes import Box if isinstance(other, datetime): - return after_timestamptz_set( - datetime_to_timestamptz(other), self._inner - ) + return after_timestamptz_set(datetime_to_timestamptz(other), self._inner) elif isinstance(other, Temporal): return self.to_span().is_left(other) elif isinstance(other, get_args(Box)): @@ -512,9 +508,7 @@ def is_right(self, other: Union[Time, Temporal, Box]) -> bool: from ...boxes import Box if isinstance(other, datetime): - return before_timestamptz_set( - datetime_to_timestamptz(other), self._inner - ) + return before_timestamptz_set(datetime_to_timestamptz(other), self._inner) elif isinstance(other, Temporal): return self.to_span().is_right(other) elif isinstance(other, get_args(Box)): @@ -632,9 +626,7 @@ def minus(self, other: Union[Time, Temporal, Box]) -> Optional[Time]: from .tstzspanset import TsTzSpanSet if isinstance(other, datetime): - result = minus_set_timestamptz( - self._inner, datetime_to_timestamptz(other) - ) + result = minus_set_timestamptz(self._inner, datetime_to_timestamptz(other)) return TsTzSet(_inner=result) if result is not None else None elif isinstance(other, TsTzSet): result = minus_set_set(self._inner, other._inner) @@ -678,9 +670,7 @@ def union(self, other: Union[datetime, TsTzSet]) -> TsTzSet: def union(self, other: Union[TsTzSpan, TsTzSpanSet, Temporal, Box]) -> TsTzSpanSet: ... - def union( - self, other: Union[Time, Temporal, Box] - ) -> Union[TsTzSpanSet, TsTzSet]: + def union(self, other: Union[Time, Temporal, Box]) -> Union[TsTzSpanSet, TsTzSet]: """ Returns the temporal union of ``self`` and ``other``. diff --git a/pymeos/pymeos/collections/time/tstzspan.py b/pymeos/pymeos/collections/time/tstzspan.py index dc1f8fd1..8544c94b 100644 --- a/pymeos/pymeos/collections/time/tstzspan.py +++ b/pymeos/pymeos/collections/time/tstzspan.py @@ -563,9 +563,7 @@ def intersection(self, other: TsTzSpan) -> Optional[TsTzSpan]: ... @overload - def intersection( - self, other: Union[TsTzSet, TsTzSpanSet] - ) -> Optional[TsTzSpanSet]: + def intersection(self, other: Union[TsTzSet, TsTzSpanSet]) -> Optional[TsTzSpanSet]: ... def intersection(self, other: Time) -> Optional[Time]: diff --git a/pymeos/pymeos/main/tint.py b/pymeos/pymeos/main/tint.py index c71baab8..bb3c4b30 100644 --- a/pymeos/pymeos/main/tint.py +++ b/pymeos/pymeos/main/tint.py @@ -85,7 +85,9 @@ def from_base_time(value: int, base: Time) -> TInt: elif isinstance(base, TsTzSpan): return TIntSeq(_inner=tintseq_from_base_tstzspan(value, base._inner)) elif isinstance(base, TsTzSpanSet): - return TIntSeqSet(_inner=tintseqset_from_base_tstzspanset(value, base._inner)) + return TIntSeqSet( + _inner=tintseqset_from_base_tstzspanset(value, base._inner) + ) raise TypeError(f"Operation not supported with type {base.__class__}") # ------------------------- Output ---------------------------------------- diff --git a/pymeos/pymeos/plotters/box_plotter.py b/pymeos/pymeos/plotters/box_plotter.py index 85bb88cb..009e0e00 100644 --- a/pymeos/pymeos/plotters/box_plotter.py +++ b/pymeos/pymeos/plotters/box_plotter.py @@ -32,7 +32,9 @@ def plot_tbox(tbox: TBox, *args, axes=None, **kwargs): tbox.to_floatspan(), *args, axes=axes, **kwargs ) if not tbox.has_x: - return TimePlotter.plot_tstzspan(tbox.to_tstzspan(), *args, axes=axes, **kwargs) + return TimePlotter.plot_tstzspan( + tbox.to_tstzspan(), *args, axes=axes, **kwargs + ) return BoxPlotter._plot_box( tbox.tmin(), tbox.tmax(), diff --git a/pymeos/pymeos/temporal/temporal.py b/pymeos/pymeos/temporal/temporal.py index 50a28034..c526d061 100644 --- a/pymeos/pymeos/temporal/temporal.py +++ b/pymeos/pymeos/temporal/temporal.py @@ -34,9 +34,7 @@ def import_pandas(): Self = TypeVar("Self", bound="Temporal[Any]") -class Temporal( - Generic[TBase, TG, TI, TS, TSS], TComparable, TTemporallyEquatable, ABC -): +class Temporal(Generic[TBase, TG, TI, TS, TSS], TComparable, TTemporallyEquatable, ABC): """ Abstract class for representing temporal values of any subtype. """ @@ -820,7 +818,9 @@ def at(self, other: Time) -> TG: temporal_at_tstzspan, temporal_at_tstzspanset """ if isinstance(other, datetime): - result = temporal_at_timestamptz(self._inner, datetime_to_timestamptz(other)) + result = temporal_at_timestamptz( + self._inner, datetime_to_timestamptz(other) + ) elif isinstance(other, TsTzSet): result = temporal_at_tstzset(self._inner, other._inner) elif isinstance(other, TsTzSpan): diff --git a/pymeos/tests/boxes/tbox_test.py b/pymeos/tests/boxes/tbox_test.py index c654fd40..1bc387e6 100644 --- a/pymeos/tests/boxes/tbox_test.py +++ b/pymeos/tests/boxes/tbox_test.py @@ -151,11 +151,11 @@ def test_from_value_constructor(self, value, expected): "TBOX T([2019-09-01 00:00:00+00, 2019-09-02 00:00:00+00])", ), ( - TsTzSpan("[2019-09-01, 2019-09-02]"), + TsTzSpan("[2019-09-01, 2019-09-02]"), "TBOX T([2019-09-01 00:00:00+00, 2019-09-02 00:00:00+00])", ), ( - TsTzSpanSet("{[2019-09-01, 2019-09-02],[2019-09-03, 2019-09-05]}"), + TsTzSpanSet("{[2019-09-01, 2019-09-02],[2019-09-03, 2019-09-05]}"), "TBOX T([2019-09-01 00:00:00+00, 2019-09-05 00:00:00+00])", ), ], @@ -190,23 +190,23 @@ def test_from_time_constructor(self, time, expected): "TBOXFLOAT XT([1.5, 2.5],[2019-09-01 00:00:00+00, 2019-09-01 00:00:00+00])", ), ( - 1, - TsTzSpan("[2019-09-01, 2019-09-02]"), + 1, + TsTzSpan("[2019-09-01, 2019-09-02]"), "TBOXINT XT([1, 2),[2019-09-01 00:00:00+00, 2019-09-02 00:00:00+00])", ), ( - 1.5, - TsTzSpan("[2019-09-01, 2019-09-02]"), + 1.5, + TsTzSpan("[2019-09-01, 2019-09-02]"), "TBOXFLOAT XT([1.5, 1.5],[2019-09-01 00:00:00+00, 2019-09-02 00:00:00+00])", ), ( - IntSpan(lower=1, upper=2, lower_inc=True, upper_inc=True), - TsTzSpan("[2019-09-01, 2019-09-02]"), + IntSpan(lower=1, upper=2, lower_inc=True, upper_inc=True), + TsTzSpan("[2019-09-01, 2019-09-02]"), "TBOXINT XT([1, 3),[2019-09-01 00:00:00+00, 2019-09-02 00:00:00+00])", ), ( - FloatSpan(lower=1.5, upper=2.5, lower_inc=True, upper_inc=True), - TsTzSpan("[2019-09-01, 2019-09-02]"), + FloatSpan(lower=1.5, upper=2.5, lower_inc=True, upper_inc=True), + TsTzSpan("[2019-09-01, 2019-09-02]"), "TBOXFLOAT XT([1.5, 2.5],[2019-09-01 00:00:00+00, 2019-09-02 00:00:00+00])", ), ], diff --git a/pymeos/tests/collections/time/dateset_test.py b/pymeos/tests/collections/time/dateset_test.py new file mode 100644 index 00000000..829f36df --- /dev/null +++ b/pymeos/tests/collections/time/dateset_test.py @@ -0,0 +1,297 @@ +from copy import copy +from datetime import date, timezone, timedelta +from typing import List + +import pytest + +from pymeos import ( + DateSpan, + DateSpanSet, + DateSet, +) +from tests.conftest import TestPyMEOS + + +class TestDateSet(TestPyMEOS): + date_set = DateSet("{2019-09-25, 2019-09-26, 2019-09-27}") + + +class TestDateSetConstructors(TestDateSet): + def test_string_constructor(self): + assert isinstance(self.date_set, DateSet) + assert self.date_set.elements() == [ + date(2019, 9, 25), + date(2019, 9, 26), + date(2019, 9, 27), + ] + + def test_list_constructor(self): + d_set = DateSet( + elements=[ + date(2019, 9, 25), + date(2019, 9, 26), + date(2019, 9, 27), + ] + ) + assert self.date_set == d_set + + def test_from_as_constructor(self): + assert self.date_set == DateSet(str(self.date_set)) + assert self.date_set == DateSet.from_wkb(self.date_set.as_wkb()) + assert self.date_set == DateSet.from_hexwkb(self.date_set.as_hexwkb()) + + def test_copy_constructor(self): + date_set_copy = copy(self.date_set) + assert self.date_set == date_set_copy + assert self.date_set is not date_set_copy + + +class TestDateSetOutputs(TestDateSet): + def test_str(self): + assert str(self.date_set) == '{"2019-09-25", "2019-09-26", "2019-09-27"}' + + def test_repr(self): + assert ( + repr(self.date_set) == 'TsTzSet({"2019-09-25", "2019-09-26", "2019-09-27"})' + ) + + def test_as_hexwkb(self): + assert self.date_set == DateSet.from_hexwkb(self.date_set.as_hexwkb()) + + +class TestCollectionConversions(TestDateSet): + def test_to_span(self): + assert self.date_set.to_span() == DateSpan("[2019-09-01, 2019-09-03]") + + def test_to_spanset(self): + assert self.date_set.to_spanset() == DateSpanSet( + "{[2019-09-01, 2019-09-01], " + "[2019-09-02, 2019-09-02], " + "[2019-09-03, 2019-09-03]}" + ) + + +class TestDateSetAccessors(TestDateSet): + def test_duration(self): + assert self.date_set.duration() == timedelta(days=2) + + def test_num_elements(self): + assert self.date_set.num_elements() == 3 + assert len(self.date_set) == 3 + + def test_start_element(self): + assert self.date_set.start_element() == date(2019, 9, 1) + + def test_end_element(self): + assert self.date_set.end_element() == date(2019, 9, 3) + + def test_element_n(self): + assert self.date_set.element_n(1) == date(2019, 9, 2) + + def test_element_n_out_of_range(self): + with pytest.raises(IndexError): + self.date_set.element_n(3) + + def test_elements(self): + assert self.date_set.elements() == [ + date(2019, 9, 1), + date(2019, 9, 2), + date(2019, 9, 3), + ] + + +class TestDateSetPositionFunctions(TestDateSet): + date_value = date(year=2020, month=1, day=1) + other_date_set = DateSet("{2020-01-01, 2020-01-31}") + + @pytest.mark.parametrize("other, expected", [(other_date_set, False)], ids=["tstzset"]) + def test_is_contained_in(self, other, expected): + assert self.date_set.is_contained_in(other) == expected + + @pytest.mark.parametrize( + "other", [timestamp, tstzset], ids=["timestamp", "tstzset"] + ) + def test_contains(self, other): + self.date_set.contains(other) + _ = other in self.tstzset + + @pytest.mark.parametrize("other", [tstzset], ids=["tstzset"]) + def test_overlaps(self, other): + self.date_set.overlaps(other) + + @pytest.mark.parametrize( + "other", [timestamp, tstzset], ids=["timestamp", "tstzset"] + ) + def test_is_before(self, other): + self.date_set.is_before(other) + + @pytest.mark.parametrize( + "other", [timestamp, tstzset], ids=["timestamp", "tstzset"] + ) + def test_is_over_or_before(self, other): + self.date_set.is_over_or_before(other) + + @pytest.mark.parametrize( + "other", [timestamp, tstzset], ids=["timestamp", "tstzset"] + ) + def test_is_after(self, other): + self.date_set.is_after(other) + + @pytest.mark.parametrize( + "other", [timestamp, tstzset], ids=["timestamp", "tstzset"] + ) + def test_is_over_or_after(self, other): + self.date_set.is_over_or_after(other) + + @pytest.mark.parametrize( + "other", [timestamp, tstzset], ids=["timestamp", "tstzset"] + ) + def test_distance(self, other): + self.date_set.distance(other) + + +class TestDateSetSetFunctions(TestDateSet): + timestamp = datetime(year=2020, month=1, day=1) + tstzset = TsTzSet("{2020-01-01, 2020-01-31}") + tstzspan = TsTzSpan("(2020-01-01, 2020-01-31)") + tstzspanset = TsTzSpanSet("{(2020-01-01, 2020-01-31), (2021-01-01, 2021-01-31)}") + + @pytest.mark.parametrize( + "other", + [tstzspan, tstzspanset, timestamp, tstzset], + ids=["tstzspan", "tstzspanset", "timestamp", "tstzset"], + ) + def test_intersection(self, other): + self.tstzset.intersection(other) + self.tstzset * other + + @pytest.mark.parametrize( + "other", + [tstzspan, tstzspanset, timestamp, tstzset], + ids=["tstzspan", "tstzspanset", "timestamp", "tstzset"], + ) + def test_union(self, other): + self.tstzset.union(other) + self.tstzset + other + + @pytest.mark.parametrize( + "other", + [tstzspan, tstzspanset, timestamp, tstzset], + ids=["tstzspan", "tstzspanset", "timestamp", "tstzset"], + ) + def test_minus(self, other): + self.tstzset.minus(other) + self.tstzset - other + + +class TestDateSetComparisons(TestDateSet): + tstzset = TsTzSet("{2020-01-01, 2020-01-31}") + other = TsTzSet("{2020-01-02, 2020-03-31}") + + def test_eq(self): + _ = self.tstzset == self.other + + def test_ne(self): + _ = self.tstzset != self.other + + def test_lt(self): + _ = self.tstzset < self.other + + def test_le(self): + _ = self.tstzset <= self.other + + def test_gt(self): + _ = self.tstzset > self.other + + def test_ge(self): + _ = self.tstzset >= self.other + + +class TestDateSetFunctionsFunctions(TestDateSet): + tstzset = TsTzSet("{2020-01-01, 2020-01-02, 2020-01-04}") + + @pytest.mark.parametrize( + "delta,result", + [ + ( + timedelta(days=4), + [ + datetime(2020, 1, 5, tzinfo=timezone.utc), + datetime(2020, 1, 6, tzinfo=timezone.utc), + datetime(2020, 1, 8, tzinfo=timezone.utc), + ], + ), + ( + timedelta(days=-4), + [ + datetime(2019, 12, 28, tzinfo=timezone.utc), + datetime(2019, 12, 29, tzinfo=timezone.utc), + datetime(2019, 12, 31, tzinfo=timezone.utc), + ], + ), + ( + timedelta(hours=2), + [ + datetime(2020, 1, 1, 2, tzinfo=timezone.utc), + datetime(2020, 1, 2, 2, tzinfo=timezone.utc), + datetime(2020, 1, 4, 2, tzinfo=timezone.utc), + ], + ), + ( + timedelta(hours=-2), + [ + datetime(2019, 12, 31, 22, tzinfo=timezone.utc), + datetime(2020, 1, 1, 22, tzinfo=timezone.utc), + datetime(2020, 1, 3, 22, tzinfo=timezone.utc), + ], + ), + ], + ids=["positive days", "negative days", "positive hours", "negative hours"], + ) + def test_shift(self, delta, result): + shifted = self.tstzset.shift(delta) + self.assert_tstzset_equality(shifted, result) + + @pytest.mark.parametrize( + "delta,result", + [ + ( + timedelta(days=6), + [ + datetime(2020, 1, 1, tzinfo=timezone.utc), + datetime(2020, 1, 3, tzinfo=timezone.utc), + datetime(2020, 1, 7, tzinfo=timezone.utc), + ], + ), + ( + timedelta(hours=3), + [ + datetime(2020, 1, 1, tzinfo=timezone.utc), + datetime(2020, 1, 1, 1, tzinfo=timezone.utc), + datetime(2020, 1, 1, 3, tzinfo=timezone.utc), + ], + ), + ], + ids=["days", "hours"], + ) + def test_scale(self, delta, result): + scaled = self.tstzset.scale(delta) + self.assert_tstzset_equality(scaled, result) + + def test_shift_scale(self): + shifted_scaled = self.tstzset.shift_scale(timedelta(days=4), timedelta(hours=3)) + self.assert_tstzset_equality( + shifted_scaled, + [ + datetime(2020, 1, 5, tzinfo=timezone.utc), + datetime(2020, 1, 5, 1, tzinfo=timezone.utc), + datetime(2020, 1, 5, 3, tzinfo=timezone.utc), + ], + ) + + +class TestDateSetMiscFunctions(TestDateSet): + dateset = DateSet("{2020-01-01, 2020-01-02, 2020-01-04}") + + def test_hash(self): + assert hash(self.dateset) diff --git a/pymeos/tests/collections/time/tstzspan_test.py b/pymeos/tests/collections/time/tstzspan_test.py index 478a3357..54721ed9 100644 --- a/pymeos/tests/collections/time/tstzspan_test.py +++ b/pymeos/tests/collections/time/tstzspan_test.py @@ -89,11 +89,13 @@ def test_string_constructor(self, source, params): ids=["string", "datetime", "mixed"], ) def test_constructor_bounds(self, input_lower, input_upper, lower, upper): - tstzspan = TsTzSpan(lower=lower, upper=upper) + tstzspan = TsTzSpan(lower=input_lower, upper=input_upper) self.assert_tstzspan_equality(tstzspan, lower, upper) def test_constructor_bound_inclusivity_defaults(self): - tstzspan = TsTzSpan(lower="2019-09-08 00:00:00+0", upper="2019-09-10 00:00:00+0") + tstzspan = TsTzSpan( + lower="2019-09-08 00:00:00+0", upper="2019-09-10 00:00:00+0" + ) self.assert_tstzspan_equality(tstzspan, lower_inc=True, upper_inc=False) @pytest.mark.parametrize( @@ -158,7 +160,9 @@ def test_lower(self): def test_upper(self): assert self.tstzspan.upper() == datetime(2019, 9, 10, tzinfo=timezone.utc) - assert self.tstzspan2.upper() == datetime(2019, 9, 10, 2, 3, tzinfo=timezone.utc) + assert self.tstzspan2.upper() == datetime( + 2019, 9, 10, 2, 3, tzinfo=timezone.utc + ) def test_lower_inc(self): assert not self.tstzspan.lower_inc() @@ -256,7 +260,9 @@ def test_scale(self, delta, result): self.assert_tstzspan_equality(scaled, *result) def test_shift_scale(self): - shifted_scaled = self.tstzspan.shift_scale(timedelta(days=4), timedelta(hours=4)) + shifted_scaled = self.tstzspan.shift_scale( + timedelta(days=4), timedelta(hours=4) + ) self.assert_tstzspan_equality( shifted_scaled, datetime(2019, 9, 12, 0, tzinfo=timezone.utc), diff --git a/pymeos/tests/main/tbool_test.py b/pymeos/tests/main/tbool_test.py index b5fe624c..908a3348 100644 --- a/pymeos/tests/main/tbool_test.py +++ b/pymeos/tests/main/tbool_test.py @@ -71,9 +71,9 @@ def test_from_base_constructor(self, source, type, interpolation): ), (TsTzSpan("[2019-09-01, 2019-09-02]"), TBoolSeq, TInterpolation.STEPWISE), ( - TsTzSpanSet("{[2019-09-01, 2019-09-02],[2019-09-03, 2019-09-05]}"), - TBoolSeqSet, - TInterpolation.STEPWISE, + TsTzSpanSet("{[2019-09-01, 2019-09-02],[2019-09-03, 2019-09-05]}"), + TBoolSeqSet, + TInterpolation.STEPWISE, ), ], ids=["Instant", "Discrete Sequence", "Sequence", "SequenceSet"], @@ -1739,7 +1739,8 @@ def test_minus_min(self, temporal, expected): ) def test_at_minus(self, temporal, restrictor): assert ( - TBool.from_merge(temporal.at(restrictor), temporal.minus(restrictor)) == temporal + TBool.from_merge(temporal.at(restrictor), temporal.minus(restrictor)) + == temporal ) @pytest.mark.parametrize( diff --git a/pymeos/tests/main/tfloat_test.py b/pymeos/tests/main/tfloat_test.py index c275828d..d46b4aa0 100644 --- a/pymeos/tests/main/tfloat_test.py +++ b/pymeos/tests/main/tfloat_test.py @@ -80,9 +80,9 @@ def test_from_base_constructor(self, source, type, interpolation): ), (TsTzSpan("[2019-09-01, 2019-09-02]"), TFloatSeq, TInterpolation.LINEAR), ( - TsTzSpanSet("{[2019-09-01, 2019-09-02],[2019-09-03, 2019-09-05]}"), - TFloatSeqSet, - TInterpolation.LINEAR, + TsTzSpanSet("{[2019-09-01, 2019-09-02],[2019-09-03, 2019-09-05]}"), + TFloatSeqSet, + TInterpolation.LINEAR, ), ], ids=["Instant", "Sequence", "Discrete Sequence", "SequenceSet"], diff --git a/pymeos/tests/main/tgeogpoint_test.py b/pymeos/tests/main/tgeogpoint_test.py index f0f1da93..a8d1fcf5 100644 --- a/pymeos/tests/main/tgeogpoint_test.py +++ b/pymeos/tests/main/tgeogpoint_test.py @@ -97,11 +97,15 @@ def test_from_base_constructor(self, source, type, interpolation): TGeogPointSeq, TInterpolation.DISCRETE, ), - (TsTzSpan("[2019-09-01, 2019-09-02]"), TGeogPointSeq, TInterpolation.LINEAR), ( - TsTzSpanSet("{[2019-09-01, 2019-09-02],[2019-09-03, 2019-09-05]}"), - TGeogPointSeqSet, - TInterpolation.LINEAR, + TsTzSpan("[2019-09-01, 2019-09-02]"), + TGeogPointSeq, + TInterpolation.LINEAR, + ), + ( + TsTzSpanSet("{[2019-09-01, 2019-09-02],[2019-09-03, 2019-09-05]}"), + TGeogPointSeqSet, + TInterpolation.LINEAR, ), ], ids=["Instant", "Sequence", "Discrete Sequence", "SequenceSet"], @@ -2276,8 +2280,12 @@ def test_at_minus(self, temporal, restrictor): ids=["Instant", "Discrete Sequence", "Sequence", "SequenceSet"], ) def test_at_minus_min_max(self, temporal): - assert TGeogPoint.from_merge(temporal.at_min(), temporal.minus_min()) == temporal - assert TGeogPoint.from_merge(temporal.at_max(), temporal.minus_max()) == temporal + assert ( + TGeogPoint.from_merge(temporal.at_min(), temporal.minus_min()) == temporal + ) + assert ( + TGeogPoint.from_merge(temporal.at_max(), temporal.minus_max()) == temporal + ) class TestTGeogPointEverSpatialOperations(TestTGeogPoint): diff --git a/pymeos/tests/main/tgeompoint_test.py b/pymeos/tests/main/tgeompoint_test.py index 84b90099..6ee9440e 100644 --- a/pymeos/tests/main/tgeompoint_test.py +++ b/pymeos/tests/main/tgeompoint_test.py @@ -90,11 +90,15 @@ def test_from_base_constructor(self, source, type, interpolation): TGeomPointSeq, TInterpolation.DISCRETE, ), - (TsTzSpan("[2019-09-01, 2019-09-02]"), TGeomPointSeq, TInterpolation.LINEAR), ( - TsTzSpanSet("{[2019-09-01, 2019-09-02],[2019-09-03, 2019-09-05]}"), - TGeomPointSeqSet, - TInterpolation.LINEAR, + TsTzSpan("[2019-09-01, 2019-09-02]"), + TGeomPointSeq, + TInterpolation.LINEAR, + ), + ( + TsTzSpanSet("{[2019-09-01, 2019-09-02],[2019-09-03, 2019-09-05]}"), + TGeomPointSeqSet, + TInterpolation.LINEAR, ), ], ids=["Instant", "Sequence", "Discrete Sequence", "SequenceSet"], @@ -2412,8 +2416,12 @@ def test_at_minus(self, temporal, restrictor): ids=["Instant", "Discrete Sequence", "Sequence", "SequenceSet"], ) def test_at_minus_min_max(self, temporal): - assert TGeomPoint.from_merge(temporal.at_min(), temporal.minus_min()) == temporal - assert TGeomPoint.from_merge(temporal.at_max(), temporal.minus_max()) == temporal + assert ( + TGeomPoint.from_merge(temporal.at_min(), temporal.minus_min()) == temporal + ) + assert ( + TGeomPoint.from_merge(temporal.at_max(), temporal.minus_max()) == temporal + ) class TestTGeomPointTopologicalFunctions(TestTGeomPoint): diff --git a/pymeos/tests/main/ttext_test.py b/pymeos/tests/main/ttext_test.py index b392601d..f41bc756 100644 --- a/pymeos/tests/main/ttext_test.py +++ b/pymeos/tests/main/ttext_test.py @@ -76,9 +76,9 @@ def test_from_base_temporal_constructor(self, source, type, interpolation): ), (TsTzSpan("[2019-09-01, 2019-09-02]"), TTextSeq, TInterpolation.STEPWISE), ( - TsTzSpanSet("{[2019-09-01, 2019-09-02],[2019-09-03, 2019-09-05]}"), - TTextSeqSet, - TInterpolation.STEPWISE, + TsTzSpanSet("{[2019-09-01, 2019-09-02],[2019-09-03, 2019-09-05]}"), + TTextSeqSet, + TInterpolation.STEPWISE, ), ], ids=["Instant", "Discrete Sequence", "Sequence", "SequenceSet"], @@ -1710,7 +1710,8 @@ def test_minus_max(self, temporal, expected): ) def test_at_minus(self, temporal, restrictor): assert ( - TText.from_merge(temporal.at(restrictor), temporal.minus(restrictor)) == temporal + TText.from_merge(temporal.at(restrictor), temporal.minus(restrictor)) + == temporal ) @pytest.mark.parametrize( diff --git a/pymeos_cffi/pymeos_cffi/__init__.py b/pymeos_cffi/pymeos_cffi/__init__.py index b40451db..42d7e3ed 100644 --- a/pymeos_cffi/pymeos_cffi/__init__.py +++ b/pymeos_cffi/pymeos_cffi/__init__.py @@ -34,1909 +34,1910 @@ "InterpolationType", "SpatialRelation", # Functions - "py_error_handler", - "create_pointer", - "get_address", - "datetime_to_timestamptz", - "timestamptz_to_datetime", - "date_to_date_adt", - "date_adt_to_date", - "timedelta_to_interval", - "interval_to_timedelta", - "geo_to_gserialized", - "geometry_to_gserialized", - "geography_to_gserialized", - "gserialized_to_shapely_point", - "gserialized_to_shapely_geometry", - "as_tinstant", - "as_tsequence", - "as_tsequenceset", - "lwpoint_make", - "lwgeom_from_gserialized", - "gserialized_from_lwgeom", - "lwgeom_get_srid", - "lwpoint_get_x", - "lwpoint_get_y", - "lwpoint_get_z", - "lwpoint_get_m", - "lwgeom_has_z", - "lwgeom_has_m", - "meos_errno", - "meos_errno_set", - "meos_errno_restore", - "meos_errno_reset", - "meos_set_datestyle", - "meos_set_intervalstyle", - "meos_get_datestyle", - "meos_get_intervalstyle", - "meos_initialize", - "meos_finalize", - "bool_in", - "bool_out", - "cstring2text", - "pg_date_in", - "pg_date_out", - "pg_date_mi", - "pg_date_mi_int", - "pg_date_pl_int", - "pg_date_timestamptz", - "pg_interval_cmp", - "pg_interval_in", - "pg_interval_make", - "pg_interval_mul", - "pg_interval_out", - "pg_interval_to_char", - "pg_interval_pl", - "pg_time_in", - "pg_time_out", - "pg_timestamp_in", - "pg_timestamp_mi", - "pg_timestamp_mi_interval", - "pg_timestamp_out", - "pg_timestamp_pl_interval", - "pg_timestamp_to_char", - "pg_timestamptz_in", - "pg_timestamptz_date", - "pg_timestamptz_out", - "pg_timestamptz_to_char", - "pg_to_date", - "pg_to_timestamptz", - "text2cstring", - "text_out", - "geography_from_hexewkb", - "geography_from_text", - "geometry_from_hexewkb", - "geometry_from_text", - "gserialized_as_ewkb", - "gserialized_as_ewkt", - "gserialized_as_geojson", - "gserialized_as_hexewkb", - "gserialized_as_text", - "gserialized_from_ewkb", - "gserialized_from_geojson", - "gserialized_out", - "pgis_geography_in", - "pgis_geometry_in", - "pgis_gserialized_same", - "bigintset_in", - "bigintset_out", - "bigintspan_in", - "bigintspan_out", - "bigintspanset_in", - "bigintspanset_out", - "dateset_in", - "dateset_out", - "datespan_in", - "datespan_out", - "datespanset_in", - "datespanset_out", - "floatset_in", - "floatset_out", - "floatspan_in", - "floatspan_out", - "floatspanset_in", - "floatspanset_out", - "geogset_in", - "geomset_in", - "geoset_as_ewkt", - "geoset_as_text", - "geoset_out", - "intset_in", - "intset_out", - "intspan_in", - "intspan_out", - "intspanset_in", - "intspanset_out", - "set_as_hexwkb", - "set_as_wkb", - "set_from_hexwkb", - "set_from_wkb", - "span_as_hexwkb", - "span_as_wkb", - "span_from_hexwkb", - "span_from_wkb", - "spanset_as_hexwkb", - "spanset_as_wkb", - "spanset_from_hexwkb", - "spanset_from_wkb", - "textset_in", - "textset_out", - "tstzset_in", - "tstzset_out", - "tstzspan_in", - "tstzspan_out", - "tstzspanset_in", - "tstzspanset_out", - "bigintset_make", - "bigintspan_make", - "dateset_make", - "datespan_make", - "floatset_make", - "floatspan_make", - "geoset_make", - "intset_make", - "intspan_make", - "set_copy", - "span_copy", - "spanset_copy", - "spanset_make", - "textset_make", - "tstzset_make", - "tstzspan_make", - "bigint_to_set", - "bigint_to_span", - "bigint_to_spanset", - "date_to_set", - "date_to_span", - "date_to_spanset", - "date_to_tstzspan", - "float_to_set", - "float_to_span", - "float_to_spanset", - "geo_to_set", - "int_to_set", - "int_to_span", - "int_to_spanset", - "set_to_spanset", - "span_to_spanset", - "text_to_set", - "timestamptz_to_set", - "timestamptz_to_span", - "timestamptz_to_spanset", - "bigintset_end_value", - "bigintset_start_value", - "bigintset_value_n", - "bigintset_values", - "bigintspan_lower", - "bigintspan_upper", - "bigintspanset_lower", - "bigintspanset_upper", - "dateset_end_value", - "dateset_start_value", - "dateset_value_n", - "dateset_values", - "datespan_duration", - "datespan_lower", - "datespan_upper", - "datespanset_duration", - "datespanset_end_date", - "datespanset_num_dates", - "datespanset_start_date", - "datespanset_date_n", - "datespanset_dates", - "floatset_end_value", - "floatset_start_value", - "floatset_value_n", - "floatset_values", - "floatspan_lower", - "floatspan_upper", - "floatspanset_lower", - "floatspanset_upper", - "geoset_end_value", - "geoset_srid", - "geoset_set_srid", - "geoset_start_value", - "geoset_value_n", - "geoset_values", - "intset_end_value", - "intset_start_value", - "intset_value_n", - "intset_values", - "intspan_lower", - "intspan_upper", - "intspanset_lower", - "intspanset_upper", - "set_hash", - "set_hash_extended", - "set_num_values", - "set_to_span", - "span_hash", - "span_hash_extended", - "span_lower_inc", - "span_upper_inc", - "span_width", - "spanset_end_span", - "spanset_hash", - "spanset_hash_extended", - "spanset_lower_inc", - "spanset_num_spans", - "spanset_span", - "spanset_span_n", - "spanset_spans", - "spanset_start_span", - "spanset_upper_inc", - "spanset_width", - "spatialset_to_stbox", - "textset_end_value", - "textset_start_value", - "textset_value_n", - "textset_values", - "tstzset_end_value", - "tstzset_start_value", - "tstzset_value_n", - "tstzset_values", - "tstzspan_duration", - "tstzspan_lower", - "tstzspan_upper", - "tstzspanset_duration", - "tstzspanset_end_timestamptz", - "tstzspanset_lower", - "tstzspanset_num_timestamps", - "tstzspanset_start_timestamptz", - "tstzspanset_timestamptz_n", - "tstzspanset_timestamps", - "tstzspanset_upper", - "bigintset_shift_scale", - "bigintspan_shift_scale", - "bigintspanset_shift_scale", - "dateset_shift_scale", - "dateset_to_tstzset", - "datespan_shift_scale", - "datespan_to_tstzspan", - "datespanset_shift_scale", - "datespanset_to_tstzspanset", - "floatset_round", - "floatset_shift_scale", - "floatset_to_intset", - "floatspan_round", - "floatspan_shift_scale", - "floatspan_to_intspan", - "floatspanset_to_intspanset", - "floatspanset_round", - "floatspanset_shift_scale", - "geoset_round", - "intset_shift_scale", - "intset_to_floatset", - "intspan_shift_scale", - "intspan_to_floatspan", - "intspanset_to_floatspanset", - "intspanset_shift_scale", - "textset_lower", - "textset_upper", - "timestamptz_tprecision", - "tstzset_shift_scale", - "datespan_shift_scale", - "tstzspan_shift_scale", - "tstzspan_tprecision", - "tstzset_to_dateset", - "tstzspan_to_datespan", - "tstzspanset_to_datespanset", - "tstzspanset_shift_scale", - "tstzspanset_tprecision", - "intersection_set_bigint", - "intersection_set_date", - "intersection_set_float", - "intersection_set_geo", - "intersection_set_int", - "intersection_set_set", - "intersection_set_text", - "intersection_set_timestamptz", - "intersection_span_bigint", - "intersection_span_date", - "intersection_span_float", - "intersection_span_int", - "intersection_span_timestamptz", - "intersection_span_span", - "intersection_spanset_bigint", - "intersection_spanset_date", - "intersection_spanset_float", - "intersection_spanset_int", - "intersection_spanset_span", - "intersection_spanset_spanset", - "intersection_spanset_timestamptz", - "minus_bigint_set", - "minus_bigint_span", - "minus_bigint_spanset", - "minus_date_set", - "minus_date_span", - "minus_date_spanset", - "minus_float_set", - "minus_float_span", - "minus_float_spanset", - "minus_geo_set", - "minus_int_set", - "minus_int_span", - "minus_int_spanset", - "minus_set_bigint", - "minus_set_date", - "minus_set_float", - "minus_set_geo", - "minus_set_int", - "minus_set_set", - "minus_set_text", - "minus_set_timestamptz", - "minus_span_bigint", - "minus_span_date", - "minus_span_float", - "minus_span_int", - "minus_span_span", - "minus_span_spanset", - "minus_span_timestamptz", - "minus_spanset_bigint", - "minus_spanset_date", - "minus_spanset_float", - "minus_spanset_int", - "minus_spanset_span", - "minus_spanset_spanset", - "minus_spanset_timestamptz", - "minus_text_set", - "minus_timestamptz_span", - "minus_timestamptz_spanset", - "minus_timestamptz_set", - "super_union_span_span", - "union_set_bigint", - "union_set_date", - "union_set_float", - "union_set_geo", - "union_set_int", - "union_set_set", - "union_set_text", - "union_set_timestamptz", - "union_span_bigint", - "union_span_date", - "union_span_float", - "union_span_int", - "union_span_span", - "union_span_timestamptz", - "union_spanset_bigint", - "union_spanset_date", - "union_spanset_float", - "union_spanset_int", - "union_spanset_span", - "union_spanset_spanset", - "union_spanset_timestamptz", - "adjacent_span_bigint", - "adjacent_span_date", - "adjacent_span_float", - "adjacent_span_int", - "adjacent_span_span", - "adjacent_span_timestamptz", - "adjacent_spanset_bigint", - "adjacent_spanset_date", - "adjacent_spanset_float", - "adjacent_spanset_int", - "adjacent_spanset_timestamptz", - "adjacent_spanset_span", - "adjacent_spanset_spanset", - "contained_bigint_set", - "contained_bigint_span", - "contained_bigint_spanset", - "contained_date_set", - "contained_date_span", - "contained_date_spanset", - "contained_float_set", - "contained_float_span", - "contained_float_spanset", - "contained_geo_set", - "contained_int_set", - "contained_int_span", - "contained_int_spanset", - "contained_set_set", - "contained_span_span", - "contained_span_spanset", - "contained_spanset_span", - "contained_spanset_spanset", - "contained_text_set", - "contained_timestamptz_set", - "contained_timestamptz_span", - "contained_timestamptz_spanset", - "contains_set_bigint", - "contains_set_date", - "contains_set_float", - "contains_set_geo", - "contains_set_int", - "contains_set_set", - "contains_set_text", - "contains_set_timestamptz", - "contains_span_bigint", - "contains_span_float", - "contains_span_int", - "contains_span_span", - "contains_span_spanset", - "contains_span_timestamptz", - "contains_span_date", - "contains_spanset_bigint", - "contains_spanset_float", - "contains_spanset_int", - "contains_spanset_span", - "contains_spanset_spanset", - "contains_spanset_timestamptz", - "contains_spanset_date", - "overlaps_set_set", - "overlaps_span_span", - "overlaps_spanset_span", - "overlaps_spanset_spanset", - "after_date_set", - "after_date_span", - "after_date_spanset", - "after_set_date", - "after_set_timestamptz", - "after_span_date", - "after_span_timestamptz", - "after_spanset_date", - "after_spanset_timestamptz", - "after_timestamptz_set", - "after_timestamptz_span", - "after_timestamptz_spanset", - "before_date_set", - "before_date_span", - "before_date_spanset", - "before_set_date", - "before_set_timestamptz", - "before_span_date", - "before_span_timestamptz", - "before_spanset_date", - "before_spanset_timestamptz", - "before_timestamptz_set", - "before_timestamptz_span", - "before_timestamptz_spanset", - "left_bigint_set", - "left_bigint_span", - "left_bigint_spanset", - "left_float_set", - "left_float_span", - "left_float_spanset", - "left_int_set", - "left_int_span", - "left_int_spanset", - "left_set_bigint", - "left_set_float", - "left_set_int", - "left_set_set", - "left_set_text", - "left_span_bigint", - "left_span_float", - "left_span_int", - "left_span_span", - "left_span_spanset", - "left_spanset_bigint", - "left_spanset_float", - "left_spanset_int", - "left_spanset_span", - "left_spanset_spanset", - "left_text_set", - "overafter_set_date", - "overafter_set_timestamptz", - "overafter_span_timestamptz", - "overafter_span_date", - "overafter_spanset_timestamptz", - "overafter_spanset_date", - "overafter_timestamptz_set", - "overafter_timestamptz_span", - "overafter_timestamptz_spanset", - "overbefore_set_date", - "overbefore_set_timestamptz", - "overbefore_span_timestamptz", - "overbefore_span_date", - "overbefore_spanset_timestamptz", - "overbefore_spanset_date", - "overbefore_timestamptz_set", - "overbefore_timestamptz_span", - "overbefore_timestamptz_spanset", - "overleft_bigint_set", - "overleft_bigint_span", - "overleft_bigint_spanset", - "overleft_float_set", - "overleft_float_span", - "overleft_float_spanset", - "overleft_int_set", - "overleft_int_span", - "overleft_int_spanset", - "overleft_set_bigint", - "overleft_set_float", - "overleft_set_int", - "overleft_set_set", - "overleft_set_text", - "overleft_span_bigint", - "overleft_span_float", - "overleft_span_int", - "overleft_span_span", - "overleft_span_spanset", - "overleft_spanset_bigint", - "overleft_spanset_float", - "overleft_spanset_int", - "overleft_spanset_span", - "overleft_spanset_spanset", - "overleft_text_set", - "overright_bigint_set", - "overright_bigint_span", - "overright_bigint_spanset", - "overright_float_set", - "overright_float_span", - "overright_float_spanset", - "overright_int_set", - "overright_int_span", - "overright_int_spanset", - "overright_set_bigint", - "overright_set_float", - "overright_set_int", - "overright_set_set", - "overright_set_text", - "overright_span_bigint", - "overright_span_float", - "overright_span_int", - "overright_span_span", - "overright_span_spanset", - "overright_spanset_bigint", - "overright_spanset_float", - "overright_spanset_int", - "overright_spanset_span", - "overright_spanset_spanset", - "overright_text_set", - "right_bigint_set", - "right_bigint_span", - "right_bigint_spanset", - "right_float_set", - "right_float_span", - "right_float_spanset", - "right_int_set", - "right_int_span", - "right_int_spanset", - "right_set_bigint", - "right_set_float", - "right_set_int", - "right_set_set", - "right_set_text", - "right_span_bigint", - "right_span_float", - "right_span_int", - "right_span_span", - "right_span_spanset", - "right_spanset_bigint", - "right_spanset_float", - "right_spanset_int", - "right_spanset_span", - "right_spanset_spanset", - "right_text_set", - "distance_set_bigint", - "distance_set_float", - "distance_set_int", - "distance_set_set", - "distance_set_timestamptz", - "distance_set_date", - "distance_span_bigint", - "distance_span_float", - "distance_span_int", - "distance_span_span", - "distance_span_timestamptz", - "distance_span_date", - "distance_spanset_bigint", - "distance_spanset_float", - "distance_spanset_int", - "distance_spanset_timestamptz", - "distance_spanset_date", - "distance_spanset_span", - "distance_spanset_spanset", - "set_cmp", - "set_eq", - "set_ge", - "set_gt", - "set_le", - "set_lt", - "set_ne", - "span_cmp", - "span_eq", - "span_ge", - "span_gt", - "span_le", - "span_lt", - "span_ne", - "spanset_cmp", - "spanset_eq", - "spanset_ge", - "spanset_gt", - "spanset_le", - "spanset_lt", - "spanset_ne", - "bigint_extent_transfn", - "bigint_union_transfn", - "float_extent_transfn", - "float_union_transfn", - "int_extent_transfn", - "int_union_transfn", - "set_extent_transfn", - "set_union_finalfn", - "set_union_transfn", - "span_extent_transfn", - "span_union_transfn", - "spanset_extent_transfn", - "spanset_union_finalfn", - "spanset_union_transfn", - "text_union_transfn", - "timestamptz_extent_transfn", - "timestamptz_tcount_transfn", - "timestamptz_union_transfn", - "tstzset_tcount_transfn", - "tstzspan_tcount_transfn", - "tstzspanset_tcount_transfn", - "tbox_in", - "tbox_out", - "tbox_from_wkb", - "tbox_from_hexwkb", - "stbox_from_wkb", - "stbox_from_hexwkb", - "tbox_as_wkb", - "tbox_as_hexwkb", - "stbox_as_wkb", - "stbox_as_hexwkb", - "stbox_in", - "stbox_out", - "float_tstzspan_to_tbox", - "float_timestamptz_to_tbox", - "geo_tstzspan_to_stbox", - "geo_timestamptz_to_stbox", - "int_tstzspan_to_tbox", - "int_timestamptz_to_tbox", - "numspan_tstzspan_to_tbox", - "numspan_timestamptz_to_tbox", - "stbox_copy", - "stbox_make", - "tbox_copy", - "tbox_make", - "box3d_to_stbox", - "gbox_to_stbox", - "float_to_tbox", - "geo_to_stbox", - "int_to_tbox", - "numset_to_tbox", - "numspan_to_tbox", - "numspanset_to_tbox", - "tstzspan_to_stbox", - "tstzspan_to_tbox", - "tstzspanset_to_stbox", - "tstzspanset_to_tbox", - "stbox_to_gbox", - "stbox_to_box3d", - "stbox_to_geo", - "stbox_to_tstzspan", - "tbox_to_intspan", - "tbox_to_floatspan", - "tbox_to_tstzspan", - "timestamptz_to_stbox", - "timestamptz_to_tbox", - "tstzset_to_stbox", - "tstzset_to_tbox", - "tnumber_to_tbox", - "tpoint_to_stbox", - "stbox_hast", - "stbox_hasx", - "stbox_hasz", - "stbox_isgeodetic", - "stbox_srid", - "stbox_tmax", - "stbox_tmax_inc", - "stbox_tmin", - "stbox_tmin_inc", - "stbox_xmax", - "stbox_xmin", - "stbox_ymax", - "stbox_ymin", - "stbox_zmax", - "stbox_zmin", - "tbox_hast", - "tbox_hasx", - "tbox_tmax", - "tbox_tmax_inc", - "tbox_tmin", - "tbox_tmin_inc", - "tbox_xmax", - "tbox_xmax_inc", - "tbox_xmin", - "tbox_xmin_inc", - "tboxfloat_xmax", - "tboxfloat_xmin", - "tboxint_xmax", - "tboxint_xmin", - "stbox_expand_space", - "stbox_expand_time", - "stbox_get_space", - "stbox_round", - "stbox_set_srid", - "stbox_shift_scale_time", - "tbox_expand_time", - "tbox_expand_float", - "tbox_expand_int", - "tbox_round", - "tbox_shift_scale_float", - "tbox_shift_scale_int", - "tbox_shift_scale_time", - "union_tbox_tbox", - "inter_tbox_tbox", - "intersection_tbox_tbox", - "union_stbox_stbox", - "inter_stbox_stbox", - "intersection_stbox_stbox", - "contains_tbox_tbox", - "contained_tbox_tbox", - "overlaps_tbox_tbox", - "same_tbox_tbox", - "adjacent_tbox_tbox", - "contains_stbox_stbox", - "contained_stbox_stbox", - "overlaps_stbox_stbox", - "same_stbox_stbox", - "adjacent_stbox_stbox", - "left_tbox_tbox", - "overleft_tbox_tbox", - "right_tbox_tbox", - "overright_tbox_tbox", - "before_tbox_tbox", - "overbefore_tbox_tbox", - "after_tbox_tbox", - "overafter_tbox_tbox", - "left_stbox_stbox", - "overleft_stbox_stbox", - "right_stbox_stbox", - "overright_stbox_stbox", - "below_stbox_stbox", - "overbelow_stbox_stbox", - "above_stbox_stbox", - "overabove_stbox_stbox", - "front_stbox_stbox", - "overfront_stbox_stbox", - "back_stbox_stbox", - "overback_stbox_stbox", - "before_stbox_stbox", - "overbefore_stbox_stbox", - "after_stbox_stbox", - "overafter_stbox_stbox", - "stbox_quad_split", - "tbox_eq", - "tbox_ne", - "tbox_cmp", - "tbox_lt", - "tbox_le", - "tbox_ge", - "tbox_gt", - "stbox_eq", - "stbox_ne", - "stbox_cmp", - "stbox_lt", - "stbox_le", - "stbox_ge", - "stbox_gt", - "tbool_in", - "tbool_out", - "temporal_as_hexwkb", - "temporal_as_mfjson", - "temporal_as_wkb", - "temporal_from_hexwkb", - "temporal_from_mfjson", - "temporal_from_wkb", - "tfloat_in", - "tfloat_out", - "tgeogpoint_in", - "tgeompoint_in", - "tint_in", - "tint_out", - "tpoint_as_ewkt", - "tpoint_as_text", - "tpoint_out", - "ttext_in", - "ttext_out", - "temporal_cp", - "tbool_from_base_temp", - "tboolinst_make", - "tboolseq_from_base_tstzset", - "tboolseq_from_base_tstzspan", - "tboolseqset_from_base_tstzspanset", - "temporal_copy", - "tfloat_from_base_temp", - "tfloatinst_make", - "tfloatseq_from_base_tstzspan", - "tfloatseq_from_base_tstzset", - "tfloatseqset_from_base_tstzspanset", - "tint_from_base_temp", - "tintinst_make", - "tintseq_from_base_tstzspan", - "tintseq_from_base_tstzset", - "tintseqset_from_base_tstzspanset", - "tpoint_from_base_temp", - "tpointinst_make", - "tpointseq_from_base_tstzspan", - "tpointseq_from_base_tstzset", - "tpointseqset_from_base_tstzspanset", - "tsequence_make", - "tsequenceset_make", - "tsequenceset_make_gaps", - "ttext_from_base_temp", - "ttextinst_make", - "ttextseq_from_base_tstzspan", - "ttextseq_from_base_tstzset", - "ttextseqset_from_base_tstzspanset", - "temporal_to_tstzspan", - "tfloat_to_tint", - "tint_to_tfloat", - "tnumber_to_span", - "tbool_end_value", - "tbool_start_value", - "tbool_values", - "temporal_duration", - "temporal_end_instant", - "temporal_end_sequence", - "temporal_end_timestamptz", - "temporal_hash", - "temporal_instant_n", - "temporal_instants", - "temporal_interp", - "temporal_max_instant", - "temporal_min_instant", - "temporal_num_instants", - "temporal_num_sequences", - "temporal_num_timestamps", - "temporal_segments", - "temporal_sequence_n", - "temporal_sequences", - "temporal_start_instant", - "temporal_start_sequence", - "temporal_start_timestamptz", - "temporal_stops", - "temporal_subtype", - "temporal_time", - "temporal_timestamptz_n", - "temporal_timestamps", - "tfloat_end_value", - "tfloat_max_value", - "tfloat_min_value", - "tfloat_start_value", - "tfloat_values", - "tint_end_value", - "tint_max_value", - "tint_min_value", - "tint_start_value", - "tint_values", - "tnumber_valuespans", - "tpoint_end_value", - "tpoint_start_value", - "tpoint_values", - "ttext_end_value", - "ttext_max_value", - "ttext_min_value", - "ttext_start_value", - "ttext_values", - "temporal_scale_time", - "temporal_set_interp", - "temporal_shift_scale_time", - "temporal_shift_time", - "temporal_to_tinstant", - "temporal_to_tsequence", - "temporal_to_tsequenceset", - "tfloat_scale_value", - "tfloat_shift_scale_value", - "tfloat_shift_value", - "tint_scale_value", - "tint_shift_scale_value", - "tint_shift_value", - "temporal_append_tinstant", - "temporal_append_tsequence", - "temporal_delete_tstzspan", - "temporal_delete_tstzspanset", - "temporal_delete_timestamptz", - "temporal_delete_tstzset", - "temporal_insert", - "temporal_merge", - "temporal_merge_array", - "temporal_update", - "tbool_at_value", - "tbool_minus_value", - "tbool_value_at_timestamptz", - "temporal_at_max", - "temporal_at_min", - "temporal_at_tstzspan", - "temporal_at_tstzspanset", - "temporal_at_timestamptz", - "temporal_at_tstzset", - "temporal_at_values", - "temporal_minus_max", - "temporal_minus_min", - "temporal_minus_tstzspan", - "temporal_minus_tstzspanset", - "temporal_minus_timestamptz", - "temporal_minus_tstzset", - "temporal_minus_values", - "tfloat_at_value", - "tfloat_minus_value", - "tfloat_value_at_timestamptz", - "tint_at_value", - "tint_minus_value", - "tint_value_at_timestamptz", - "tnumber_at_span", - "tnumber_at_spanset", - "tnumber_at_tbox", - "tnumber_minus_span", - "tnumber_minus_spanset", - "tnumber_minus_tbox", - "tpoint_at_geom_time", - "tpoint_at_stbox", - "tpoint_at_value", - "tpoint_minus_geom_time", - "tpoint_minus_stbox", - "tpoint_minus_value", - "tpoint_value_at_timestamptz", - "ttext_at_value", - "ttext_minus_value", - "ttext_value_at_timestamptz", - "temporal_cmp", - "temporal_eq", - "temporal_ge", - "temporal_gt", - "temporal_le", - "temporal_lt", - "temporal_ne", - "tbool_always_eq", - "tbool_ever_eq", - "tfloat_always_eq", - "tfloat_always_le", - "tfloat_always_lt", - "tfloat_ever_eq", - "tfloat_ever_le", - "tfloat_ever_lt", - "tint_always_eq", - "tint_always_le", - "tint_always_lt", - "tint_ever_eq", - "tint_ever_le", - "tint_ever_lt", - "tpoint_always_eq", - "tpoint_ever_eq", - "ttext_always_eq", - "ttext_always_le", - "ttext_always_lt", - "ttext_ever_eq", - "ttext_ever_le", - "ttext_ever_lt", - "teq_bool_tbool", - "teq_float_tfloat", - "teq_int_tint", - "teq_point_tpoint", - "teq_tbool_bool", - "teq_temporal_temporal", - "teq_text_ttext", - "teq_tfloat_float", - "teq_tpoint_point", - "teq_tint_int", - "teq_ttext_text", - "tge_float_tfloat", - "tge_int_tint", - "tge_temporal_temporal", - "tge_text_ttext", - "tge_tfloat_float", - "tge_tint_int", - "tge_ttext_text", - "tgt_float_tfloat", - "tgt_int_tint", - "tgt_temporal_temporal", - "tgt_text_ttext", - "tgt_tfloat_float", - "tgt_tint_int", - "tgt_ttext_text", - "tle_float_tfloat", - "tle_int_tint", - "tle_temporal_temporal", - "tle_text_ttext", - "tle_tfloat_float", - "tle_tint_int", - "tle_ttext_text", - "tlt_float_tfloat", - "tlt_int_tint", - "tlt_temporal_temporal", - "tlt_text_ttext", - "tlt_tfloat_float", - "tlt_tint_int", - "tlt_ttext_text", - "tne_bool_tbool", - "tne_float_tfloat", - "tne_int_tint", - "tne_point_tpoint", - "tne_tbool_bool", - "tne_temporal_temporal", - "tne_text_ttext", - "tne_tfloat_float", - "tne_tpoint_point", - "tne_tint_int", - "tne_ttext_text", - "adjacent_numspan_tnumber", - "adjacent_stbox_tpoint", - "adjacent_tbox_tnumber", - "adjacent_temporal_temporal", - "adjacent_temporal_tstzspan", - "adjacent_tnumber_numspan", - "adjacent_tnumber_tbox", - "adjacent_tnumber_tnumber", - "adjacent_tpoint_stbox", - "adjacent_tpoint_tpoint", - "adjacent_tstzspan_temporal", - "contained_numspan_tnumber", - "contained_stbox_tpoint", - "contained_tbox_tnumber", - "contained_temporal_temporal", - "contained_temporal_tstzspan", - "contained_tnumber_numspan", - "contained_tnumber_tbox", - "contained_tnumber_tnumber", - "contained_tpoint_stbox", - "contained_tpoint_tpoint", - "contained_tstzspan_temporal", - "contains_numspan_tnumber", - "contains_stbox_tpoint", - "contains_tbox_tnumber", - "contains_temporal_tstzspan", - "contains_temporal_temporal", - "contains_tnumber_numspan", - "contains_tnumber_tbox", - "contains_tnumber_tnumber", - "contains_tpoint_stbox", - "contains_tpoint_tpoint", - "contains_tstzspan_temporal", - "overlaps_numspan_tnumber", - "overlaps_stbox_tpoint", - "overlaps_tbox_tnumber", - "overlaps_temporal_temporal", - "overlaps_temporal_tstzspan", - "overlaps_tnumber_numspan", - "overlaps_tnumber_tbox", - "overlaps_tnumber_tnumber", - "overlaps_tpoint_stbox", - "overlaps_tpoint_tpoint", - "overlaps_tstzspan_temporal", - "same_numspan_tnumber", - "same_stbox_tpoint", - "same_tbox_tnumber", - "same_temporal_temporal", - "same_temporal_tstzspan", - "same_tnumber_numspan", - "same_tnumber_tbox", - "same_tnumber_tnumber", - "same_tpoint_stbox", - "same_tpoint_tpoint", - "same_tstzspan_temporal", - "above_stbox_tpoint", - "above_tpoint_stbox", - "above_tpoint_tpoint", - "after_stbox_tpoint", - "after_tbox_tnumber", - "after_temporal_tstzspan", - "after_temporal_temporal", - "after_tnumber_tbox", - "after_tnumber_tnumber", - "after_tpoint_stbox", - "after_tpoint_tpoint", - "after_tstzspan_temporal", - "back_stbox_tpoint", - "back_tpoint_stbox", - "back_tpoint_tpoint", - "before_stbox_tpoint", - "before_tbox_tnumber", - "before_temporal_tstzspan", - "before_temporal_temporal", - "before_tnumber_tbox", - "before_tnumber_tnumber", - "before_tpoint_stbox", - "before_tpoint_tpoint", - "before_tstzspan_temporal", - "below_stbox_tpoint", - "below_tpoint_stbox", - "below_tpoint_tpoint", - "front_stbox_tpoint", - "front_tpoint_stbox", - "front_tpoint_tpoint", - "left_stbox_tpoint", - "left_tbox_tnumber", - "left_numspan_tnumber", - "left_tnumber_numspan", - "left_tnumber_tbox", - "left_tnumber_tnumber", - "left_tpoint_stbox", - "left_tpoint_tpoint", - "overabove_stbox_tpoint", - "overabove_tpoint_stbox", - "overabove_tpoint_tpoint", - "overafter_stbox_tpoint", - "overafter_tbox_tnumber", - "overafter_temporal_tstzspan", - "overafter_temporal_temporal", - "overafter_tnumber_tbox", - "overafter_tnumber_tnumber", - "overafter_tpoint_stbox", - "overafter_tpoint_tpoint", - "overafter_tstzspan_temporal", - "overback_stbox_tpoint", - "overback_tpoint_stbox", - "overback_tpoint_tpoint", - "overbefore_stbox_tpoint", - "overbefore_tbox_tnumber", - "overbefore_temporal_tstzspan", - "overbefore_temporal_temporal", - "overbefore_tnumber_tbox", - "overbefore_tnumber_tnumber", - "overbefore_tpoint_stbox", - "overbefore_tpoint_tpoint", - "overbefore_tstzspan_temporal", - "overbelow_stbox_tpoint", - "overbelow_tpoint_stbox", - "overbelow_tpoint_tpoint", - "overfront_stbox_tpoint", - "overfront_tpoint_stbox", - "overfront_tpoint_tpoint", - "overleft_numspan_tnumber", - "overleft_stbox_tpoint", - "overleft_tbox_tnumber", - "overleft_tnumber_numspan", - "overleft_tnumber_tbox", - "overleft_tnumber_tnumber", - "overleft_tpoint_stbox", - "overleft_tpoint_tpoint", - "overright_numspan_tnumber", - "overright_stbox_tpoint", - "overright_tbox_tnumber", - "overright_tnumber_numspan", - "overright_tnumber_tbox", - "overright_tnumber_tnumber", - "overright_tpoint_stbox", - "overright_tpoint_tpoint", - "right_numspan_tnumber", - "right_stbox_tpoint", - "right_tbox_tnumber", - "right_tnumber_numspan", - "right_tnumber_tbox", - "right_tnumber_tnumber", - "right_tpoint_stbox", - "right_tpoint_tpoint", - "tand_bool_tbool", - "tand_tbool_bool", - "tand_tbool_tbool", - "tbool_when_true", - "tnot_tbool", - "tor_bool_tbool", - "tor_tbool_bool", - "tor_tbool_tbool", - "add_float_tfloat", - "add_int_tint", - "add_tfloat_float", - "add_tint_int", - "add_tnumber_tnumber", - "div_float_tfloat", - "div_int_tint", - "div_tfloat_float", - "div_tint_int", - "div_tnumber_tnumber", - "float_degrees", - "mult_float_tfloat", - "mult_int_tint", - "mult_tfloat_float", - "mult_tint_int", - "mult_tnumber_tnumber", - "sub_float_tfloat", - "sub_int_tint", - "sub_tfloat_float", - "sub_tint_int", - "sub_tnumber_tnumber", - "tfloat_round", - "tfloatarr_round", - "tfloat_degrees", - "tfloat_derivative", - "tfloat_radians", - "tnumber_abs", - "tnumber_angular_difference", - "tnumber_delta_value", - "textcat_text_ttext", - "textcat_ttext_text", - "textcat_ttext_ttext", - "ttext_upper", - "ttext_lower", - "distance_tfloat_float", - "distance_tint_int", - "distance_tnumber_tnumber", - "distance_tpoint_point", - "distance_tpoint_tpoint", - "nad_stbox_geo", - "nad_stbox_stbox", - "nad_tbox_tbox", - "nad_tfloat_float", - "nad_tfloat_tfloat", - "nad_tint_int", - "nad_tint_tint", - "nad_tnumber_tbox", - "nad_tpoint_geo", - "nad_tpoint_stbox", - "nad_tpoint_tpoint", - "nai_tpoint_geo", - "nai_tpoint_tpoint", - "shortestline_tpoint_geo", - "shortestline_tpoint_tpoint", - "bearing_point_point", - "bearing_tpoint_point", - "bearing_tpoint_tpoint", - "tpoint_angular_difference", - "tpoint_azimuth", - "tpoint_convex_hull", - "tpoint_cumulative_length", - "tpoint_direction", - "tpoint_get_x", - "tpoint_get_y", - "tpoint_get_z", - "tpoint_is_simple", - "tpoint_length", - "tpoint_speed", - "tpoint_srid", - "tpoint_stboxes", - "tpoint_trajectory", - "geo_expand_space", - "geomeas_to_tpoint", - "tgeogpoint_to_tgeompoint", - "tgeompoint_to_tgeogpoint", - "tpoint_AsMVTGeom", - "tpoint_expand_space", - "tpoint_make_simple", - "tpoint_round", - "tpointarr_round", - "tpoint_set_srid", - "tpoint_tfloat_to_geomeas", - "econtains_geo_tpoint", - "edisjoint_tpoint_geo", - "edisjoint_tpoint_tpoint", - "edwithin_tpoint_geo", - "edwithin_tpoint_tpoint", - "eintersects_tpoint_geo", - "eintersects_tpoint_tpoint", - "etouches_tpoint_geo", - "tcontains_geo_tpoint", - "tdisjoint_tpoint_geo", - "tdwithin_tpoint_geo", - "tdwithin_tpoint_tpoint", - "tintersects_tpoint_geo", - "ttouches_tpoint_geo", - "tbool_tand_transfn", - "tbool_tor_transfn", - "temporal_extent_transfn", - "temporal_tagg_finalfn", - "temporal_tcount_transfn", - "tfloat_tmax_transfn", - "tfloat_tmin_transfn", - "tfloat_tsum_transfn", - "tint_tmax_transfn", - "tint_tmin_transfn", - "tint_tsum_transfn", - "tnumber_extent_transfn", - "tnumber_integral", - "tnumber_tavg_finalfn", - "tnumber_tavg_transfn", - "tnumber_twavg", - "tpoint_extent_transfn", - "tpoint_tcentroid_finalfn", - "tpoint_tcentroid_transfn", - "tpoint_twcentroid", - "ttext_tmax_transfn", - "ttext_tmin_transfn", - "temporal_simplify_min_dist", - "temporal_simplify_min_tdelta", - "temporal_simplify_dp", - "temporal_simplify_max_dist", - "temporal_tprecision", - "temporal_tsample", - "temporal_dyntimewarp_distance", - "temporal_dyntimewarp_path", - "temporal_frechet_distance", - "temporal_frechet_path", - "temporal_hausdorff_distance", - "float_bucket", - "floatspan_bucket_list", - "int_bucket", - "intspan_bucket_list", - "tstzspan_bucket_list", - "stbox_tile", - "stbox_tile_list", - "tintbox_tile_list", - "tfloatbox_tile_list", - "temporal_time_split", - "tfloat_value_split", - "tfloat_value_time_split", - "timestamptz_bucket", - "tint_value_split", - "tint_value_time_split", - "tpoint_space_split", - "tpoint_space_time_split", - "temptype_subtype", - "temptype_subtype_all", - "tempsubtype_name", - "tempsubtype_from_string", - "meosoper_name", - "meosoper_from_string", - "interptype_name", - "interptype_from_string", - "meostype_name", - "temptype_basetype", - "settype_basetype", - "spantype_basetype", - "spantype_spansettype", - "spansettype_spantype", - "basetype_spantype", - "basetype_settype", - "meostype_internal", - "meos_basetype", - "alpha_basetype", - "tnumber_basetype", - "alphanum_basetype", - "geo_basetype", - "spatial_basetype", - "time_type", - "set_basetype", - "set_type", - "numset_type", - "ensure_numset_type", - "timeset_type", - "ensure_timeset_type", - "set_spantype", - "ensure_set_spantype", - "alphanumset_type", - "geoset_type", - "ensure_geoset_type", - "spatialset_type", - "ensure_spatialset_type", - "span_basetype", - "span_canon_basetype", - "span_type", - "span_bbox_type", - "numspan_basetype", - "numspan_type", - "ensure_numspan_type", - "timespan_basetype", - "timespan_type", - "ensure_timespan_type", - "spanset_type", - "numspanset_type", - "timespanset_type", - "ensure_timespanset_type", - "temporal_type", - "temporal_basetype", - "temptype_continuous", - "basetype_byvalue", - "basetype_varlength", - "basetype_length", - "talphanum_type", - "talpha_type", - "tnumber_type", - "ensure_tnumber_type", - "tnumber_basetype", - "ensure_tnumber_basetype", - "tnumber_settype", - "tnumber_spantype", - "tnumber_spansettype", - "tspatial_type", - "ensure_tspatial_type", - "tspatial_basetype", - "tgeo_type", - "ensure_tgeo_type", - "ensure_tnumber_tgeo_type", - "datum_hash", - "datum_hash_extended", - "set_in", - "set_out", - "span_in", - "span_out", - "spanset_in", - "spanset_out", - "set_compact", - "set_cp", - "set_make", - "set_make_exp", - "set_make_free", - "set_out", - "span_cp", - "span_make", - "span_out", - "span_set", - "spanset_cp", - "spanset_compact", - "spanset_make_exp", - "spanset_make_free", - "spanset_out", - "span_spanset", - "value_to_set", - "value_to_span", - "value_to_spanset", - "set_end_value", - "set_mem_size", - "set_set_span", - "set_span", - "set_start_value", - "set_value_n", - "set_values", - "spanset_lower", - "spanset_mem_size", - "spanset_upper", - "spatialset_set_stbox", - "value_set_span", - "datespan_set_tstzspan", - "floatspan_rnd", - "floatspan_set_intspan", - "floatspan_set_numspan", - "intspan_set_floatspan", - "numset_shift_scale", - "numspan_set_floatspan", - "numspan_shift_scale", - "numspanset_shift_scale", - "set_compact", - "span_expand", - "spanset_compact", - "tstzspan_set_datespan", - "set_cmp1", - "set_eq1", - "span_cmp1", - "span_eq1", - "spanset_cmp1", - "spanset_eq1", - "spanbase_extent_transfn", - "value_union_transfn", - "adj_span_span", - "adjacent_span_value", - "adjacent_spanset_value", - "cont_span_span", - "contains_span_value", - "contains_spanset_value", - "contains_set_value", - "contains_set_set", - "contained_value_span", - "contained_value_set", - "contained_set_set", - "contained_value_spanset", - "over_span_span", - "over_adj_span_span", - "overlaps_value_span", - "overlaps_value_spanset", - "overlaps_span_value", - "overlaps_spanset_value", - "overlaps_set_set", - "left_notadj_span_span", - "left_set_set", - "left_set_value", - "left_span_value", - "left_spanset_value", - "left_value_set", - "left_value_span", - "left_value_spanset", - "lf_span_span", - "ri_span_span", - "right_value_set", - "right_set_value", - "right_set_set", - "right_value_span", - "right_value_spanset", - "right_span_value", - "right_spanset_value", - "overleft_value_set", - "overleft_set_value", - "overleft_set_set", - "overleft_value_span", - "overleft_value_spanset", - "overleft_span_value", - "overleft_spanset_value", - "overright_value_set", - "overright_set_value", - "overright_set_set", - "overright_value_span", - "overright_value_spanset", - "overright_span_value", - "overright_spanset_value", - "ovlf_span_span", - "ovri_span_span", - "inter_span_span", - "intersection_set_value", - "intersection_span_value", - "intersection_spanset_value", - "minus_set_value", - "minus_span_value", - "minus_spanset_value", - "minus_value_set", - "minus_value_span", - "minus_value_spanset", - "union_set_value", - "union_span_value", - "union_spanset_value", - "dist_set_set", - "dist_span_span", - "distance_value_value", - "distance_span_value", - "distance_spanset_value", - "distance_value_set", - "distance_set_value", - "datum_hash", - "datum_hash_extended", - "number_tstzspan_to_tbox", - "number_timestamptz_to_tbox", - "stbox_cp", - "stbox_set", - "tbox_cp", - "tbox_set", - "float_set_tbox", - "geo_set_stbox", - "geoarr_set_stbox", - "int_set_tbox", - "number_set_tbox", - "number_to_tbox", - "numset_set_tbox", - "numspan_set_tbox", - "numspanset_set_tbox", - "tstzspan_set_stbox", - "tstzspan_set_tbox", - "tstzspanset_set_stbox", - "tstzspanset_set_tbox", - "stbox_set_box3d", - "stbox_set_gbox", - "timestamptz_set_stbox", - "timestamptz_set_tbox", - "tstzset_set_stbox", - "tstzset_set_tbox", - "tbox_shift_scale_value", - "stbox_expand", - "tbox_expand", - "bbox_union_span_span", - "inter_stbox_stbox", - "inter_tbox_tbox", - "geoarr_as_text", - "tboolinst_as_mfjson", - "tboolinst_from_mfjson", - "tboolinst_in", - "tboolseq_as_mfjson", - "tboolseq_from_mfjson", - "tboolseq_in", - "tboolseqset_as_mfjson", - "tboolseqset_from_mfjson", - "tboolseqset_in", - "temporal_in", - "temporal_out", - "temporal_values", - "temporalarr_out", - "tfloatinst_as_mfjson", - "tfloatinst_from_mfjson", - "tfloatinst_in", - "tfloatseq_as_mfjson", - "tfloatseq_from_mfjson", - "tfloatseq_in", - "tfloatseqset_as_mfjson", - "tfloatseqset_from_mfjson", - "tfloatseqset_in", - "tgeogpointinst_from_mfjson", - "tgeogpointinst_in", - "tgeogpointseq_from_mfjson", - "tgeogpointseq_in", - "tgeogpointseqset_from_mfjson", - "tgeogpointseqset_in", - "tgeompointinst_from_mfjson", - "tgeompointinst_in", - "tgeompointseq_from_mfjson", - "tgeompointseq_in", - "tgeompointseqset_from_mfjson", - "tgeompointseqset_in", - "tinstant_as_mfjson", - "tinstant_from_mfjson", - "tinstant_in", - "tinstant_out", - "tintinst_as_mfjson", - "tintinst_from_mfjson", - "tintinst_in", - "tintseq_as_mfjson", - "tintseq_from_mfjson", - "tintseq_in", - "tintseqset_as_mfjson", - "tintseqset_from_mfjson", - "tintseqset_in", - "tpointarr_as_text", - "tpointinst_as_mfjson", - "tpointseq_as_mfjson", - "tpointseqset_as_mfjson", - "tsequence_as_mfjson", - "tsequence_from_mfjson", - "tsequence_in", - "tsequence_out", - "tsequenceset_as_mfjson", - "tsequenceset_from_mfjson", - "tsequenceset_in", - "tsequenceset_out", - "ttextinst_as_mfjson", - "ttextinst_from_mfjson", - "ttextinst_in", - "ttextseq_as_mfjson", - "ttextseq_from_mfjson", - "ttextseq_in", - "ttextseqset_as_mfjson", - "ttextseqset_from_mfjson", - "ttextseqset_in", - "temporal_cp", - "temporal_from_base_temp", - "tinstant_copy", - "tinstant_make", - "tpointseq_make_coords", - "tsequence_from_base_tstzset", - "tsequence_make_exp", - "tsequence_compact", - "tsequence_restart", - "tsequence_subseq", - "tsequence_copy", - "tsequence_from_base_tstzspan", - "tsequence_make_free", - "tsequenceset_make_exp", - "tsequenceset_compact", - "tsequenceset_make_free", - "tsequenceset_restart", - "tsequenceset_copy", - "tseqsetarr_to_tseqset", - "tsequenceset_from_base_tstzspanset", - "temporal_set_tstzspan", - "tinstant_set_tstzspan", - "tnumber_span", - "tsequence_set_tstzspan", - "tsequenceset_set_tstzspan", - "temporal_end_value", - "temporal_max_value", - "temporal_mem_size", - "temporal_min_value", - "temporal_set_bbox", - "tfloatseq_derivative", - "tfloatseqset_derivative", - "tnumber_set_span", - "temporal_start_value", - "tnumberinst_abs", - "tnumberseq_abs", - "tnumberseqset_abs", - "tnumberseq_angular_difference", - "tnumberseqset_angular_difference", - "tnumberseq_delta_value", - "tnumberseqset_delta_value", - "tnumberinst_valuespans", - "tnumberseq_valuespans", - "tnumberseqset_valuespans", - "tinstant_hash", - "tinstant_instants", - "tinstant_set_bbox", - "tinstant_time", - "tinstant_timestamps", - "tinstant_value", - "tinstant_value_at_timestamptz", - "tinstant_value_copy", - "tinstant_values", - "tsequence_duration", - "tsequence_end_timestamptz", - "tsequence_hash", - "tsequence_instants", - "tsequence_max_instant", - "tsequence_max_value", - "tsequence_min_instant", - "tsequence_min_value", - "tsequence_segments", - "tsequence_sequences", - "tsequence_set_bbox", - "tsequence_expand_bbox", - "tsequenceset_expand_bbox", - "tsequence_start_timestamptz", - "tsequence_time", - "tsequence_timestamps", - "tsequence_value_at_timestamptz", - "tsequence_values", - "tsequenceset_duration", - "tsequenceset_end_timestamptz", - "tsequenceset_hash", - "tsequenceset_inst_n", - "tsequenceset_instants", - "tsequenceset_max_instant", - "tsequenceset_max_value", - "tsequenceset_min_instant", - "tsequenceset_min_value", - "tsequenceset_num_instants", - "tsequenceset_num_timestamps", - "tsequenceset_segments", - "tsequenceset_sequences", - "tsequenceset_sequences_p", - "tsequenceset_set_bbox", - "tsequenceset_start_timestamptz", - "tsequenceset_time", - "tsequenceset_timespan", - "tsequenceset_timestamptz_n", - "tsequenceset_timestamps", - "tsequenceset_value_at_timestamptz", - "tsequenceset_values", - "tinstant_merge", - "tinstant_merge_array", - "tinstant_shift_time", - "tinstant_to_tsequence", - "tinstant_to_tsequenceset", - "tnumber_shift_scale_value", - "tnuminst_shift_value", - "tnumberseq_shift_scale_value", - "tsequence_append_tinstant", - "tsequence_append_tsequence", - "tsequence_merge", - "tsequence_merge_array", - "tsequence_set_interp", - "tsequence_shift_scale_time", - "tsequence_to_tinstant", - "tsequence_to_tdiscseq", - "tsequence_to_tcontseq", - "tsequence_to_tsequenceset", - "tsequence_to_tsequenceset_interp", - "tsequenceset_append_tinstant", - "tsequenceset_append_tsequence", - "tsequenceset_merge", - "tsequenceset_merge_array", - "tsequenceset_set_interp", - "tnumberseqset_shift_scale_value", - "tsequenceset_shift_scale_time", - "tsequenceset_to_tinstant", - "tsequenceset_to_discrete", - "tsequenceset_to_step", - "tsequenceset_to_linear", - "tsequenceset_to_tsequence", - "temporal_bbox_restrict_set", - "temporal_restrict_minmax", - "temporal_restrict_tstzspan", - "temporal_restrict_tstzspanset", - "temporal_restrict_timestamptz", - "temporal_restrict_tstzset", - "temporal_restrict_value", - "temporal_restrict_values", - "temporal_value_at_timestamptz", - "tinstant_restrict_tstzspan", - "tinstant_restrict_tstzspanset", - "tinstant_restrict_timestamptz", - "tinstant_restrict_tstzset", - "tinstant_restrict_value", - "tinstant_restrict_values", - "tnumber_restrict_span", - "tnumber_restrict_spanset", - "tnumberinst_restrict_span", - "tnumberinst_restrict_spanset", - "tnumberseqset_restrict_span", - "tnumberseqset_restrict_spanset", - "tpoint_restrict_geom_time", - "tpoint_restrict_stbox", - "tpointinst_restrict_geom_time", - "tpointinst_restrict_stbox", - "tpointseq_restrict_geom_time", - "tpointseq_restrict_stbox", - "tpointseqset_restrict_geom_time", - "tpointseqset_restrict_stbox", - "tsequence_at_tstzspan", - "tsequence_at_timestamptz", - "tsequence_restrict_minmax", - "tsequence_restrict_tstzspan", - "tsequence_restrict_tstzspanset", - "tsequence_restrict_timestamptz", - "tsequence_restrict_tstzset", - "tsequence_restrict_value", - "tsequence_restrict_values", - "tsequenceset_restrict_minmax", - "tsequenceset_restrict_tstzspan", - "tsequenceset_restrict_tstzspanset", - "tsequenceset_restrict_timestamptz", - "tsequenceset_restrict_tstzset", - "tsequenceset_restrict_value", - "tsequenceset_restrict_values", - "tnumberseq_derivative", - "tnumberseqset_derivative", - "distance_tnumber_number", - "nad_tnumber_number", - "temporal_always_eq", - "temporal_always_le", - "temporal_always_lt", - "temporal_ever_eq", - "temporal_ever_le", - "temporal_ever_lt", - "tinstant_always_eq", - "tinstant_always_le", - "tinstant_always_lt", - "tinstant_ever_eq", - "tinstant_ever_le", - "tinstant_ever_lt", - "tpointinst_always_eq", - "tpointinst_ever_eq", - "tpointseq_always_eq", - "tpointseq_ever_eq", - "tpointseqset_always_eq", - "tpointseqset_ever_eq", - "tsequence_always_eq", - "tsequence_always_le", - "tsequence_always_lt", - "tsequence_ever_eq", - "tsequence_ever_le", - "tsequence_ever_lt", - "tsequenceset_always_eq", - "tsequenceset_always_le", - "tsequenceset_always_lt", - "tsequenceset_ever_eq", - "tsequenceset_ever_le", - "tsequenceset_ever_lt", - "tinstant_cmp", - "tinstant_eq", - "tsequence_cmp", - "tsequence_eq", - "tsequenceset_cmp", - "tsequenceset_eq", - "tpointinst_srid", - "tpointseq_trajectory", - "tpointseq_azimuth", - "tpointseq_cumulative_length", - "tpointseq_is_simple", - "tpointseq_length", - "tpointseq_speed", - "tpointseq_srid", - "tpointseq_stboxes", - "tpointseqset_azimuth", - "tpointseqset_cumulative_length", - "tpointseqset_is_simple", - "tpointseqset_length", - "tpointseqset_speed", - "tpointseqset_srid", - "tpointseqset_stboxes", - "tpointseqset_trajectory", - "tpoint_get_coord", - "tgeompointinst_tgeogpointinst", - "tgeompointseq_tgeogpointseq", - "tgeompointseqset_tgeogpointseqset", - "tgeompoint_tgeogpoint", - "tpointinst_set_srid", - "tpointseq_make_simple", - "tpointseq_set_srid", - "tpointseqset_make_simple", - "tpointseqset_set_srid", - "tsequence_insert", - "tsequenceset_insert", - "tsequence_delete_timestamptz", - "tsequence_delete_tstzset", - "tsequence_delete_tstzspan", - "tsequence_delete_tstzspanset", - "tsequenceset_delete_timestamptz", - "tsequenceset_delete_tstzset", - "tsequenceset_delete_tstzspan", - "tsequenceset_delete_tstzspanset", - "tnumberseq_integral", - "tnumberseq_twavg", - "tnumberseqset_integral", - "tnumberseqset_twavg", - "tpointseq_twcentroid", - "tpointseqset_twcentroid", - "temporal_compact", - "tsequence_compact", - "tsequenceset_compact", - "tbool_tand_transfn", - "tbool_tor_transfn", - "temporal_tagg_finalfn", - "temporal_tcount_transfn", - "tfloat_tmax_transfn", - "tfloat_tmin_transfn", - "tfloat_tsum_transfn", - "tfloat_wmax_transfn", - "tfloat_wmin_transfn", - "tfloat_wsum_transfn", - "tint_tmin_transfn", - "tint_tmax_transfn", - "tint_tsum_transfn", - "tint_wmax_transfn", - "tint_wmin_transfn", - "tint_wsum_transfn", - "tnumber_tavg_finalfn", - "tnumber_tavg_transfn", - "tnumber_wavg_transfn", - "ttext_tmin_transfn", - "ttext_tmax_transfn", - "tnumber_value_split", + 'py_error_handler', + 'create_pointer', + 'get_address', + 'datetime_to_timestamptz', + 'timestamptz_to_datetime', + 'date_to_date_adt', + 'date_adt_to_date', + 'timedelta_to_interval', + 'interval_to_timedelta', + 'geo_to_gserialized', + 'geometry_to_gserialized', + 'geography_to_gserialized', + 'gserialized_to_shapely_point', + 'gserialized_to_shapely_geometry', + 'as_tinstant', + 'as_tsequence', + 'as_tsequenceset', + 'lwpoint_make', + 'lwgeom_from_gserialized', + 'gserialized_from_lwgeom', + 'lwgeom_get_srid', + 'lwpoint_get_x', + 'lwpoint_get_y', + 'lwpoint_get_z', + 'lwpoint_get_m', + 'lwgeom_has_z', + 'lwgeom_has_m', + 'meos_errno', + 'meos_errno_set', + 'meos_errno_restore', + 'meos_errno_reset', + 'meos_set_datestyle', + 'meos_set_intervalstyle', + 'meos_get_datestyle', + 'meos_get_intervalstyle', + 'meos_initialize', + 'meos_finalize', + 'bool_in', + 'bool_out', + 'cstring2text', + 'pg_date_in', + 'pg_date_out', + 'pg_date_mi', + 'pg_date_mi_int', + 'pg_date_pl_int', + 'pg_date_timestamptz', + 'pg_interval_cmp', + 'pg_interval_in', + 'pg_interval_make', + 'pg_interval_mul', + 'pg_interval_out', + 'pg_interval_to_char', + 'pg_interval_pl', + 'pg_time_in', + 'pg_time_out', + 'pg_timestamp_in', + 'pg_timestamp_mi', + 'pg_timestamp_mi_interval', + 'pg_timestamp_out', + 'pg_timestamp_pl_interval', + 'pg_timestamp_to_char', + 'pg_timestamptz_in', + 'pg_timestamptz_date', + 'pg_timestamptz_out', + 'pg_timestamptz_to_char', + 'pg_to_date', + 'pg_to_timestamptz', + 'text2cstring', + 'text_out', + 'geography_from_hexewkb', + 'geography_from_text', + 'geometry_from_hexewkb', + 'geometry_from_text', + 'gserialized_as_ewkb', + 'gserialized_as_ewkt', + 'gserialized_as_geojson', + 'gserialized_as_hexewkb', + 'gserialized_as_text', + 'gserialized_from_ewkb', + 'gserialized_from_geojson', + 'gserialized_out', + 'pgis_geography_in', + 'pgis_geometry_in', + 'pgis_gserialized_same', + 'bigintset_in', + 'bigintset_out', + 'bigintspan_in', + 'bigintspan_out', + 'bigintspanset_in', + 'bigintspanset_out', + 'dateset_in', + 'dateset_out', + 'datespan_in', + 'datespan_out', + 'datespanset_in', + 'datespanset_out', + 'floatset_in', + 'floatset_out', + 'floatspan_in', + 'floatspan_out', + 'floatspanset_in', + 'floatspanset_out', + 'geogset_in', + 'geomset_in', + 'geoset_as_ewkt', + 'geoset_as_text', + 'geoset_out', + 'intset_in', + 'intset_out', + 'intspan_in', + 'intspan_out', + 'intspanset_in', + 'intspanset_out', + 'set_as_hexwkb', + 'set_as_wkb', + 'set_from_hexwkb', + 'set_from_wkb', + 'span_as_hexwkb', + 'span_as_wkb', + 'span_from_hexwkb', + 'span_from_wkb', + 'spanset_as_hexwkb', + 'spanset_as_wkb', + 'spanset_from_hexwkb', + 'spanset_from_wkb', + 'textset_in', + 'textset_out', + 'tstzset_in', + 'tstzset_out', + 'tstzspan_in', + 'tstzspan_out', + 'tstzspanset_in', + 'tstzspanset_out', + 'bigintset_make', + 'bigintspan_make', + 'dateset_make', + 'datespan_make', + 'floatset_make', + 'floatspan_make', + 'geoset_make', + 'intset_make', + 'intspan_make', + 'set_copy', + 'span_copy', + 'spanset_copy', + 'spanset_make', + 'textset_make', + 'tstzset_make', + 'tstzspan_make', + 'bigint_to_set', + 'bigint_to_span', + 'bigint_to_spanset', + 'date_to_set', + 'date_to_span', + 'date_to_spanset', + 'date_to_tstzspan', + 'float_to_set', + 'float_to_span', + 'float_to_spanset', + 'geo_to_set', + 'int_to_set', + 'int_to_span', + 'int_to_spanset', + 'set_to_spanset', + 'span_to_spanset', + 'text_to_set', + 'timestamptz_to_set', + 'timestamptz_to_span', + 'timestamptz_to_spanset', + 'bigintset_end_value', + 'bigintset_start_value', + 'bigintset_value_n', + 'bigintset_values', + 'bigintspan_lower', + 'bigintspan_upper', + 'bigintspanset_lower', + 'bigintspanset_upper', + 'dateset_end_value', + 'dateset_start_value', + 'dateset_value_n', + 'dateset_values', + 'datespan_duration', + 'datespan_lower', + 'datespan_upper', + 'datespanset_duration', + 'datespanset_end_date', + 'datespanset_num_dates', + 'datespanset_start_date', + 'datespanset_date_n', + 'datespanset_dates', + 'floatset_end_value', + 'floatset_start_value', + 'floatset_value_n', + 'floatset_values', + 'floatspan_lower', + 'floatspan_upper', + 'floatspanset_lower', + 'floatspanset_upper', + 'geoset_end_value', + 'geoset_srid', + 'geoset_set_srid', + 'geoset_start_value', + 'geoset_value_n', + 'geoset_values', + 'intset_end_value', + 'intset_start_value', + 'intset_value_n', + 'intset_values', + 'intspan_lower', + 'intspan_upper', + 'intspanset_lower', + 'intspanset_upper', + 'set_hash', + 'set_hash_extended', + 'set_num_values', + 'set_to_span', + 'span_hash', + 'span_hash_extended', + 'span_lower_inc', + 'span_upper_inc', + 'span_width', + 'spanset_end_span', + 'spanset_hash', + 'spanset_hash_extended', + 'spanset_lower_inc', + 'spanset_num_spans', + 'spanset_span', + 'spanset_span_n', + 'spanset_spans', + 'spanset_start_span', + 'spanset_upper_inc', + 'spanset_width', + 'spatialset_to_stbox', + 'textset_end_value', + 'textset_start_value', + 'textset_value_n', + 'textset_values', + 'tstzset_end_value', + 'tstzset_start_value', + 'tstzset_value_n', + 'tstzset_values', + 'tstzspan_duration', + 'tstzspan_lower', + 'tstzspan_upper', + 'tstzspanset_duration', + 'tstzspanset_end_timestamptz', + 'tstzspanset_lower', + 'tstzspanset_num_timestamps', + 'tstzspanset_start_timestamptz', + 'tstzspanset_timestamptz_n', + 'tstzspanset_timestamps', + 'tstzspanset_upper', + 'bigintset_shift_scale', + 'bigintspan_shift_scale', + 'bigintspanset_shift_scale', + 'dateset_shift_scale', + 'dateset_to_tstzset', + 'datespan_shift_scale', + 'datespan_to_tstzspan', + 'datespanset_shift_scale', + 'datespanset_to_tstzspanset', + 'floatset_round', + 'floatset_shift_scale', + 'floatset_to_intset', + 'floatspan_round', + 'floatspan_shift_scale', + 'floatspan_to_intspan', + 'floatspanset_to_intspanset', + 'floatspanset_round', + 'floatspanset_shift_scale', + 'geoset_round', + 'intset_shift_scale', + 'intset_to_floatset', + 'intspan_shift_scale', + 'intspan_to_floatspan', + 'intspanset_to_floatspanset', + 'intspanset_shift_scale', + 'textset_lower', + 'textset_upper', + 'timestamptz_tprecision', + 'tstzset_shift_scale', + 'datespan_shift_scale', + 'tstzspan_shift_scale', + 'tstzspan_tprecision', + 'tstzset_to_dateset', + 'tstzspan_to_datespan', + 'tstzspanset_to_datespanset', + 'tstzspanset_shift_scale', + 'tstzspanset_tprecision', + 'intersection_set_bigint', + 'intersection_set_date', + 'intersection_set_float', + 'intersection_set_geo', + 'intersection_set_int', + 'intersection_set_set', + 'intersection_set_text', + 'intersection_set_timestamptz', + 'intersection_span_bigint', + 'intersection_span_date', + 'intersection_span_float', + 'intersection_span_int', + 'intersection_span_timestamptz', + 'intersection_span_span', + 'intersection_spanset_bigint', + 'intersection_spanset_date', + 'intersection_spanset_float', + 'intersection_spanset_int', + 'intersection_spanset_span', + 'intersection_spanset_spanset', + 'intersection_spanset_timestamptz', + 'minus_bigint_set', + 'minus_bigint_span', + 'minus_bigint_spanset', + 'minus_date_set', + 'minus_date_span', + 'minus_date_spanset', + 'minus_float_set', + 'minus_float_span', + 'minus_float_spanset', + 'minus_geo_set', + 'minus_int_set', + 'minus_int_span', + 'minus_int_spanset', + 'minus_set_bigint', + 'minus_set_date', + 'minus_set_float', + 'minus_set_geo', + 'minus_set_int', + 'minus_set_set', + 'minus_set_text', + 'minus_set_timestamptz', + 'minus_span_bigint', + 'minus_span_date', + 'minus_span_float', + 'minus_span_int', + 'minus_span_span', + 'minus_span_spanset', + 'minus_span_timestamptz', + 'minus_spanset_bigint', + 'minus_spanset_date', + 'minus_spanset_float', + 'minus_spanset_int', + 'minus_spanset_span', + 'minus_spanset_spanset', + 'minus_spanset_timestamptz', + 'minus_text_set', + 'minus_timestamptz_span', + 'minus_timestamptz_spanset', + 'minus_timestamptz_set', + 'super_union_span_span', + 'union_set_bigint', + 'union_set_date', + 'union_set_float', + 'union_set_geo', + 'union_set_int', + 'union_set_set', + 'union_set_text', + 'union_set_timestamptz', + 'union_span_bigint', + 'union_span_date', + 'union_span_float', + 'union_span_int', + 'union_span_span', + 'union_span_timestamptz', + 'union_spanset_bigint', + 'union_spanset_date', + 'union_spanset_float', + 'union_spanset_int', + 'union_spanset_span', + 'union_spanset_spanset', + 'union_spanset_timestamptz', + 'adjacent_span_bigint', + 'adjacent_span_date', + 'adjacent_span_float', + 'adjacent_span_int', + 'adjacent_span_span', + 'adjacent_span_timestamptz', + 'adjacent_spanset_bigint', + 'adjacent_spanset_date', + 'adjacent_spanset_float', + 'adjacent_spanset_int', + 'adjacent_spanset_timestamptz', + 'adjacent_spanset_span', + 'adjacent_spanset_spanset', + 'contained_bigint_set', + 'contained_bigint_span', + 'contained_bigint_spanset', + 'contained_date_set', + 'contained_date_span', + 'contained_date_spanset', + 'contained_float_set', + 'contained_float_span', + 'contained_float_spanset', + 'contained_geo_set', + 'contained_int_set', + 'contained_int_span', + 'contained_int_spanset', + 'contained_set_set', + 'contained_span_span', + 'contained_span_spanset', + 'contained_spanset_span', + 'contained_spanset_spanset', + 'contained_text_set', + 'contained_timestamptz_set', + 'contained_timestamptz_span', + 'contained_timestamptz_spanset', + 'contains_set_bigint', + 'contains_set_date', + 'contains_set_float', + 'contains_set_geo', + 'contains_set_int', + 'contains_set_set', + 'contains_set_text', + 'contains_set_timestamptz', + 'contains_span_bigint', + 'contains_span_float', + 'contains_span_int', + 'contains_span_span', + 'contains_span_spanset', + 'contains_span_timestamptz', + 'contains_span_date', + 'contains_spanset_bigint', + 'contains_spanset_float', + 'contains_spanset_int', + 'contains_spanset_span', + 'contains_spanset_spanset', + 'contains_spanset_timestamptz', + 'contains_spanset_date', + 'overlaps_set_set', + 'overlaps_span_span', + 'overlaps_spanset_span', + 'overlaps_spanset_spanset', + 'after_date_set', + 'after_date_span', + 'after_date_spanset', + 'after_set_date', + 'after_set_timestamptz', + 'after_span_date', + 'after_span_timestamptz', + 'after_spanset_date', + 'after_spanset_timestamptz', + 'after_timestamptz_set', + 'after_timestamptz_span', + 'after_timestamptz_spanset', + 'before_date_set', + 'before_date_span', + 'before_date_spanset', + 'before_set_date', + 'before_set_timestamptz', + 'before_span_date', + 'before_span_timestamptz', + 'before_spanset_date', + 'before_spanset_timestamptz', + 'before_timestamptz_set', + 'before_timestamptz_span', + 'before_timestamptz_spanset', + 'left_bigint_set', + 'left_bigint_span', + 'left_bigint_spanset', + 'left_float_set', + 'left_float_span', + 'left_float_spanset', + 'left_int_set', + 'left_int_span', + 'left_int_spanset', + 'left_set_bigint', + 'left_set_float', + 'left_set_int', + 'left_set_set', + 'left_set_text', + 'left_span_bigint', + 'left_span_float', + 'left_span_int', + 'left_span_span', + 'left_span_spanset', + 'left_spanset_bigint', + 'left_spanset_float', + 'left_spanset_int', + 'left_spanset_span', + 'left_spanset_spanset', + 'left_text_set', + 'overafter_set_date', + 'overafter_set_timestamptz', + 'overafter_span_timestamptz', + 'overafter_span_date', + 'overafter_spanset_timestamptz', + 'overafter_spanset_date', + 'overafter_timestamptz_set', + 'overafter_timestamptz_span', + 'overafter_timestamptz_spanset', + 'overbefore_set_date', + 'overbefore_set_timestamptz', + 'overbefore_span_timestamptz', + 'overbefore_span_date', + 'overbefore_spanset_timestamptz', + 'overbefore_spanset_date', + 'overbefore_timestamptz_set', + 'overbefore_timestamptz_span', + 'overbefore_timestamptz_spanset', + 'overleft_bigint_set', + 'overleft_bigint_span', + 'overleft_bigint_spanset', + 'overleft_float_set', + 'overleft_float_span', + 'overleft_float_spanset', + 'overleft_int_set', + 'overleft_int_span', + 'overleft_int_spanset', + 'overleft_set_bigint', + 'overleft_set_float', + 'overleft_set_int', + 'overleft_set_set', + 'overleft_set_text', + 'overleft_span_bigint', + 'overleft_span_float', + 'overleft_span_int', + 'overleft_span_span', + 'overleft_span_spanset', + 'overleft_spanset_bigint', + 'overleft_spanset_float', + 'overleft_spanset_int', + 'overleft_spanset_span', + 'overleft_spanset_spanset', + 'overleft_text_set', + 'overright_bigint_set', + 'overright_bigint_span', + 'overright_bigint_spanset', + 'overright_float_set', + 'overright_float_span', + 'overright_float_spanset', + 'overright_int_set', + 'overright_int_span', + 'overright_int_spanset', + 'overright_set_bigint', + 'overright_set_float', + 'overright_set_int', + 'overright_set_set', + 'overright_set_text', + 'overright_span_bigint', + 'overright_span_float', + 'overright_span_int', + 'overright_span_span', + 'overright_span_spanset', + 'overright_spanset_bigint', + 'overright_spanset_float', + 'overright_spanset_int', + 'overright_spanset_span', + 'overright_spanset_spanset', + 'overright_text_set', + 'right_bigint_set', + 'right_bigint_span', + 'right_bigint_spanset', + 'right_float_set', + 'right_float_span', + 'right_float_spanset', + 'right_int_set', + 'right_int_span', + 'right_int_spanset', + 'right_set_bigint', + 'right_set_float', + 'right_set_int', + 'right_set_set', + 'right_set_text', + 'right_span_bigint', + 'right_span_float', + 'right_span_int', + 'right_span_span', + 'right_span_spanset', + 'right_spanset_bigint', + 'right_spanset_float', + 'right_spanset_int', + 'right_spanset_span', + 'right_spanset_spanset', + 'right_text_set', + 'distance_set_bigint', + 'distance_set_float', + 'distance_set_int', + 'distance_set_set', + 'distance_set_timestamptz', + 'distance_set_date', + 'distance_span_bigint', + 'distance_span_float', + 'distance_span_int', + 'distance_span_span', + 'distance_span_timestamptz', + 'distance_span_date', + 'distance_spanset_bigint', + 'distance_spanset_float', + 'distance_spanset_int', + 'distance_spanset_timestamptz', + 'distance_spanset_date', + 'distance_spanset_span', + 'distance_spanset_spanset', + 'set_cmp', + 'set_eq', + 'set_ge', + 'set_gt', + 'set_le', + 'set_lt', + 'set_ne', + 'span_cmp', + 'span_eq', + 'span_ge', + 'span_gt', + 'span_le', + 'span_lt', + 'span_ne', + 'spanset_cmp', + 'spanset_eq', + 'spanset_ge', + 'spanset_gt', + 'spanset_le', + 'spanset_lt', + 'spanset_ne', + 'bigint_extent_transfn', + 'bigint_union_transfn', + 'float_extent_transfn', + 'float_union_transfn', + 'int_extent_transfn', + 'int_union_transfn', + 'set_extent_transfn', + 'set_union_finalfn', + 'set_union_transfn', + 'span_extent_transfn', + 'span_union_transfn', + 'spanset_extent_transfn', + 'spanset_union_finalfn', + 'spanset_union_transfn', + 'text_union_transfn', + 'timestamptz_extent_transfn', + 'timestamptz_tcount_transfn', + 'timestamptz_union_transfn', + 'tstzset_tcount_transfn', + 'tstzspan_tcount_transfn', + 'tstzspanset_tcount_transfn', + 'tbox_in', + 'tbox_out', + 'tbox_from_wkb', + 'tbox_from_hexwkb', + 'stbox_from_wkb', + 'stbox_from_hexwkb', + 'tbox_as_wkb', + 'tbox_as_hexwkb', + 'stbox_as_wkb', + 'stbox_as_hexwkb', + 'stbox_in', + 'stbox_out', + 'float_tstzspan_to_tbox', + 'float_timestamptz_to_tbox', + 'geo_tstzspan_to_stbox', + 'geo_timestamptz_to_stbox', + 'int_tstzspan_to_tbox', + 'int_timestamptz_to_tbox', + 'numspan_tstzspan_to_tbox', + 'numspan_timestamptz_to_tbox', + 'stbox_copy', + 'stbox_make', + 'tbox_copy', + 'tbox_make', + 'box3d_to_stbox', + 'gbox_to_stbox', + 'float_to_tbox', + 'geo_to_stbox', + 'int_to_tbox', + 'numset_to_tbox', + 'numspan_to_tbox', + 'numspanset_to_tbox', + 'tstzspan_to_stbox', + 'tstzspan_to_tbox', + 'tstzspanset_to_stbox', + 'tstzspanset_to_tbox', + 'stbox_to_gbox', + 'stbox_to_box3d', + 'stbox_to_geo', + 'stbox_to_tstzspan', + 'tbox_to_intspan', + 'tbox_to_floatspan', + 'tbox_to_tstzspan', + 'timestamptz_to_stbox', + 'timestamptz_to_tbox', + 'tstzset_to_stbox', + 'tstzset_to_tbox', + 'tnumber_to_tbox', + 'tpoint_to_stbox', + 'stbox_hast', + 'stbox_hasx', + 'stbox_hasz', + 'stbox_isgeodetic', + 'stbox_srid', + 'stbox_tmax', + 'stbox_tmax_inc', + 'stbox_tmin', + 'stbox_tmin_inc', + 'stbox_xmax', + 'stbox_xmin', + 'stbox_ymax', + 'stbox_ymin', + 'stbox_zmax', + 'stbox_zmin', + 'tbox_hast', + 'tbox_hasx', + 'tbox_tmax', + 'tbox_tmax_inc', + 'tbox_tmin', + 'tbox_tmin_inc', + 'tbox_xmax', + 'tbox_xmax_inc', + 'tbox_xmin', + 'tbox_xmin_inc', + 'tboxfloat_xmax', + 'tboxfloat_xmin', + 'tboxint_xmax', + 'tboxint_xmin', + 'stbox_expand_space', + 'stbox_expand_time', + 'stbox_get_space', + 'stbox_round', + 'stbox_set_srid', + 'stbox_shift_scale_time', + 'tbox_expand_time', + 'tbox_expand_float', + 'tbox_expand_int', + 'tbox_round', + 'tbox_shift_scale_float', + 'tbox_shift_scale_int', + 'tbox_shift_scale_time', + 'union_tbox_tbox', + 'inter_tbox_tbox', + 'intersection_tbox_tbox', + 'union_stbox_stbox', + 'inter_stbox_stbox', + 'intersection_stbox_stbox', + 'contains_tbox_tbox', + 'contained_tbox_tbox', + 'overlaps_tbox_tbox', + 'same_tbox_tbox', + 'adjacent_tbox_tbox', + 'contains_stbox_stbox', + 'contained_stbox_stbox', + 'overlaps_stbox_stbox', + 'same_stbox_stbox', + 'adjacent_stbox_stbox', + 'left_tbox_tbox', + 'overleft_tbox_tbox', + 'right_tbox_tbox', + 'overright_tbox_tbox', + 'before_tbox_tbox', + 'overbefore_tbox_tbox', + 'after_tbox_tbox', + 'overafter_tbox_tbox', + 'left_stbox_stbox', + 'overleft_stbox_stbox', + 'right_stbox_stbox', + 'overright_stbox_stbox', + 'below_stbox_stbox', + 'overbelow_stbox_stbox', + 'above_stbox_stbox', + 'overabove_stbox_stbox', + 'front_stbox_stbox', + 'overfront_stbox_stbox', + 'back_stbox_stbox', + 'overback_stbox_stbox', + 'before_stbox_stbox', + 'overbefore_stbox_stbox', + 'after_stbox_stbox', + 'overafter_stbox_stbox', + 'stbox_quad_split', + 'tbox_eq', + 'tbox_ne', + 'tbox_cmp', + 'tbox_lt', + 'tbox_le', + 'tbox_ge', + 'tbox_gt', + 'stbox_eq', + 'stbox_ne', + 'stbox_cmp', + 'stbox_lt', + 'stbox_le', + 'stbox_ge', + 'stbox_gt', + 'tbool_in', + 'tbool_out', + 'temporal_as_hexwkb', + 'temporal_as_mfjson', + 'temporal_as_wkb', + 'temporal_from_hexwkb', + 'temporal_from_mfjson', + 'temporal_from_wkb', + 'tfloat_in', + 'tfloat_out', + 'tgeogpoint_in', + 'tgeompoint_in', + 'tint_in', + 'tint_out', + 'tpoint_as_ewkt', + 'tpoint_as_text', + 'tpoint_out', + 'ttext_in', + 'ttext_out', + 'temporal_cp', + 'tbool_from_base_temp', + 'tboolinst_make', + 'tboolseq_from_base_tstzset', + 'tboolseq_from_base_tstzspan', + 'tboolseqset_from_base_tstzspanset', + 'temporal_copy', + 'tfloat_from_base_temp', + 'tfloatinst_make', + 'tfloatseq_from_base_tstzspan', + 'tfloatseq_from_base_tstzset', + 'tfloatseqset_from_base_tstzspanset', + 'tint_from_base_temp', + 'tintinst_make', + 'tintseq_from_base_tstzspan', + 'tintseq_from_base_tstzset', + 'tintseqset_from_base_tstzspanset', + 'tpoint_from_base_temp', + 'tpointinst_make', + 'tpointseq_from_base_tstzspan', + 'tpointseq_from_base_tstzset', + 'tpointseqset_from_base_tstzspanset', + 'tsequence_make', + 'tsequenceset_make', + 'tsequenceset_make_gaps', + 'ttext_from_base_temp', + 'ttextinst_make', + 'ttextseq_from_base_tstzspan', + 'ttextseq_from_base_tstzset', + 'ttextseqset_from_base_tstzspanset', + 'temporal_to_tstzspan', + 'tfloat_to_tint', + 'tint_to_tfloat', + 'tnumber_to_span', + 'tbool_end_value', + 'tbool_start_value', + 'tbool_values', + 'temporal_duration', + 'temporal_end_instant', + 'temporal_end_sequence', + 'temporal_end_timestamptz', + 'temporal_hash', + 'temporal_instant_n', + 'temporal_instants', + 'temporal_interp', + 'temporal_max_instant', + 'temporal_min_instant', + 'temporal_num_instants', + 'temporal_num_sequences', + 'temporal_num_timestamps', + 'temporal_segments', + 'temporal_sequence_n', + 'temporal_sequences', + 'temporal_start_instant', + 'temporal_start_sequence', + 'temporal_start_timestamptz', + 'temporal_stops', + 'temporal_subtype', + 'temporal_time', + 'temporal_timestamptz_n', + 'temporal_timestamps', + 'tfloat_end_value', + 'tfloat_max_value', + 'tfloat_min_value', + 'tfloat_start_value', + 'tfloat_values', + 'tint_end_value', + 'tint_max_value', + 'tint_min_value', + 'tint_start_value', + 'tint_values', + 'tnumber_valuespans', + 'tpoint_end_value', + 'tpoint_start_value', + 'tpoint_values', + 'ttext_end_value', + 'ttext_max_value', + 'ttext_min_value', + 'ttext_start_value', + 'ttext_values', + 'temporal_scale_time', + 'temporal_set_interp', + 'temporal_shift_scale_time', + 'temporal_shift_time', + 'temporal_to_tinstant', + 'temporal_to_tsequence', + 'temporal_to_tsequenceset', + 'tfloat_scale_value', + 'tfloat_shift_scale_value', + 'tfloat_shift_value', + 'tint_scale_value', + 'tint_shift_scale_value', + 'tint_shift_value', + 'temporal_append_tinstant', + 'temporal_append_tsequence', + 'temporal_delete_tstzspan', + 'temporal_delete_tstzspanset', + 'temporal_delete_timestamptz', + 'temporal_delete_tstzset', + 'temporal_insert', + 'temporal_merge', + 'temporal_merge_array', + 'temporal_update', + 'tbool_at_value', + 'tbool_minus_value', + 'tbool_value_at_timestamptz', + 'temporal_at_max', + 'temporal_at_min', + 'temporal_at_tstzspan', + 'temporal_at_tstzspanset', + 'temporal_at_timestamptz', + 'temporal_at_tstzset', + 'temporal_at_values', + 'temporal_minus_max', + 'temporal_minus_min', + 'temporal_minus_tstzspan', + 'temporal_minus_tstzspanset', + 'temporal_minus_timestamptz', + 'temporal_minus_tstzset', + 'temporal_minus_values', + 'tfloat_at_value', + 'tfloat_minus_value', + 'tfloat_value_at_timestamptz', + 'tint_at_value', + 'tint_minus_value', + 'tint_value_at_timestamptz', + 'tnumber_at_span', + 'tnumber_at_spanset', + 'tnumber_at_tbox', + 'tnumber_minus_span', + 'tnumber_minus_spanset', + 'tnumber_minus_tbox', + 'tpoint_at_geom_time', + 'tpoint_at_stbox', + 'tpoint_at_value', + 'tpoint_minus_geom_time', + 'tpoint_minus_stbox', + 'tpoint_minus_value', + 'tpoint_value_at_timestamptz', + 'ttext_at_value', + 'ttext_minus_value', + 'ttext_value_at_timestamptz', + 'temporal_cmp', + 'temporal_eq', + 'temporal_ge', + 'temporal_gt', + 'temporal_le', + 'temporal_lt', + 'temporal_ne', + 'tbool_always_eq', + 'tbool_ever_eq', + 'tfloat_always_eq', + 'tfloat_always_le', + 'tfloat_always_lt', + 'tfloat_ever_eq', + 'tfloat_ever_le', + 'tfloat_ever_lt', + 'tint_always_eq', + 'tint_always_le', + 'tint_always_lt', + 'tint_ever_eq', + 'tint_ever_le', + 'tint_ever_lt', + 'tpoint_always_eq', + 'tpoint_ever_eq', + 'ttext_always_eq', + 'ttext_always_le', + 'ttext_always_lt', + 'ttext_ever_eq', + 'ttext_ever_le', + 'ttext_ever_lt', + 'teq_bool_tbool', + 'teq_float_tfloat', + 'teq_int_tint', + 'teq_point_tpoint', + 'teq_tbool_bool', + 'teq_temporal_temporal', + 'teq_text_ttext', + 'teq_tfloat_float', + 'teq_tpoint_point', + 'teq_tint_int', + 'teq_ttext_text', + 'tge_float_tfloat', + 'tge_int_tint', + 'tge_temporal_temporal', + 'tge_text_ttext', + 'tge_tfloat_float', + 'tge_tint_int', + 'tge_ttext_text', + 'tgt_float_tfloat', + 'tgt_int_tint', + 'tgt_temporal_temporal', + 'tgt_text_ttext', + 'tgt_tfloat_float', + 'tgt_tint_int', + 'tgt_ttext_text', + 'tle_float_tfloat', + 'tle_int_tint', + 'tle_temporal_temporal', + 'tle_text_ttext', + 'tle_tfloat_float', + 'tle_tint_int', + 'tle_ttext_text', + 'tlt_float_tfloat', + 'tlt_int_tint', + 'tlt_temporal_temporal', + 'tlt_text_ttext', + 'tlt_tfloat_float', + 'tlt_tint_int', + 'tlt_ttext_text', + 'tne_bool_tbool', + 'tne_float_tfloat', + 'tne_int_tint', + 'tne_point_tpoint', + 'tne_tbool_bool', + 'tne_temporal_temporal', + 'tne_text_ttext', + 'tne_tfloat_float', + 'tne_tpoint_point', + 'tne_tint_int', + 'tne_ttext_text', + 'adjacent_numspan_tnumber', + 'adjacent_stbox_tpoint', + 'adjacent_tbox_tnumber', + 'adjacent_temporal_temporal', + 'adjacent_temporal_tstzspan', + 'adjacent_tnumber_numspan', + 'adjacent_tnumber_tbox', + 'adjacent_tnumber_tnumber', + 'adjacent_tpoint_stbox', + 'adjacent_tpoint_tpoint', + 'adjacent_tstzspan_temporal', + 'contained_numspan_tnumber', + 'contained_stbox_tpoint', + 'contained_tbox_tnumber', + 'contained_temporal_temporal', + 'contained_temporal_tstzspan', + 'contained_tnumber_numspan', + 'contained_tnumber_tbox', + 'contained_tnumber_tnumber', + 'contained_tpoint_stbox', + 'contained_tpoint_tpoint', + 'contained_tstzspan_temporal', + 'contains_numspan_tnumber', + 'contains_stbox_tpoint', + 'contains_tbox_tnumber', + 'contains_temporal_tstzspan', + 'contains_temporal_temporal', + 'contains_tnumber_numspan', + 'contains_tnumber_tbox', + 'contains_tnumber_tnumber', + 'contains_tpoint_stbox', + 'contains_tpoint_tpoint', + 'contains_tstzspan_temporal', + 'overlaps_numspan_tnumber', + 'overlaps_stbox_tpoint', + 'overlaps_tbox_tnumber', + 'overlaps_temporal_temporal', + 'overlaps_temporal_tstzspan', + 'overlaps_tnumber_numspan', + 'overlaps_tnumber_tbox', + 'overlaps_tnumber_tnumber', + 'overlaps_tpoint_stbox', + 'overlaps_tpoint_tpoint', + 'overlaps_tstzspan_temporal', + 'same_numspan_tnumber', + 'same_stbox_tpoint', + 'same_tbox_tnumber', + 'same_temporal_temporal', + 'same_temporal_tstzspan', + 'same_tnumber_numspan', + 'same_tnumber_tbox', + 'same_tnumber_tnumber', + 'same_tpoint_stbox', + 'same_tpoint_tpoint', + 'same_tstzspan_temporal', + 'above_stbox_tpoint', + 'above_tpoint_stbox', + 'above_tpoint_tpoint', + 'after_stbox_tpoint', + 'after_tbox_tnumber', + 'after_temporal_tstzspan', + 'after_temporal_temporal', + 'after_tnumber_tbox', + 'after_tnumber_tnumber', + 'after_tpoint_stbox', + 'after_tpoint_tpoint', + 'after_tstzspan_temporal', + 'back_stbox_tpoint', + 'back_tpoint_stbox', + 'back_tpoint_tpoint', + 'before_stbox_tpoint', + 'before_tbox_tnumber', + 'before_temporal_tstzspan', + 'before_temporal_temporal', + 'before_tnumber_tbox', + 'before_tnumber_tnumber', + 'before_tpoint_stbox', + 'before_tpoint_tpoint', + 'before_tstzspan_temporal', + 'below_stbox_tpoint', + 'below_tpoint_stbox', + 'below_tpoint_tpoint', + 'front_stbox_tpoint', + 'front_tpoint_stbox', + 'front_tpoint_tpoint', + 'left_stbox_tpoint', + 'left_tbox_tnumber', + 'left_numspan_tnumber', + 'left_tnumber_numspan', + 'left_tnumber_tbox', + 'left_tnumber_tnumber', + 'left_tpoint_stbox', + 'left_tpoint_tpoint', + 'overabove_stbox_tpoint', + 'overabove_tpoint_stbox', + 'overabove_tpoint_tpoint', + 'overafter_stbox_tpoint', + 'overafter_tbox_tnumber', + 'overafter_temporal_tstzspan', + 'overafter_temporal_temporal', + 'overafter_tnumber_tbox', + 'overafter_tnumber_tnumber', + 'overafter_tpoint_stbox', + 'overafter_tpoint_tpoint', + 'overafter_tstzspan_temporal', + 'overback_stbox_tpoint', + 'overback_tpoint_stbox', + 'overback_tpoint_tpoint', + 'overbefore_stbox_tpoint', + 'overbefore_tbox_tnumber', + 'overbefore_temporal_tstzspan', + 'overbefore_temporal_temporal', + 'overbefore_tnumber_tbox', + 'overbefore_tnumber_tnumber', + 'overbefore_tpoint_stbox', + 'overbefore_tpoint_tpoint', + 'overbefore_tstzspan_temporal', + 'overbelow_stbox_tpoint', + 'overbelow_tpoint_stbox', + 'overbelow_tpoint_tpoint', + 'overfront_stbox_tpoint', + 'overfront_tpoint_stbox', + 'overfront_tpoint_tpoint', + 'overleft_numspan_tnumber', + 'overleft_stbox_tpoint', + 'overleft_tbox_tnumber', + 'overleft_tnumber_numspan', + 'overleft_tnumber_tbox', + 'overleft_tnumber_tnumber', + 'overleft_tpoint_stbox', + 'overleft_tpoint_tpoint', + 'overright_numspan_tnumber', + 'overright_stbox_tpoint', + 'overright_tbox_tnumber', + 'overright_tnumber_numspan', + 'overright_tnumber_tbox', + 'overright_tnumber_tnumber', + 'overright_tpoint_stbox', + 'overright_tpoint_tpoint', + 'right_numspan_tnumber', + 'right_stbox_tpoint', + 'right_tbox_tnumber', + 'right_tnumber_numspan', + 'right_tnumber_tbox', + 'right_tnumber_tnumber', + 'right_tpoint_stbox', + 'right_tpoint_tpoint', + 'tand_bool_tbool', + 'tand_tbool_bool', + 'tand_tbool_tbool', + 'tbool_when_true', + 'tnot_tbool', + 'tor_bool_tbool', + 'tor_tbool_bool', + 'tor_tbool_tbool', + 'add_float_tfloat', + 'add_int_tint', + 'add_tfloat_float', + 'add_tint_int', + 'add_tnumber_tnumber', + 'div_float_tfloat', + 'div_int_tint', + 'div_tfloat_float', + 'div_tint_int', + 'div_tnumber_tnumber', + 'float_degrees', + 'mult_float_tfloat', + 'mult_int_tint', + 'mult_tfloat_float', + 'mult_tint_int', + 'mult_tnumber_tnumber', + 'sub_float_tfloat', + 'sub_int_tint', + 'sub_tfloat_float', + 'sub_tint_int', + 'sub_tnumber_tnumber', + 'tfloat_round', + 'tfloatarr_round', + 'tfloat_degrees', + 'tfloat_derivative', + 'tfloat_radians', + 'tnumber_abs', + 'tnumber_angular_difference', + 'tnumber_delta_value', + 'textcat_text_ttext', + 'textcat_ttext_text', + 'textcat_ttext_ttext', + 'ttext_upper', + 'ttext_lower', + 'distance_tfloat_float', + 'distance_tint_int', + 'distance_tnumber_tnumber', + 'distance_tpoint_point', + 'distance_tpoint_tpoint', + 'nad_stbox_geo', + 'nad_stbox_stbox', + 'nad_tbox_tbox', + 'nad_tfloat_float', + 'nad_tfloat_tfloat', + 'nad_tint_int', + 'nad_tint_tint', + 'nad_tnumber_tbox', + 'nad_tpoint_geo', + 'nad_tpoint_stbox', + 'nad_tpoint_tpoint', + 'nai_tpoint_geo', + 'nai_tpoint_tpoint', + 'shortestline_tpoint_geo', + 'shortestline_tpoint_tpoint', + 'bearing_point_point', + 'bearing_tpoint_point', + 'bearing_tpoint_tpoint', + 'tpoint_angular_difference', + 'tpoint_azimuth', + 'tpoint_convex_hull', + 'tpoint_cumulative_length', + 'tpoint_direction', + 'tpoint_get_x', + 'tpoint_get_y', + 'tpoint_get_z', + 'tpoint_is_simple', + 'tpoint_length', + 'tpoint_speed', + 'tpoint_srid', + 'tpoint_stboxes', + 'tpoint_trajectory', + 'geo_expand_space', + 'geomeas_to_tpoint', + 'tgeogpoint_to_tgeompoint', + 'tgeompoint_to_tgeogpoint', + 'tpoint_AsMVTGeom', + 'tpoint_expand_space', + 'tpoint_make_simple', + 'tpoint_round', + 'tpointarr_round', + 'tpoint_set_srid', + 'tpoint_tfloat_to_geomeas', + 'econtains_geo_tpoint', + 'edisjoint_tpoint_geo', + 'edisjoint_tpoint_tpoint', + 'edwithin_tpoint_geo', + 'edwithin_tpoint_tpoint', + 'eintersects_tpoint_geo', + 'eintersects_tpoint_tpoint', + 'etouches_tpoint_geo', + 'tcontains_geo_tpoint', + 'tdisjoint_tpoint_geo', + 'tdwithin_tpoint_geo', + 'tdwithin_tpoint_tpoint', + 'tintersects_tpoint_geo', + 'ttouches_tpoint_geo', + 'tbool_tand_transfn', + 'tbool_tor_transfn', + 'temporal_extent_transfn', + 'temporal_tagg_finalfn', + 'temporal_tcount_transfn', + 'tfloat_tmax_transfn', + 'tfloat_tmin_transfn', + 'tfloat_tsum_transfn', + 'tint_tmax_transfn', + 'tint_tmin_transfn', + 'tint_tsum_transfn', + 'tnumber_extent_transfn', + 'tnumber_integral', + 'tnumber_tavg_finalfn', + 'tnumber_tavg_transfn', + 'tnumber_twavg', + 'tpoint_extent_transfn', + 'tpoint_tcentroid_finalfn', + 'tpoint_tcentroid_transfn', + 'tpoint_twcentroid', + 'ttext_tmax_transfn', + 'ttext_tmin_transfn', + 'temporal_simplify_min_dist', + 'temporal_simplify_min_tdelta', + 'temporal_simplify_dp', + 'temporal_simplify_max_dist', + 'temporal_tprecision', + 'temporal_tsample', + 'temporal_dyntimewarp_distance', + 'temporal_dyntimewarp_path', + 'temporal_frechet_distance', + 'temporal_frechet_path', + 'temporal_hausdorff_distance', + 'float_bucket', + 'floatspan_bucket_list', + 'int_bucket', + 'intspan_bucket_list', + 'tstzspan_bucket_list', + 'stbox_tile', + 'stbox_tile_list', + 'tintbox_tile_list', + 'tfloatbox_tile_list', + 'temporal_time_split', + 'tfloat_value_split', + 'tfloat_value_time_split', + 'timestamptz_bucket', + 'tint_value_split', + 'tint_value_time_split', + 'tpoint_space_split', + 'tpoint_space_time_split', + 'temptype_subtype', + 'temptype_subtype_all', + 'tempsubtype_name', + 'tempsubtype_from_string', + 'meosoper_name', + 'meosoper_from_string', + 'interptype_name', + 'interptype_from_string', + 'meostype_name', + 'temptype_basetype', + 'settype_basetype', + 'spantype_basetype', + 'spantype_spansettype', + 'spansettype_spantype', + 'basetype_spantype', + 'basetype_settype', + 'meostype_internal', + 'meos_basetype', + 'alpha_basetype', + 'tnumber_basetype', + 'alphanum_basetype', + 'geo_basetype', + 'spatial_basetype', + 'time_type', + 'set_basetype', + 'set_type', + 'numset_type', + 'ensure_numset_type', + 'timeset_type', + 'ensure_timeset_type', + 'set_spantype', + 'ensure_set_spantype', + 'alphanumset_type', + 'geoset_type', + 'ensure_geoset_type', + 'spatialset_type', + 'ensure_spatialset_type', + 'span_basetype', + 'span_canon_basetype', + 'span_type', + 'span_bbox_type', + 'numspan_basetype', + 'numspan_type', + 'ensure_numspan_type', + 'timespan_basetype', + 'timespan_type', + 'ensure_timespan_type', + 'spanset_type', + 'numspanset_type', + 'timespanset_type', + 'ensure_timespanset_type', + 'temporal_type', + 'temporal_basetype', + 'temptype_continuous', + 'basetype_byvalue', + 'basetype_varlength', + 'basetype_length', + 'talphanum_type', + 'talpha_type', + 'tnumber_type', + 'ensure_tnumber_type', + 'tnumber_basetype', + 'ensure_tnumber_basetype', + 'tnumber_settype', + 'tnumber_spantype', + 'tnumber_spansettype', + 'tspatial_type', + 'ensure_tspatial_type', + 'tspatial_basetype', + 'tgeo_type', + 'ensure_tgeo_type', + 'ensure_tnumber_tgeo_type', + 'datum_hash', + 'datum_hash_extended', + 'set_in', + 'set_out', + 'span_in', + 'span_out', + 'spanset_in', + 'spanset_out', + 'set_compact', + 'set_cp', + 'set_make', + 'set_make_exp', + 'set_make_free', + 'set_out', + 'span_cp', + 'span_make', + 'span_out', + 'span_set', + 'spanset_cp', + 'spanset_compact', + 'spanset_make_exp', + 'spanset_make_free', + 'spanset_out', + 'span_spanset', + 'value_to_set', + 'value_to_span', + 'value_to_spanset', + 'set_end_value', + 'set_mem_size', + 'set_set_span', + 'set_span', + 'set_start_value', + 'set_value_n', + 'set_values', + 'spanset_lower', + 'spanset_mem_size', + 'spanset_upper', + 'spatialset_set_stbox', + 'value_set_span', + 'datespan_set_tstzspan', + 'floatspan_rnd', + 'floatspan_set_intspan', + 'floatspan_set_numspan', + 'intspan_set_floatspan', + 'numset_shift_scale', + 'numspan_set_floatspan', + 'numspan_shift_scale', + 'numspanset_shift_scale', + 'set_compact', + 'span_expand', + 'spanset_compact', + 'tstzspan_set_datespan', + 'set_cmp1', + 'set_eq1', + 'span_cmp1', + 'span_eq1', + 'spanset_cmp1', + 'spanset_eq1', + 'spanbase_extent_transfn', + 'value_union_transfn', + 'adj_span_span', + 'adjacent_span_value', + 'adjacent_spanset_value', + 'cont_span_span', + 'contains_span_value', + 'contains_spanset_value', + 'contains_set_value', + 'contains_set_set', + 'contained_value_span', + 'contained_value_set', + 'contained_set_set', + 'contained_value_spanset', + 'over_span_span', + 'over_adj_span_span', + 'overlaps_value_span', + 'overlaps_value_spanset', + 'overlaps_span_value', + 'overlaps_spanset_value', + 'overlaps_set_set', + 'left_notadj_span_span', + 'left_set_set', + 'left_set_value', + 'left_span_value', + 'left_spanset_value', + 'left_value_set', + 'left_value_span', + 'left_value_spanset', + 'lf_span_span', + 'ri_span_span', + 'right_value_set', + 'right_set_value', + 'right_set_set', + 'right_value_span', + 'right_value_spanset', + 'right_span_value', + 'right_spanset_value', + 'overleft_value_set', + 'overleft_set_value', + 'overleft_set_set', + 'overleft_value_span', + 'overleft_value_spanset', + 'overleft_span_value', + 'overleft_spanset_value', + 'overright_value_set', + 'overright_set_value', + 'overright_set_set', + 'overright_value_span', + 'overright_value_spanset', + 'overright_span_value', + 'overright_spanset_value', + 'ovlf_span_span', + 'ovri_span_span', + 'inter_span_span', + 'intersection_set_value', + 'intersection_span_value', + 'intersection_spanset_value', + 'minus_set_value', + 'minus_span_value', + 'minus_spanset_value', + 'minus_value_set', + 'minus_value_span', + 'minus_value_spanset', + 'union_set_value', + 'union_span_value', + 'union_spanset_value', + 'dist_set_set', + 'dist_span_span', + 'distance_value_value', + 'distance_span_value', + 'distance_spanset_value', + 'distance_value_set', + 'distance_set_value', + 'datum_hash', + 'datum_hash_extended', + 'number_tstzspan_to_tbox', + 'number_timestamptz_to_tbox', + 'stbox_cp', + 'stbox_set', + 'tbox_cp', + 'tbox_set', + 'float_set_tbox', + 'geo_set_stbox', + 'geoarr_set_stbox', + 'int_set_tbox', + 'number_set_tbox', + 'number_to_tbox', + 'numset_set_tbox', + 'numspan_set_tbox', + 'numspanset_set_tbox', + 'tstzspan_set_stbox', + 'tstzspan_set_tbox', + 'tstzspanset_set_stbox', + 'tstzspanset_set_tbox', + 'stbox_set_box3d', + 'stbox_set_gbox', + 'timestamptz_set_stbox', + 'timestamptz_set_tbox', + 'tstzset_set_stbox', + 'tstzset_set_tbox', + 'tbox_shift_scale_value', + 'stbox_expand', + 'tbox_expand', + 'bbox_union_span_span', + 'inter_stbox_stbox', + 'inter_tbox_tbox', + 'geoarr_as_text', + 'tboolinst_as_mfjson', + 'tboolinst_from_mfjson', + 'tboolinst_in', + 'tboolseq_as_mfjson', + 'tboolseq_from_mfjson', + 'tboolseq_in', + 'tboolseqset_as_mfjson', + 'tboolseqset_from_mfjson', + 'tboolseqset_in', + 'temporal_in', + 'temporal_out', + 'temporal_values', + 'temporalarr_out', + 'tfloatinst_as_mfjson', + 'tfloatinst_from_mfjson', + 'tfloatinst_in', + 'tfloatseq_as_mfjson', + 'tfloatseq_from_mfjson', + 'tfloatseq_in', + 'tfloatseqset_as_mfjson', + 'tfloatseqset_from_mfjson', + 'tfloatseqset_in', + 'tgeogpointinst_from_mfjson', + 'tgeogpointinst_in', + 'tgeogpointseq_from_mfjson', + 'tgeogpointseq_in', + 'tgeogpointseqset_from_mfjson', + 'tgeogpointseqset_in', + 'tgeompointinst_from_mfjson', + 'tgeompointinst_in', + 'tgeompointseq_from_mfjson', + 'tgeompointseq_in', + 'tgeompointseqset_from_mfjson', + 'tgeompointseqset_in', + 'tinstant_as_mfjson', + 'tinstant_from_mfjson', + 'tinstant_in', + 'tinstant_out', + 'tintinst_as_mfjson', + 'tintinst_from_mfjson', + 'tintinst_in', + 'tintseq_as_mfjson', + 'tintseq_from_mfjson', + 'tintseq_in', + 'tintseqset_as_mfjson', + 'tintseqset_from_mfjson', + 'tintseqset_in', + 'tpointarr_as_text', + 'tpointinst_as_mfjson', + 'tpointseq_as_mfjson', + 'tpointseqset_as_mfjson', + 'tsequence_as_mfjson', + 'tsequence_from_mfjson', + 'tsequence_in', + 'tsequence_out', + 'tsequenceset_as_mfjson', + 'tsequenceset_from_mfjson', + 'tsequenceset_in', + 'tsequenceset_out', + 'ttextinst_as_mfjson', + 'ttextinst_from_mfjson', + 'ttextinst_in', + 'ttextseq_as_mfjson', + 'ttextseq_from_mfjson', + 'ttextseq_in', + 'ttextseqset_as_mfjson', + 'ttextseqset_from_mfjson', + 'ttextseqset_in', + 'temporal_cp', + 'temporal_from_base_temp', + 'tinstant_copy', + 'tinstant_make', + 'tpointseq_make_coords', + 'tsequence_from_base_tstzset', + 'tsequence_make_exp', + 'tsequence_compact', + 'tsequence_restart', + 'tsequence_subseq', + 'tsequence_copy', + 'tsequence_from_base_tstzspan', + 'tsequence_make_free', + 'tsequenceset_make_exp', + 'tsequenceset_compact', + 'tsequenceset_make_free', + 'tsequenceset_restart', + 'tsequenceset_copy', + 'tseqsetarr_to_tseqset', + 'tsequenceset_from_base_tstzspanset', + 'temporal_set_tstzspan', + 'tinstant_set_tstzspan', + 'tnumber_span', + 'tsequence_set_tstzspan', + 'tsequenceset_set_tstzspan', + 'temporal_end_value', + 'temporal_max_value', + 'temporal_mem_size', + 'temporal_min_value', + 'temporal_set_bbox', + 'tfloatseq_derivative', + 'tfloatseqset_derivative', + 'tnumber_set_span', + 'temporal_start_value', + 'tnumberinst_abs', + 'tnumberseq_abs', + 'tnumberseqset_abs', + 'tnumberseq_angular_difference', + 'tnumberseqset_angular_difference', + 'tnumberseq_delta_value', + 'tnumberseqset_delta_value', + 'tnumberinst_valuespans', + 'tnumberseq_valuespans', + 'tnumberseqset_valuespans', + 'tinstant_hash', + 'tinstant_instants', + 'tinstant_set_bbox', + 'tinstant_time', + 'tinstant_timestamps', + 'tinstant_value', + 'tinstant_value_at_timestamptz', + 'tinstant_value_copy', + 'tinstant_values', + 'tsequence_duration', + 'tsequence_end_timestamptz', + 'tsequence_hash', + 'tsequence_instants', + 'tsequence_max_instant', + 'tsequence_max_value', + 'tsequence_min_instant', + 'tsequence_min_value', + 'tsequence_segments', + 'tsequence_sequences', + 'tsequence_set_bbox', + 'tsequence_expand_bbox', + 'tsequenceset_expand_bbox', + 'tsequence_start_timestamptz', + 'tsequence_time', + 'tsequence_timestamps', + 'tsequence_value_at_timestamptz', + 'tsequence_values', + 'tsequenceset_duration', + 'tsequenceset_end_timestamptz', + 'tsequenceset_hash', + 'tsequenceset_inst_n', + 'tsequenceset_instants', + 'tsequenceset_max_instant', + 'tsequenceset_max_value', + 'tsequenceset_min_instant', + 'tsequenceset_min_value', + 'tsequenceset_num_instants', + 'tsequenceset_num_timestamps', + 'tsequenceset_segments', + 'tsequenceset_sequences', + 'tsequenceset_sequences_p', + 'tsequenceset_set_bbox', + 'tsequenceset_start_timestamptz', + 'tsequenceset_time', + 'tsequenceset_timespan', + 'tsequenceset_timestamptz_n', + 'tsequenceset_timestamps', + 'tsequenceset_value_at_timestamptz', + 'tsequenceset_values', + 'tinstant_merge', + 'tinstant_merge_array', + 'tinstant_shift_time', + 'tinstant_to_tsequence', + 'tinstant_to_tsequenceset', + 'tnumber_shift_scale_value', + 'tnuminst_shift_value', + 'tnumberseq_shift_scale_value', + 'tsequence_append_tinstant', + 'tsequence_append_tsequence', + 'tsequence_merge', + 'tsequence_merge_array', + 'tsequence_set_interp', + 'tsequence_shift_scale_time', + 'tsequence_to_tinstant', + 'tsequence_to_tdiscseq', + 'tsequence_to_tcontseq', + 'tsequence_to_tsequenceset', + 'tsequence_to_tsequenceset_interp', + 'tsequenceset_append_tinstant', + 'tsequenceset_append_tsequence', + 'tsequenceset_merge', + 'tsequenceset_merge_array', + 'tsequenceset_set_interp', + 'tnumberseqset_shift_scale_value', + 'tsequenceset_shift_scale_time', + 'tsequenceset_to_tinstant', + 'tsequenceset_to_discrete', + 'tsequenceset_to_step', + 'tsequenceset_to_linear', + 'tsequenceset_to_tsequence', + 'temporal_bbox_restrict_set', + 'temporal_restrict_minmax', + 'temporal_restrict_tstzspan', + 'temporal_restrict_tstzspanset', + 'temporal_restrict_timestamptz', + 'temporal_restrict_tstzset', + 'temporal_restrict_value', + 'temporal_restrict_values', + 'temporal_value_at_timestamptz', + 'tinstant_restrict_tstzspan', + 'tinstant_restrict_tstzspanset', + 'tinstant_restrict_timestamptz', + 'tinstant_restrict_tstzset', + 'tinstant_restrict_value', + 'tinstant_restrict_values', + 'tnumber_restrict_span', + 'tnumber_restrict_spanset', + 'tnumberinst_restrict_span', + 'tnumberinst_restrict_spanset', + 'tnumberseqset_restrict_span', + 'tnumberseqset_restrict_spanset', + 'tpoint_restrict_geom_time', + 'tpoint_restrict_stbox', + 'tpointinst_restrict_geom_time', + 'tpointinst_restrict_stbox', + 'tpointseq_restrict_geom_time', + 'tpointseq_restrict_stbox', + 'tpointseqset_restrict_geom_time', + 'tpointseqset_restrict_stbox', + 'tsequence_at_tstzspan', + 'tsequence_at_timestamptz', + 'tsequence_restrict_minmax', + 'tsequence_restrict_tstzspan', + 'tsequence_restrict_tstzspanset', + 'tsequence_restrict_timestamptz', + 'tsequence_restrict_tstzset', + 'tsequence_restrict_value', + 'tsequence_restrict_values', + 'tsequenceset_restrict_minmax', + 'tsequenceset_restrict_tstzspan', + 'tsequenceset_restrict_tstzspanset', + 'tsequenceset_restrict_timestamptz', + 'tsequenceset_restrict_tstzset', + 'tsequenceset_restrict_value', + 'tsequenceset_restrict_values', + 'tnumberseq_derivative', + 'tnumberseqset_derivative', + 'distance_tnumber_number', + 'nad_tnumber_number', + 'temporal_always_eq', + 'temporal_always_le', + 'temporal_always_lt', + 'temporal_ever_eq', + 'temporal_ever_le', + 'temporal_ever_lt', + 'tinstant_always_eq', + 'tinstant_always_le', + 'tinstant_always_lt', + 'tinstant_ever_eq', + 'tinstant_ever_le', + 'tinstant_ever_lt', + 'tpointinst_always_eq', + 'tpointinst_ever_eq', + 'tpointseq_always_eq', + 'tpointseq_ever_eq', + 'tpointseqset_always_eq', + 'tpointseqset_ever_eq', + 'tsequence_always_eq', + 'tsequence_always_le', + 'tsequence_always_lt', + 'tsequence_ever_eq', + 'tsequence_ever_le', + 'tsequence_ever_lt', + 'tsequenceset_always_eq', + 'tsequenceset_always_le', + 'tsequenceset_always_lt', + 'tsequenceset_ever_eq', + 'tsequenceset_ever_le', + 'tsequenceset_ever_lt', + 'tinstant_cmp', + 'tinstant_eq', + 'tsequence_cmp', + 'tsequence_eq', + 'tsequenceset_cmp', + 'tsequenceset_eq', + 'tpointinst_srid', + 'tpointseq_trajectory', + 'tpointseq_azimuth', + 'tpointseq_cumulative_length', + 'tpointseq_is_simple', + 'tpointseq_length', + 'tpointseq_speed', + 'tpointseq_srid', + 'tpointseq_stboxes', + 'tpointseqset_azimuth', + 'tpointseqset_cumulative_length', + 'tpointseqset_is_simple', + 'tpointseqset_length', + 'tpointseqset_speed', + 'tpointseqset_srid', + 'tpointseqset_stboxes', + 'tpointseqset_trajectory', + 'tpoint_get_coord', + 'tgeompointinst_tgeogpointinst', + 'tgeompointseq_tgeogpointseq', + 'tgeompointseqset_tgeogpointseqset', + 'tgeompoint_tgeogpoint', + 'tpointinst_set_srid', + 'tpointseq_make_simple', + 'tpointseq_set_srid', + 'tpointseqset_make_simple', + 'tpointseqset_set_srid', + 'tsequence_insert', + 'tsequenceset_insert', + 'tsequence_delete_timestamptz', + 'tsequence_delete_tstzset', + 'tsequence_delete_tstzspan', + 'tsequence_delete_tstzspanset', + 'tsequenceset_delete_timestamptz', + 'tsequenceset_delete_tstzset', + 'tsequenceset_delete_tstzspan', + 'tsequenceset_delete_tstzspanset', + 'tnumberseq_integral', + 'tnumberseq_twavg', + 'tnumberseqset_integral', + 'tnumberseqset_twavg', + 'tpointseq_twcentroid', + 'tpointseqset_twcentroid', + 'temporal_compact', + 'tsequence_compact', + 'tsequenceset_compact', + 'tbool_tand_transfn', + 'tbool_tor_transfn', + 'temporal_tagg_finalfn', + 'temporal_tcount_transfn', + 'tfloat_tmax_transfn', + 'tfloat_tmin_transfn', + 'tfloat_tsum_transfn', + 'tfloat_wmax_transfn', + 'tfloat_wmin_transfn', + 'tfloat_wsum_transfn', + 'tint_tmin_transfn', + 'tint_tmax_transfn', + 'tint_tsum_transfn', + 'tint_wmax_transfn', + 'tint_wmin_transfn', + 'tint_wsum_transfn', + 'tnumber_tavg_finalfn', + 'tnumber_tavg_transfn', + 'tnumber_wavg_transfn', + 'ttext_tmin_transfn', + 'ttext_tmax_transfn', + 'tnumber_value_split', + ] diff --git a/pymeos_cffi/pymeos_cffi/functions.py b/pymeos_cffi/pymeos_cffi/functions.py index 39b4768b..04be29bb 100644 --- a/pymeos_cffi/pymeos_cffi/functions.py +++ b/pymeos_cffi/pymeos_cffi/functions.py @@ -142,114 +142,112 @@ def as_tsequenceset(temporal: "Temporal *") -> "TSequenceSet *": # ----------------------------------------------------------------------------- # ----------------------End of manually-defined functions---------------------- # ----------------------------------------------------------------------------- -def lwpoint_make( - srid: "int32_t", hasz: int, hasm: int, p: "const POINT4D *" -) -> "LWPOINT *": - srid_converted = _ffi.cast("int32_t", srid) - p_converted = _ffi.cast("const POINT4D *", p) +def lwpoint_make(srid: 'int32_t', hasz: int, hasm: int, p: 'const POINT4D *') -> 'LWPOINT *': + srid_converted = _ffi.cast('int32_t', srid) + p_converted = _ffi.cast('const POINT4D *', p) result = _lib.lwpoint_make(srid_converted, hasz, hasm, p_converted) _check_error() return result if result != _ffi.NULL else None -def lwgeom_from_gserialized(g: "const GSERIALIZED *") -> "LWGEOM *": - g_converted = _ffi.cast("const GSERIALIZED *", g) +def lwgeom_from_gserialized(g: 'const GSERIALIZED *') -> 'LWGEOM *': + g_converted = _ffi.cast('const GSERIALIZED *', g) result = _lib.lwgeom_from_gserialized(g_converted) _check_error() return result if result != _ffi.NULL else None -def gserialized_from_lwgeom(geom: "LWGEOM *") -> "GSERIALIZED *": - geom_converted = _ffi.cast("LWGEOM *", geom) +def gserialized_from_lwgeom(geom: 'LWGEOM *') -> 'GSERIALIZED *': + geom_converted = _ffi.cast('LWGEOM *', geom) size_converted = _ffi.NULL result = _lib.gserialized_from_lwgeom(geom_converted, size_converted) _check_error() return result if result != _ffi.NULL else None -def lwgeom_get_srid(geom: "const LWGEOM *") -> "int32_t": - geom_converted = _ffi.cast("const LWGEOM *", geom) +def lwgeom_get_srid(geom: 'const LWGEOM *') -> 'int32_t': + geom_converted = _ffi.cast('const LWGEOM *', geom) result = _lib.lwgeom_get_srid(geom_converted) _check_error() return result if result != _ffi.NULL else None -def lwpoint_get_x(point: "const LWPOINT *") -> "double": - point_converted = _ffi.cast("const LWPOINT *", point) +def lwpoint_get_x(point: 'const LWPOINT *') -> 'double': + point_converted = _ffi.cast('const LWPOINT *', point) result = _lib.lwpoint_get_x(point_converted) _check_error() return result if result != _ffi.NULL else None -def lwpoint_get_y(point: "const LWPOINT *") -> "double": - point_converted = _ffi.cast("const LWPOINT *", point) +def lwpoint_get_y(point: 'const LWPOINT *') -> 'double': + point_converted = _ffi.cast('const LWPOINT *', point) result = _lib.lwpoint_get_y(point_converted) _check_error() return result if result != _ffi.NULL else None -def lwpoint_get_z(point: "const LWPOINT *") -> "double": - point_converted = _ffi.cast("const LWPOINT *", point) +def lwpoint_get_z(point: 'const LWPOINT *') -> 'double': + point_converted = _ffi.cast('const LWPOINT *', point) result = _lib.lwpoint_get_z(point_converted) _check_error() return result if result != _ffi.NULL else None -def lwpoint_get_m(point: "const LWPOINT *") -> "double": - point_converted = _ffi.cast("const LWPOINT *", point) +def lwpoint_get_m(point: 'const LWPOINT *') -> 'double': + point_converted = _ffi.cast('const LWPOINT *', point) result = _lib.lwpoint_get_m(point_converted) _check_error() return result if result != _ffi.NULL else None -def lwgeom_has_z(geom: "const LWGEOM *") -> "int": - geom_converted = _ffi.cast("const LWGEOM *", geom) +def lwgeom_has_z(geom: 'const LWGEOM *') -> 'int': + geom_converted = _ffi.cast('const LWGEOM *', geom) result = _lib.lwgeom_has_z(geom_converted) _check_error() return result if result != _ffi.NULL else None -def lwgeom_has_m(geom: "const LWGEOM *") -> "int": - geom_converted = _ffi.cast("const LWGEOM *", geom) +def lwgeom_has_m(geom: 'const LWGEOM *') -> 'int': + geom_converted = _ffi.cast('const LWGEOM *', geom) result = _lib.lwgeom_has_m(geom_converted) _check_error() return result if result != _ffi.NULL else None -def meos_errno() -> "int": +def meos_errno() -> 'int': result = _lib.meos_errno() _check_error() return result if result != _ffi.NULL else None -def meos_errno_set(err: int) -> "int": +def meos_errno_set(err: int) -> 'int': result = _lib.meos_errno_set(err) _check_error() return result if result != _ffi.NULL else None -def meos_errno_restore(err: int) -> "int": +def meos_errno_restore(err: int) -> 'int': result = _lib.meos_errno_restore(err) _check_error() return result if result != _ffi.NULL else None -def meos_errno_reset() -> "int": +def meos_errno_reset() -> 'int': result = _lib.meos_errno_reset() _check_error() return result if result != _ffi.NULL else None -def meos_set_datestyle(newval: str, extra: "void *") -> "bool": - newval_converted = newval.encode("utf-8") - extra_converted = _ffi.cast("void *", extra) +def meos_set_datestyle(newval: str, extra: 'void *') -> 'bool': + newval_converted = newval.encode('utf-8') + extra_converted = _ffi.cast('void *', extra) result = _lib.meos_set_datestyle(newval_converted, extra_converted) _check_error() return result if result != _ffi.NULL else None -def meos_set_intervalstyle(newval: str, extra: "Optional[int]") -> "bool": - newval_converted = newval.encode("utf-8") +def meos_set_intervalstyle(newval: str, extra: 'Optional[int]') -> 'bool': + newval_converted = newval.encode('utf-8') extra_converted = extra if extra is not None else _ffi.NULL result = _lib.meos_set_intervalstyle(newval_converted, extra_converted) _check_error() @@ -259,19 +257,19 @@ def meos_set_intervalstyle(newval: str, extra: "Optional[int]") -> "bool": def meos_get_datestyle() -> str: result = _lib.meos_get_datestyle() _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None def meos_get_intervalstyle() -> str: result = _lib.meos_get_intervalstyle() _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None def meos_initialize(tz_str: "Optional[str]") -> None: - tz_str_converted = tz_str.encode("utf-8") if tz_str is not None else _ffi.NULL + tz_str_converted = tz_str.encode('utf-8') if tz_str is not None else _ffi.NULL _lib.meos_initialize(tz_str_converted, _lib.py_error_handler) @@ -280,8 +278,8 @@ def meos_finalize() -> None: _check_error() -def bool_in(in_str: str) -> "bool": - in_str_converted = in_str.encode("utf-8") +def bool_in(in_str: str) -> 'bool': + in_str_converted = in_str.encode('utf-8') result = _lib.bool_in(in_str_converted) _check_error() return result if result != _ffi.NULL else None @@ -290,119 +288,107 @@ def bool_in(in_str: str) -> "bool": def bool_out(b: bool) -> str: result = _lib.bool_out(b) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def cstring2text(cstring: str) -> "text *": - cstring_converted = cstring.encode("utf-8") +def cstring2text(cstring: str) -> 'text *': + cstring_converted = cstring.encode('utf-8') result = _lib.cstring2text(cstring_converted) return result -def pg_date_in(string: str) -> "DateADT": - string_converted = string.encode("utf-8") +def pg_date_in(string: str) -> 'DateADT': + string_converted = string.encode('utf-8') result = _lib.pg_date_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def pg_date_out(d: "DateADT") -> str: - d_converted = _ffi.cast("DateADT", d) +def pg_date_out(d: 'DateADT') -> str: + d_converted = _ffi.cast('DateADT', d) result = _lib.pg_date_out(d_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def pg_date_mi(d1: "DateADT", d2: "DateADT") -> "Interval *": - d1_converted = _ffi.cast("DateADT", d1) - d2_converted = _ffi.cast("DateADT", d2) +def pg_date_mi(d1: 'DateADT', d2: 'DateADT') -> 'Interval *': + d1_converted = _ffi.cast('DateADT', d1) + d2_converted = _ffi.cast('DateADT', d2) result = _lib.pg_date_mi(d1_converted, d2_converted) _check_error() return result if result != _ffi.NULL else None -def pg_date_mi_int(d: "DateADT", days: int) -> "DateADT": - d_converted = _ffi.cast("DateADT", d) - days_converted = _ffi.cast("int32", days) +def pg_date_mi_int(d: 'DateADT', days: int) -> 'DateADT': + d_converted = _ffi.cast('DateADT', d) + days_converted = _ffi.cast('int32', days) result = _lib.pg_date_mi_int(d_converted, days_converted) _check_error() return result if result != _ffi.NULL else None -def pg_date_pl_int(d: "DateADT", days: int) -> "DateADT": - d_converted = _ffi.cast("DateADT", d) - days_converted = _ffi.cast("int32", days) +def pg_date_pl_int(d: 'DateADT', days: int) -> 'DateADT': + d_converted = _ffi.cast('DateADT', d) + days_converted = _ffi.cast('int32', days) result = _lib.pg_date_pl_int(d_converted, days_converted) _check_error() return result if result != _ffi.NULL else None -def pg_date_timestamptz(d: "DateADT") -> "TimestampTz": - d_converted = _ffi.cast("DateADT", d) +def pg_date_timestamptz(d: 'DateADT') -> 'TimestampTz': + d_converted = _ffi.cast('DateADT', d) result = _lib.pg_date_timestamptz(d_converted) _check_error() return result if result != _ffi.NULL else None -def pg_interval_cmp( - interval1: "const Interval *", interval2: "const Interval *" -) -> "int": - interval1_converted = _ffi.cast("const Interval *", interval1) - interval2_converted = _ffi.cast("const Interval *", interval2) +def pg_interval_cmp(interval1: 'const Interval *', interval2: 'const Interval *') -> 'int': + interval1_converted = _ffi.cast('const Interval *', interval1) + interval2_converted = _ffi.cast('const Interval *', interval2) result = _lib.pg_interval_cmp(interval1_converted, interval2_converted) _check_error() return result if result != _ffi.NULL else None -def pg_interval_in(string: str, typmod: int) -> "Interval *": - string_converted = string.encode("utf-8") - typmod_converted = _ffi.cast("int32", typmod) +def pg_interval_in(string: str, typmod: int) -> 'Interval *': + string_converted = string.encode('utf-8') + typmod_converted = _ffi.cast('int32', typmod) result = _lib.pg_interval_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def pg_interval_make( - years: int, months: int, weeks: int, days: int, hours: int, mins: int, secs: float -) -> "Interval *": - years_converted = _ffi.cast("int32", years) - months_converted = _ffi.cast("int32", months) - weeks_converted = _ffi.cast("int32", weeks) - days_converted = _ffi.cast("int32", days) - hours_converted = _ffi.cast("int32", hours) - mins_converted = _ffi.cast("int32", mins) - result = _lib.pg_interval_make( - years_converted, - months_converted, - weeks_converted, - days_converted, - hours_converted, - mins_converted, - secs, - ) +def pg_interval_make(years: int, months: int, weeks: int, days: int, hours: int, mins: int, secs: float) -> 'Interval *': + years_converted = _ffi.cast('int32', years) + months_converted = _ffi.cast('int32', months) + weeks_converted = _ffi.cast('int32', weeks) + days_converted = _ffi.cast('int32', days) + hours_converted = _ffi.cast('int32', hours) + mins_converted = _ffi.cast('int32', mins) + result = _lib.pg_interval_make(years_converted, months_converted, weeks_converted, days_converted, hours_converted, mins_converted, secs) _check_error() return result if result != _ffi.NULL else None -def pg_interval_mul(span: "const Interval *", factor: float) -> "Interval *": - span_converted = _ffi.cast("const Interval *", span) +def pg_interval_mul(span: 'const Interval *', factor: float) -> 'Interval *': + span_converted = _ffi.cast('const Interval *', span) result = _lib.pg_interval_mul(span_converted, factor) _check_error() return result if result != _ffi.NULL else None -def pg_interval_out(span: "const Interval *") -> str: - span_converted = _ffi.cast("const Interval *", span) +def pg_interval_out(span: 'const Interval *') -> str: + span_converted = _ffi.cast('const Interval *', span) result = _lib.pg_interval_out(span_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def pg_interval_to_char(it: "Interval *", fmt: str) -> str: - it_converted = _ffi.cast("Interval *", it) +def pg_interval_to_char(it: 'Interval *', fmt: str) -> str: + it_converted = _ffi.cast('Interval *', it) fmt_converted = cstring2text(fmt) result = _lib.pg_interval_to_char(it_converted, fmt_converted) _check_error() @@ -410,74 +396,72 @@ def pg_interval_to_char(it: "Interval *", fmt: str) -> str: return result if result != _ffi.NULL else None -def pg_interval_pl( - span1: "const Interval *", span2: "const Interval *" -) -> "Interval *": - span1_converted = _ffi.cast("const Interval *", span1) - span2_converted = _ffi.cast("const Interval *", span2) +def pg_interval_pl(span1: 'const Interval *', span2: 'const Interval *') -> 'Interval *': + span1_converted = _ffi.cast('const Interval *', span1) + span2_converted = _ffi.cast('const Interval *', span2) result = _lib.pg_interval_pl(span1_converted, span2_converted) _check_error() return result if result != _ffi.NULL else None -def pg_time_in(string: str, typmod: int) -> "TimeADT": - string_converted = string.encode("utf-8") - typmod_converted = _ffi.cast("int32", typmod) +def pg_time_in(string: str, typmod: int) -> 'TimeADT': + string_converted = string.encode('utf-8') + typmod_converted = _ffi.cast('int32', typmod) result = _lib.pg_time_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def pg_time_out(time: "TimeADT") -> str: - time_converted = _ffi.cast("TimeADT", time) +def pg_time_out(time: 'TimeADT') -> str: + time_converted = _ffi.cast('TimeADT', time) result = _lib.pg_time_out(time_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def pg_timestamp_in(string: str, typmod: int) -> "Timestamp": - string_converted = string.encode("utf-8") - typmod_converted = _ffi.cast("int32", typmod) +def pg_timestamp_in(string: str, typmod: int) -> 'Timestamp': + string_converted = string.encode('utf-8') + typmod_converted = _ffi.cast('int32', typmod) result = _lib.pg_timestamp_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def pg_timestamp_mi(dt1: int, dt2: int) -> "Interval *": - dt1_converted = _ffi.cast("TimestampTz", dt1) - dt2_converted = _ffi.cast("TimestampTz", dt2) +def pg_timestamp_mi(dt1: int, dt2: int) -> 'Interval *': + dt1_converted = _ffi.cast('TimestampTz', dt1) + dt2_converted = _ffi.cast('TimestampTz', dt2) result = _lib.pg_timestamp_mi(dt1_converted, dt2_converted) _check_error() return result if result != _ffi.NULL else None -def pg_timestamp_mi_interval(timestamp: int, span: "const Interval *") -> "TimestampTz": - timestamp_converted = _ffi.cast("TimestampTz", timestamp) - span_converted = _ffi.cast("const Interval *", span) +def pg_timestamp_mi_interval(timestamp: int, span: 'const Interval *') -> 'TimestampTz': + timestamp_converted = _ffi.cast('TimestampTz', timestamp) + span_converted = _ffi.cast('const Interval *', span) result = _lib.pg_timestamp_mi_interval(timestamp_converted, span_converted) _check_error() return result if result != _ffi.NULL else None def pg_timestamp_out(dt: int) -> str: - dt_converted = _ffi.cast("Timestamp", dt) + dt_converted = _ffi.cast('Timestamp', dt) result = _lib.pg_timestamp_out(dt_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def pg_timestamp_pl_interval(timestamp: int, span: "const Interval *") -> "TimestampTz": - timestamp_converted = _ffi.cast("TimestampTz", timestamp) - span_converted = _ffi.cast("const Interval *", span) +def pg_timestamp_pl_interval(timestamp: int, span: 'const Interval *') -> 'TimestampTz': + timestamp_converted = _ffi.cast('TimestampTz', timestamp) + span_converted = _ffi.cast('const Interval *', span) result = _lib.pg_timestamp_pl_interval(timestamp_converted, span_converted) _check_error() return result if result != _ffi.NULL else None def pg_timestamp_to_char(dt: int, fmt: str) -> str: - dt_converted = _ffi.cast("Timestamp", dt) + dt_converted = _ffi.cast('Timestamp', dt) fmt_converted = cstring2text(fmt) result = _lib.pg_timestamp_to_char(dt_converted, fmt_converted) _check_error() @@ -485,31 +469,31 @@ def pg_timestamp_to_char(dt: int, fmt: str) -> str: return result if result != _ffi.NULL else None -def pg_timestamptz_in(string: str, typmod: int) -> "TimestampTz": - string_converted = string.encode("utf-8") - typmod_converted = _ffi.cast("int32", typmod) +def pg_timestamptz_in(string: str, typmod: int) -> 'TimestampTz': + string_converted = string.encode('utf-8') + typmod_converted = _ffi.cast('int32', typmod) result = _lib.pg_timestamptz_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def pg_timestamptz_date(t: int) -> "DateADT": - t_converted = _ffi.cast("TimestampTz", t) +def pg_timestamptz_date(t: int) -> 'DateADT': + t_converted = _ffi.cast('TimestampTz', t) result = _lib.pg_timestamptz_date(t_converted) _check_error() return result if result != _ffi.NULL else None def pg_timestamptz_out(dt: int) -> str: - dt_converted = _ffi.cast("TimestampTz", dt) + dt_converted = _ffi.cast('TimestampTz', dt) result = _lib.pg_timestamptz_out(dt_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None def pg_timestamptz_to_char(dt: int, fmt: str) -> str: - dt_converted = _ffi.cast("TimestampTz", dt) + dt_converted = _ffi.cast('TimestampTz', dt) fmt_converted = cstring2text(fmt) result = _lib.pg_timestamptz_to_char(dt_converted, fmt_converted) _check_error() @@ -517,7 +501,7 @@ def pg_timestamptz_to_char(dt: int, fmt: str) -> str: return result if result != _ffi.NULL else None -def pg_to_date(date_txt: str, fmt: str) -> "DateADT": +def pg_to_date(date_txt: str, fmt: str) -> 'DateADT': date_txt_converted = cstring2text(date_txt) fmt_converted = cstring2text(fmt) result = _lib.pg_to_date(date_txt_converted, fmt_converted) @@ -525,7 +509,7 @@ def pg_to_date(date_txt: str, fmt: str) -> "DateADT": return result if result != _ffi.NULL else None -def pg_to_timestamptz(date_txt: str, fmt: str) -> "TimestampTz": +def pg_to_timestamptz(date_txt: str, fmt: str) -> 'TimestampTz': date_txt_converted = cstring2text(date_txt) fmt_converted = cstring2text(fmt) result = _lib.pg_to_timestamptz(date_txt_converted, fmt_converted) @@ -533,9 +517,9 @@ def pg_to_timestamptz(date_txt: str, fmt: str) -> "TimestampTz": return result if result != _ffi.NULL else None -def text2cstring(textptr: "text *") -> str: +def text2cstring(textptr: 'text *') -> str: result = _lib.text2cstring(textptr) - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result @@ -543,784 +527,766 @@ def text_out(txt: str) -> str: txt_converted = cstring2text(txt) result = _lib.text_out(txt_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def geography_from_hexewkb(wkt: str) -> "GSERIALIZED *": - wkt_converted = wkt.encode("utf-8") +def geography_from_hexewkb(wkt: str) -> 'GSERIALIZED *': + wkt_converted = wkt.encode('utf-8') result = _lib.geography_from_hexewkb(wkt_converted) _check_error() return result if result != _ffi.NULL else None -def geography_from_text(wkt: str, srid: int) -> "GSERIALIZED *": - wkt_converted = wkt.encode("utf-8") +def geography_from_text(wkt: str, srid: int) -> 'GSERIALIZED *': + wkt_converted = wkt.encode('utf-8') result = _lib.geography_from_text(wkt_converted, srid) _check_error() return result if result != _ffi.NULL else None -def geometry_from_hexewkb(wkt: str) -> "GSERIALIZED *": - wkt_converted = wkt.encode("utf-8") +def geometry_from_hexewkb(wkt: str) -> 'GSERIALIZED *': + wkt_converted = wkt.encode('utf-8') result = _lib.geometry_from_hexewkb(wkt_converted) _check_error() return result if result != _ffi.NULL else None -def geometry_from_text(wkt: str, srid: int) -> "GSERIALIZED *": - wkt_converted = wkt.encode("utf-8") +def geometry_from_text(wkt: str, srid: int) -> 'GSERIALIZED *': + wkt_converted = wkt.encode('utf-8') result = _lib.geometry_from_text(wkt_converted, srid) _check_error() return result if result != _ffi.NULL else None -def gserialized_as_ewkb(gs: "const GSERIALIZED *", type: str) -> "bytea *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - type_converted = type.encode("utf-8") +def gserialized_as_ewkb(gs: 'const GSERIALIZED *', type: str) -> 'bytea *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + type_converted = type.encode('utf-8') result = _lib.gserialized_as_ewkb(gs_converted, type_converted) _check_error() return result if result != _ffi.NULL else None -def gserialized_as_ewkt(gs: "const GSERIALIZED *", precision: int) -> str: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def gserialized_as_ewkt(gs: 'const GSERIALIZED *', precision: int) -> str: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.gserialized_as_ewkt(gs_converted, precision) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def gserialized_as_geojson( - gs: "const GSERIALIZED *", option: int, precision: int, srs: "Optional[str]" -) -> str: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - srs_converted = srs.encode("utf-8") if srs is not None else _ffi.NULL +def gserialized_as_geojson(gs: 'const GSERIALIZED *', option: int, precision: int, srs: "Optional[str]") -> str: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + srs_converted = srs.encode('utf-8') if srs is not None else _ffi.NULL result = _lib.gserialized_as_geojson(gs_converted, option, precision, srs_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def gserialized_as_hexewkb(gs: "const GSERIALIZED *", type: str) -> str: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - type_converted = type.encode("utf-8") +def gserialized_as_hexewkb(gs: 'const GSERIALIZED *', type: str) -> str: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + type_converted = type.encode('utf-8') result = _lib.gserialized_as_hexewkb(gs_converted, type_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def gserialized_as_text(gs: "const GSERIALIZED *", precision: int) -> str: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def gserialized_as_text(gs: 'const GSERIALIZED *', precision: int) -> str: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.gserialized_as_text(gs_converted, precision) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def gserialized_from_ewkb(bytea_wkb: "const bytea *", srid: int) -> "GSERIALIZED *": - bytea_wkb_converted = _ffi.cast("const bytea *", bytea_wkb) - srid_converted = _ffi.cast("int32", srid) +def gserialized_from_ewkb(bytea_wkb: 'const bytea *', srid: int) -> 'GSERIALIZED *': + bytea_wkb_converted = _ffi.cast('const bytea *', bytea_wkb) + srid_converted = _ffi.cast('int32', srid) result = _lib.gserialized_from_ewkb(bytea_wkb_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def gserialized_from_geojson(geojson: str) -> "GSERIALIZED *": - geojson_converted = geojson.encode("utf-8") +def gserialized_from_geojson(geojson: str) -> 'GSERIALIZED *': + geojson_converted = geojson.encode('utf-8') result = _lib.gserialized_from_geojson(geojson_converted) _check_error() return result if result != _ffi.NULL else None -def gserialized_out(gs: "const GSERIALIZED *") -> str: - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def gserialized_out(gs: 'const GSERIALIZED *') -> str: + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.gserialized_out(gs_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def pgis_geography_in(input: str, geom_typmod: int) -> "GSERIALIZED *": - input_converted = input.encode("utf-8") - geom_typmod_converted = _ffi.cast("int32", geom_typmod) +def pgis_geography_in(input: str, geom_typmod: int) -> 'GSERIALIZED *': + input_converted = input.encode('utf-8') + geom_typmod_converted = _ffi.cast('int32', geom_typmod) result = _lib.pgis_geography_in(input_converted, geom_typmod_converted) _check_error() return result if result != _ffi.NULL else None -def pgis_geometry_in(input: str, geom_typmod: int) -> "GSERIALIZED *": - input_converted = input.encode("utf-8") - geom_typmod_converted = _ffi.cast("int32", geom_typmod) +def pgis_geometry_in(input: str, geom_typmod: int) -> 'GSERIALIZED *': + input_converted = input.encode('utf-8') + geom_typmod_converted = _ffi.cast('int32', geom_typmod) result = _lib.pgis_geometry_in(input_converted, geom_typmod_converted) _check_error() return result if result != _ffi.NULL else None -def pgis_gserialized_same( - gs1: "const GSERIALIZED *", gs2: "const GSERIALIZED *" -) -> "bool": - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) +def pgis_gserialized_same(gs1: 'const GSERIALIZED *', gs2: 'const GSERIALIZED *') -> 'bool': + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) result = _lib.pgis_gserialized_same(gs1_converted, gs2_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_in(string: str) -> "Set *": - string_converted = string.encode("utf-8") +def bigintset_in(string: str) -> 'Set *': + string_converted = string.encode('utf-8') result = _lib.bigintset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_out(set: "const Set *") -> str: - set_converted = _ffi.cast("const Set *", set) +def bigintset_out(set: 'const Set *') -> str: + set_converted = _ffi.cast('const Set *', set) result = _lib.bigintset_out(set_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def bigintspan_in(string: str) -> "Span *": - string_converted = string.encode("utf-8") +def bigintspan_in(string: str) -> 'Span *': + string_converted = string.encode('utf-8') result = _lib.bigintspan_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspan_out(s: "const Span *") -> str: - s_converted = _ffi.cast("const Span *", s) +def bigintspan_out(s: 'const Span *') -> str: + s_converted = _ffi.cast('const Span *', s) result = _lib.bigintspan_out(s_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def bigintspanset_in(string: str) -> "SpanSet *": - string_converted = string.encode("utf-8") +def bigintspanset_in(string: str) -> 'SpanSet *': + string_converted = string.encode('utf-8') result = _lib.bigintspanset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspanset_out(ss: "const SpanSet *") -> str: - ss_converted = _ffi.cast("const SpanSet *", ss) +def bigintspanset_out(ss: 'const SpanSet *') -> str: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.bigintspanset_out(ss_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def dateset_in(string: str) -> "Set *": - string_converted = string.encode("utf-8") +def dateset_in(string: str) -> 'Set *': + string_converted = string.encode('utf-8') result = _lib.dateset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def dateset_out(s: "const Set *") -> str: - s_converted = _ffi.cast("const Set *", s) +def dateset_out(s: 'const Set *') -> str: + s_converted = _ffi.cast('const Set *', s) result = _lib.dateset_out(s_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def datespan_in(string: str) -> "Span *": - string_converted = string.encode("utf-8") +def datespan_in(string: str) -> 'Span *': + string_converted = string.encode('utf-8') result = _lib.datespan_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def datespan_out(s: "const Span *") -> str: - s_converted = _ffi.cast("const Span *", s) +def datespan_out(s: 'const Span *') -> str: + s_converted = _ffi.cast('const Span *', s) result = _lib.datespan_out(s_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def datespanset_in(string: str) -> "SpanSet *": - string_converted = string.encode("utf-8") +def datespanset_in(string: str) -> 'SpanSet *': + string_converted = string.encode('utf-8') result = _lib.datespanset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def datespanset_out(ss: "const SpanSet *") -> str: - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_out(ss: 'const SpanSet *') -> str: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.datespanset_out(ss_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def floatset_in(string: str) -> "Set *": - string_converted = string.encode("utf-8") +def floatset_in(string: str) -> 'Set *': + string_converted = string.encode('utf-8') result = _lib.floatset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def floatset_out(set: "const Set *", maxdd: int) -> str: - set_converted = _ffi.cast("const Set *", set) +def floatset_out(set: 'const Set *', maxdd: int) -> str: + set_converted = _ffi.cast('const Set *', set) result = _lib.floatset_out(set_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def floatspan_in(string: str) -> "Span *": - string_converted = string.encode("utf-8") +def floatspan_in(string: str) -> 'Span *': + string_converted = string.encode('utf-8') result = _lib.floatspan_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_out(s: "const Span *", maxdd: int) -> str: - s_converted = _ffi.cast("const Span *", s) +def floatspan_out(s: 'const Span *', maxdd: int) -> str: + s_converted = _ffi.cast('const Span *', s) result = _lib.floatspan_out(s_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def floatspanset_in(string: str) -> "SpanSet *": - string_converted = string.encode("utf-8") +def floatspanset_in(string: str) -> 'SpanSet *': + string_converted = string.encode('utf-8') result = _lib.floatspanset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_out(ss: "const SpanSet *", maxdd: int) -> str: - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_out(ss: 'const SpanSet *', maxdd: int) -> str: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.floatspanset_out(ss_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def geogset_in(string: str) -> "Set *": - string_converted = string.encode("utf-8") +def geogset_in(string: str) -> 'Set *': + string_converted = string.encode('utf-8') result = _lib.geogset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def geomset_in(string: str) -> "Set *": - string_converted = string.encode("utf-8") +def geomset_in(string: str) -> 'Set *': + string_converted = string.encode('utf-8') result = _lib.geomset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_as_ewkt(set: "const Set *", maxdd: int) -> str: - set_converted = _ffi.cast("const Set *", set) +def geoset_as_ewkt(set: 'const Set *', maxdd: int) -> str: + set_converted = _ffi.cast('const Set *', set) result = _lib.geoset_as_ewkt(set_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def geoset_as_text(set: "const Set *", maxdd: int) -> str: - set_converted = _ffi.cast("const Set *", set) +def geoset_as_text(set: 'const Set *', maxdd: int) -> str: + set_converted = _ffi.cast('const Set *', set) result = _lib.geoset_as_text(set_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def geoset_out(set: "const Set *", maxdd: int) -> str: - set_converted = _ffi.cast("const Set *", set) +def geoset_out(set: 'const Set *', maxdd: int) -> str: + set_converted = _ffi.cast('const Set *', set) result = _lib.geoset_out(set_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def intset_in(string: str) -> "Set *": - string_converted = string.encode("utf-8") +def intset_in(string: str) -> 'Set *': + string_converted = string.encode('utf-8') result = _lib.intset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def intset_out(set: "const Set *") -> str: - set_converted = _ffi.cast("const Set *", set) +def intset_out(set: 'const Set *') -> str: + set_converted = _ffi.cast('const Set *', set) result = _lib.intset_out(set_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def intspan_in(string: str) -> "Span *": - string_converted = string.encode("utf-8") +def intspan_in(string: str) -> 'Span *': + string_converted = string.encode('utf-8') result = _lib.intspan_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def intspan_out(s: "const Span *") -> str: - s_converted = _ffi.cast("const Span *", s) +def intspan_out(s: 'const Span *') -> str: + s_converted = _ffi.cast('const Span *', s) result = _lib.intspan_out(s_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def intspanset_in(string: str) -> "SpanSet *": - string_converted = string.encode("utf-8") +def intspanset_in(string: str) -> 'SpanSet *': + string_converted = string.encode('utf-8') result = _lib.intspanset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def intspanset_out(ss: "const SpanSet *") -> str: - ss_converted = _ffi.cast("const SpanSet *", ss) +def intspanset_out(ss: 'const SpanSet *') -> str: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.intspanset_out(ss_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def set_as_hexwkb(s: "const Set *", variant: int) -> "Tuple[str, 'size_t *']": - s_converted = _ffi.cast("const Set *", s) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") +def set_as_hexwkb(s: 'const Set *', variant: int) -> "Tuple[str, 'size_t *']": + s_converted = _ffi.cast('const Set *', s) + variant_converted = _ffi.cast('uint8_t', variant) + size_out = _ffi.new('size_t *') result = _lib.set_as_hexwkb(s_converted, variant_converted, size_out) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None, size_out[0] -def set_as_wkb(s: "const Set *", variant: int) -> bytes: - s_converted = _ffi.cast("const Set *", s) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") +def set_as_wkb(s: 'const Set *', variant: int) -> bytes: + s_converted = _ffi.cast('const Set *', s) + variant_converted = _ffi.cast('uint8_t', variant) + size_out = _ffi.new('size_t *') result = _lib.set_as_wkb(s_converted, variant_converted, size_out) _check_error() - result_converted = ( - bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None - ) + result_converted = bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None return result_converted -def set_from_hexwkb(hexwkb: str) -> "Set *": - hexwkb_converted = hexwkb.encode("utf-8") +def set_from_hexwkb(hexwkb: str) -> 'Set *': + hexwkb_converted = hexwkb.encode('utf-8') result = _lib.set_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def set_from_wkb(wkb: bytes) -> "Set *": - wkb_converted = _ffi.new("uint8_t []", wkb) +def set_from_wkb(wkb: bytes) -> 'Set *': + wkb_converted = _ffi.new('uint8_t []', wkb) result = _lib.set_from_wkb(wkb_converted, len(wkb)) return result if result != _ffi.NULL else None -def span_as_hexwkb(s: "const Span *", variant: int) -> "Tuple[str, 'size_t *']": - s_converted = _ffi.cast("const Span *", s) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") +def span_as_hexwkb(s: 'const Span *', variant: int) -> "Tuple[str, 'size_t *']": + s_converted = _ffi.cast('const Span *', s) + variant_converted = _ffi.cast('uint8_t', variant) + size_out = _ffi.new('size_t *') result = _lib.span_as_hexwkb(s_converted, variant_converted, size_out) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None, size_out[0] -def span_as_wkb(s: "const Span *", variant: int) -> bytes: - s_converted = _ffi.cast("const Span *", s) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") +def span_as_wkb(s: 'const Span *', variant: int) -> bytes: + s_converted = _ffi.cast('const Span *', s) + variant_converted = _ffi.cast('uint8_t', variant) + size_out = _ffi.new('size_t *') result = _lib.span_as_wkb(s_converted, variant_converted, size_out) _check_error() - result_converted = ( - bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None - ) + result_converted = bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None return result_converted -def span_from_hexwkb(hexwkb: str) -> "Span *": - hexwkb_converted = hexwkb.encode("utf-8") +def span_from_hexwkb(hexwkb: str) -> 'Span *': + hexwkb_converted = hexwkb.encode('utf-8') result = _lib.span_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def span_from_wkb(wkb: bytes) -> "Span *": - wkb_converted = _ffi.new("uint8_t []", wkb) +def span_from_wkb(wkb: bytes) -> 'Span *': + wkb_converted = _ffi.new('uint8_t []', wkb) result = _lib.span_from_wkb(wkb_converted, len(wkb)) return result if result != _ffi.NULL else None -def spanset_as_hexwkb(ss: "const SpanSet *", variant: int) -> "Tuple[str, 'size_t *']": - ss_converted = _ffi.cast("const SpanSet *", ss) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") +def spanset_as_hexwkb(ss: 'const SpanSet *', variant: int) -> "Tuple[str, 'size_t *']": + ss_converted = _ffi.cast('const SpanSet *', ss) + variant_converted = _ffi.cast('uint8_t', variant) + size_out = _ffi.new('size_t *') result = _lib.spanset_as_hexwkb(ss_converted, variant_converted, size_out) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None, size_out[0] -def spanset_as_wkb(ss: "const SpanSet *", variant: int) -> bytes: - ss_converted = _ffi.cast("const SpanSet *", ss) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") +def spanset_as_wkb(ss: 'const SpanSet *', variant: int) -> bytes: + ss_converted = _ffi.cast('const SpanSet *', ss) + variant_converted = _ffi.cast('uint8_t', variant) + size_out = _ffi.new('size_t *') result = _lib.spanset_as_wkb(ss_converted, variant_converted, size_out) _check_error() - result_converted = ( - bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None - ) + result_converted = bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None return result_converted -def spanset_from_hexwkb(hexwkb: str) -> "SpanSet *": - hexwkb_converted = hexwkb.encode("utf-8") +def spanset_from_hexwkb(hexwkb: str) -> 'SpanSet *': + hexwkb_converted = hexwkb.encode('utf-8') result = _lib.spanset_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_from_wkb(wkb: bytes) -> "SpanSet *": - wkb_converted = _ffi.new("uint8_t []", wkb) +def spanset_from_wkb(wkb: bytes) -> 'SpanSet *': + wkb_converted = _ffi.new('uint8_t []', wkb) result = _lib.spanset_from_wkb(wkb_converted, len(wkb)) return result if result != _ffi.NULL else None -def textset_in(string: str) -> "Set *": - string_converted = string.encode("utf-8") +def textset_in(string: str) -> 'Set *': + string_converted = string.encode('utf-8') result = _lib.textset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def textset_out(set: "const Set *") -> str: - set_converted = _ffi.cast("const Set *", set) +def textset_out(set: 'const Set *') -> str: + set_converted = _ffi.cast('const Set *', set) result = _lib.textset_out(set_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tstzset_in(string: str) -> "Set *": - string_converted = string.encode("utf-8") +def tstzset_in(string: str) -> 'Set *': + string_converted = string.encode('utf-8') result = _lib.tstzset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_out(set: "const Set *") -> str: - set_converted = _ffi.cast("const Set *", set) +def tstzset_out(set: 'const Set *') -> str: + set_converted = _ffi.cast('const Set *', set) result = _lib.tstzset_out(set_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tstzspan_in(string: str) -> "Span *": - string_converted = string.encode("utf-8") +def tstzspan_in(string: str) -> 'Span *': + string_converted = string.encode('utf-8') result = _lib.tstzspan_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_out(s: "const Span *") -> str: - s_converted = _ffi.cast("const Span *", s) +def tstzspan_out(s: 'const Span *') -> str: + s_converted = _ffi.cast('const Span *', s) result = _lib.tstzspan_out(s_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tstzspanset_in(string: str) -> "SpanSet *": - string_converted = string.encode("utf-8") +def tstzspanset_in(string: str) -> 'SpanSet *': + string_converted = string.encode('utf-8') result = _lib.tstzspanset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_out(ss: "const SpanSet *") -> str: - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_out(ss: 'const SpanSet *') -> str: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tstzspanset_out(ss_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def bigintset_make(values: "List[const int64]") -> "Set *": - values_converted = _ffi.new("const int64 []", values) +def bigintset_make(values: 'List[const int64]') -> 'Set *': + values_converted = _ffi.new('const int64 []', values) result = _lib.bigintset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None -def bigintspan_make( - lower: int, upper: int, lower_inc: bool, upper_inc: bool -) -> "Span *": - lower_converted = _ffi.cast("int64", lower) - upper_converted = _ffi.cast("int64", upper) - result = _lib.bigintspan_make( - lower_converted, upper_converted, lower_inc, upper_inc - ) +def bigintspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> 'Span *': + lower_converted = _ffi.cast('int64', lower) + upper_converted = _ffi.cast('int64', upper) + result = _lib.bigintspan_make(lower_converted, upper_converted, lower_inc, upper_inc) _check_error() return result if result != _ffi.NULL else None -def dateset_make(values: "const DateADT *", count: int) -> "Set *": - values_converted = _ffi.cast("const DateADT *", values) +def dateset_make(values: 'const DateADT *', count: int) -> 'Set *': + values_converted = _ffi.cast('const DateADT *', values) result = _lib.dateset_make(values_converted, count) _check_error() return result if result != _ffi.NULL else None -def datespan_make( - lower: "DateADT", upper: "DateADT", lower_inc: bool, upper_inc: bool -) -> "Span *": - lower_converted = _ffi.cast("DateADT", lower) - upper_converted = _ffi.cast("DateADT", upper) +def datespan_make(lower: 'DateADT', upper: 'DateADT', lower_inc: bool, upper_inc: bool) -> 'Span *': + lower_converted = _ffi.cast('DateADT', lower) + upper_converted = _ffi.cast('DateADT', upper) result = _lib.datespan_make(lower_converted, upper_converted, lower_inc, upper_inc) _check_error() return result if result != _ffi.NULL else None -def floatset_make(values: "List[const double]") -> "Set *": - values_converted = _ffi.new("const double []", values) +def floatset_make(values: 'List[const double]') -> 'Set *': + values_converted = _ffi.new('const double []', values) result = _lib.floatset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None -def floatspan_make( - lower: float, upper: float, lower_inc: bool, upper_inc: bool -) -> "Span *": +def floatspan_make(lower: float, upper: float, lower_inc: bool, upper_inc: bool) -> 'Span *': result = _lib.floatspan_make(lower, upper, lower_inc, upper_inc) _check_error() return result if result != _ffi.NULL else None -def geoset_make(values: "const GSERIALIZED **") -> "Set *": - values_converted = [_ffi.cast("const GSERIALIZED *", x) for x in values] +def geoset_make(values: 'const GSERIALIZED **') -> 'Set *': + values_converted = [_ffi.cast('const GSERIALIZED *', x) for x in values] result = _lib.geoset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None -def intset_make(values: "List[const int]") -> "Set *": - values_converted = _ffi.new("const int []", values) +def intset_make(values: 'List[const int]') -> 'Set *': + values_converted = _ffi.new('const int []', values) result = _lib.intset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None -def intspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> "Span *": +def intspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> 'Span *': result = _lib.intspan_make(lower, upper, lower_inc, upper_inc) _check_error() return result if result != _ffi.NULL else None -def set_copy(s: "const Set *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def set_copy(s: 'const Set *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.set_copy(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_copy(s: "const Span *") -> "Span *": - s_converted = _ffi.cast("const Span *", s) +def span_copy(s: 'const Span *') -> 'Span *': + s_converted = _ffi.cast('const Span *', s) result = _lib.span_copy(s_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_copy(ss: "const SpanSet *") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_copy(ss: 'const SpanSet *') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_copy(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_make(spans: "List[Span *]", normalize: bool) -> "SpanSet *": - spans_converted = _ffi.new("Span []", spans) +def spanset_make(spans: 'List[Span *]', normalize: bool) -> 'SpanSet *': + spans_converted = _ffi.new('Span []', spans) result = _lib.spanset_make(spans_converted, len(spans), normalize) _check_error() return result if result != _ffi.NULL else None -def textset_make(values: List[str]) -> "Set *": +def textset_make(values: List[str]) -> 'Set *': values_converted = [cstring2text(x) for x in values] result = _lib.textset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None -def tstzset_make(values: List[int]) -> "Set *": - values_converted = [_ffi.cast("const TimestampTz", x) for x in values] +def tstzset_make(values: List[int]) -> 'Set *': + values_converted = [_ffi.cast('const TimestampTz', x) for x in values] result = _lib.tstzset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None -def tstzspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> "Span *": - lower_converted = _ffi.cast("TimestampTz", lower) - upper_converted = _ffi.cast("TimestampTz", upper) +def tstzspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> 'Span *': + lower_converted = _ffi.cast('TimestampTz', lower) + upper_converted = _ffi.cast('TimestampTz', upper) result = _lib.tstzspan_make(lower_converted, upper_converted, lower_inc, upper_inc) _check_error() return result if result != _ffi.NULL else None -def bigint_to_set(i: int) -> "Set *": - i_converted = _ffi.cast("int64", i) +def bigint_to_set(i: int) -> 'Set *': + i_converted = _ffi.cast('int64', i) result = _lib.bigint_to_set(i_converted) _check_error() return result if result != _ffi.NULL else None -def bigint_to_span(i: int) -> "Span *": +def bigint_to_span(i: int) -> 'Span *': result = _lib.bigint_to_span(i) _check_error() return result if result != _ffi.NULL else None -def bigint_to_spanset(i: int) -> "SpanSet *": +def bigint_to_spanset(i: int) -> 'SpanSet *': result = _lib.bigint_to_spanset(i) _check_error() return result if result != _ffi.NULL else None -def date_to_set(d: "DateADT") -> "Set *": - d_converted = _ffi.cast("DateADT", d) +def date_to_set(d: 'DateADT') -> 'Set *': + d_converted = _ffi.cast('DateADT', d) result = _lib.date_to_set(d_converted) _check_error() return result if result != _ffi.NULL else None -def date_to_span(d: "DateADT") -> "Span *": - d_converted = _ffi.cast("DateADT", d) +def date_to_span(d: 'DateADT') -> 'Span *': + d_converted = _ffi.cast('DateADT', d) result = _lib.date_to_span(d_converted) _check_error() return result if result != _ffi.NULL else None -def date_to_spanset(d: "DateADT") -> "SpanSet *": - d_converted = _ffi.cast("DateADT", d) +def date_to_spanset(d: 'DateADT') -> 'SpanSet *': + d_converted = _ffi.cast('DateADT', d) result = _lib.date_to_spanset(d_converted) _check_error() return result if result != _ffi.NULL else None -def date_to_tstzspan(d: "DateADT") -> "Span *": - d_converted = _ffi.cast("DateADT", d) +def date_to_tstzspan(d: 'DateADT') -> 'Span *': + d_converted = _ffi.cast('DateADT', d) result = _lib.date_to_tstzspan(d_converted) _check_error() return result if result != _ffi.NULL else None -def float_to_set(d: float) -> "Set *": +def float_to_set(d: float) -> 'Set *': result = _lib.float_to_set(d) _check_error() return result if result != _ffi.NULL else None -def float_to_span(d: float) -> "Span *": +def float_to_span(d: float) -> 'Span *': result = _lib.float_to_span(d) _check_error() return result if result != _ffi.NULL else None -def float_to_spanset(d: float) -> "SpanSet *": +def float_to_spanset(d: float) -> 'SpanSet *': result = _lib.float_to_spanset(d) _check_error() return result if result != _ffi.NULL else None -def geo_to_set(gs: "GSERIALIZED *") -> "Set *": - gs_converted = _ffi.cast("GSERIALIZED *", gs) +def geo_to_set(gs: 'GSERIALIZED *') -> 'Set *': + gs_converted = _ffi.cast('GSERIALIZED *', gs) result = _lib.geo_to_set(gs_converted) _check_error() return result if result != _ffi.NULL else None -def int_to_set(i: int) -> "Set *": +def int_to_set(i: int) -> 'Set *': result = _lib.int_to_set(i) _check_error() return result if result != _ffi.NULL else None -def int_to_span(i: int) -> "Span *": +def int_to_span(i: int) -> 'Span *': result = _lib.int_to_span(i) _check_error() return result if result != _ffi.NULL else None -def int_to_spanset(i: int) -> "SpanSet *": +def int_to_spanset(i: int) -> 'SpanSet *': result = _lib.int_to_spanset(i) _check_error() return result if result != _ffi.NULL else None -def set_to_spanset(s: "const Set *") -> "SpanSet *": - s_converted = _ffi.cast("const Set *", s) +def set_to_spanset(s: 'const Set *') -> 'SpanSet *': + s_converted = _ffi.cast('const Set *', s) result = _lib.set_to_spanset(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_to_spanset(s: "const Span *") -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) +def span_to_spanset(s: 'const Span *') -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) result = _lib.span_to_spanset(s_converted) _check_error() return result if result != _ffi.NULL else None -def text_to_set(txt: str) -> "Set *": +def text_to_set(txt: str) -> 'Set *': txt_converted = cstring2text(txt) result = _lib.text_to_set(txt_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_to_set(t: int) -> "Set *": - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_to_set(t: int) -> 'Set *': + t_converted = _ffi.cast('TimestampTz', t) result = _lib.timestamptz_to_set(t_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_to_span(t: int) -> "Span *": - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_to_span(t: int) -> 'Span *': + t_converted = _ffi.cast('TimestampTz', t) result = _lib.timestamptz_to_span(t_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_to_spanset(t: int) -> "SpanSet *": - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_to_spanset(t: int) -> 'SpanSet *': + t_converted = _ffi.cast('TimestampTz', t) result = _lib.timestamptz_to_spanset(t_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_end_value(s: "const Set *") -> "int64": - s_converted = _ffi.cast("const Set *", s) +def bigintset_end_value(s: 'const Set *') -> 'int64': + s_converted = _ffi.cast('const Set *', s) result = _lib.bigintset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_start_value(s: "const Set *") -> "int64": - s_converted = _ffi.cast("const Set *", s) +def bigintset_start_value(s: 'const Set *') -> 'int64': + s_converted = _ffi.cast('const Set *', s) result = _lib.bigintset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_value_n(s: "const Set *", n: int) -> "int64": - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("int64 *") +def bigintset_value_n(s: 'const Set *', n: int) -> 'int64': + s_converted = _ffi.cast('const Set *', s) + out_result = _ffi.new('int64 *') result = _lib.bigintset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1328,58 +1294,58 @@ def bigintset_value_n(s: "const Set *", n: int) -> "int64": return None -def bigintset_values(s: "const Set *") -> "int64 *": - s_converted = _ffi.cast("const Set *", s) +def bigintset_values(s: 'const Set *') -> 'int64 *': + s_converted = _ffi.cast('const Set *', s) result = _lib.bigintset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspan_lower(s: "const Span *") -> "int64": - s_converted = _ffi.cast("const Span *", s) +def bigintspan_lower(s: 'const Span *') -> 'int64': + s_converted = _ffi.cast('const Span *', s) result = _lib.bigintspan_lower(s_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspan_upper(s: "const Span *") -> "int64": - s_converted = _ffi.cast("const Span *", s) +def bigintspan_upper(s: 'const Span *') -> 'int64': + s_converted = _ffi.cast('const Span *', s) result = _lib.bigintspan_upper(s_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspanset_lower(ss: "const SpanSet *") -> "int64": - ss_converted = _ffi.cast("const SpanSet *", ss) +def bigintspanset_lower(ss: 'const SpanSet *') -> 'int64': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.bigintspanset_lower(ss_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspanset_upper(ss: "const SpanSet *") -> "int64": - ss_converted = _ffi.cast("const SpanSet *", ss) +def bigintspanset_upper(ss: 'const SpanSet *') -> 'int64': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.bigintspanset_upper(ss_converted) _check_error() return result if result != _ffi.NULL else None -def dateset_end_value(s: "const Set *") -> "DateADT": - s_converted = _ffi.cast("const Set *", s) +def dateset_end_value(s: 'const Set *') -> 'DateADT': + s_converted = _ffi.cast('const Set *', s) result = _lib.dateset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def dateset_start_value(s: "const Set *") -> "DateADT": - s_converted = _ffi.cast("const Set *", s) +def dateset_start_value(s: 'const Set *') -> 'DateADT': + s_converted = _ffi.cast('const Set *', s) result = _lib.dateset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def dateset_value_n(s: "const Set *", n: int) -> "DateADT *": - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("DateADT *") +def dateset_value_n(s: 'const Set *', n: int) -> 'DateADT *': + s_converted = _ffi.cast('const Set *', s) + out_result = _ffi.new('DateADT *') result = _lib.dateset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1387,65 +1353,65 @@ def dateset_value_n(s: "const Set *", n: int) -> "DateADT *": return None -def dateset_values(s: "const Set *") -> "DateADT *": - s_converted = _ffi.cast("const Set *", s) +def dateset_values(s: 'const Set *') -> 'DateADT *': + s_converted = _ffi.cast('const Set *', s) result = _lib.dateset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def datespan_duration(s: "const Span *") -> "Interval *": - s_converted = _ffi.cast("const Span *", s) +def datespan_duration(s: 'const Span *') -> 'Interval *': + s_converted = _ffi.cast('const Span *', s) result = _lib.datespan_duration(s_converted) _check_error() return result if result != _ffi.NULL else None -def datespan_lower(s: "const Span *") -> "DateADT": - s_converted = _ffi.cast("const Span *", s) +def datespan_lower(s: 'const Span *') -> 'DateADT': + s_converted = _ffi.cast('const Span *', s) result = _lib.datespan_lower(s_converted) _check_error() return result if result != _ffi.NULL else None -def datespan_upper(s: "const Span *") -> "DateADT": - s_converted = _ffi.cast("const Span *", s) +def datespan_upper(s: 'const Span *') -> 'DateADT': + s_converted = _ffi.cast('const Span *', s) result = _lib.datespan_upper(s_converted) _check_error() return result if result != _ffi.NULL else None -def datespanset_duration(ss: "const SpanSet *", boundspan: bool) -> "Interval *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_duration(ss: 'const SpanSet *', boundspan: bool) -> 'Interval *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.datespanset_duration(ss_converted, boundspan) _check_error() return result if result != _ffi.NULL else None -def datespanset_end_date(ss: "const SpanSet *") -> "DateADT": - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_end_date(ss: 'const SpanSet *') -> 'DateADT': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.datespanset_end_date(ss_converted) _check_error() return result if result != _ffi.NULL else None -def datespanset_num_dates(ss: "const SpanSet *") -> "int": - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_num_dates(ss: 'const SpanSet *') -> 'int': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.datespanset_num_dates(ss_converted) _check_error() return result if result != _ffi.NULL else None -def datespanset_start_date(ss: "const SpanSet *") -> "DateADT": - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_start_date(ss: 'const SpanSet *') -> 'DateADT': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.datespanset_start_date(ss_converted) _check_error() return result if result != _ffi.NULL else None -def datespanset_date_n(ss: "const SpanSet *", n: int) -> "DateADT *": - ss_converted = _ffi.cast("const SpanSet *", ss) - out_result = _ffi.new("DateADT *") +def datespanset_date_n(ss: 'const SpanSet *', n: int) -> 'DateADT *': + ss_converted = _ffi.cast('const SpanSet *', ss) + out_result = _ffi.new('DateADT *') result = _lib.datespanset_date_n(ss_converted, n, out_result) _check_error() if result: @@ -1453,31 +1419,31 @@ def datespanset_date_n(ss: "const SpanSet *", n: int) -> "DateADT *": return None -def datespanset_dates(ss: "const SpanSet *") -> "Tuple['DateADT *', 'int']": - ss_converted = _ffi.cast("const SpanSet *", ss) - count = _ffi.new("int *") +def datespanset_dates(ss: 'const SpanSet *') -> "Tuple['DateADT *', 'int']": + ss_converted = _ffi.cast('const SpanSet *', ss) + count = _ffi.new('int *') result = _lib.datespanset_dates(ss_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def floatset_end_value(s: "const Set *") -> "double": - s_converted = _ffi.cast("const Set *", s) +def floatset_end_value(s: 'const Set *') -> 'double': + s_converted = _ffi.cast('const Set *', s) result = _lib.floatset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatset_start_value(s: "const Set *") -> "double": - s_converted = _ffi.cast("const Set *", s) +def floatset_start_value(s: 'const Set *') -> 'double': + s_converted = _ffi.cast('const Set *', s) result = _lib.floatset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatset_value_n(s: "const Set *", n: int) -> "double": - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("double *") +def floatset_value_n(s: 'const Set *', n: int) -> 'double': + s_converted = _ffi.cast('const Set *', s) + out_result = _ffi.new('double *') result = _lib.floatset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1485,73 +1451,73 @@ def floatset_value_n(s: "const Set *", n: int) -> "double": return None -def floatset_values(s: "const Set *") -> "double *": - s_converted = _ffi.cast("const Set *", s) +def floatset_values(s: 'const Set *') -> 'double *': + s_converted = _ffi.cast('const Set *', s) result = _lib.floatset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_lower(s: "const Span *") -> "double": - s_converted = _ffi.cast("const Span *", s) +def floatspan_lower(s: 'const Span *') -> 'double': + s_converted = _ffi.cast('const Span *', s) result = _lib.floatspan_lower(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_upper(s: "const Span *") -> "double": - s_converted = _ffi.cast("const Span *", s) +def floatspan_upper(s: 'const Span *') -> 'double': + s_converted = _ffi.cast('const Span *', s) result = _lib.floatspan_upper(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_lower(ss: "const SpanSet *") -> "double": - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_lower(ss: 'const SpanSet *') -> 'double': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.floatspanset_lower(ss_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_upper(ss: "const SpanSet *") -> "double": - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_upper(ss: 'const SpanSet *') -> 'double': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.floatspanset_upper(ss_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_end_value(s: "const Set *") -> "GSERIALIZED *": - s_converted = _ffi.cast("const Set *", s) +def geoset_end_value(s: 'const Set *') -> 'GSERIALIZED *': + s_converted = _ffi.cast('const Set *', s) result = _lib.geoset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_srid(s: "const Set *") -> "int": - s_converted = _ffi.cast("const Set *", s) +def geoset_srid(s: 'const Set *') -> 'int': + s_converted = _ffi.cast('const Set *', s) result = _lib.geoset_srid(s_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_set_srid(s: "const Set *", srid: int) -> "Set *": - s_converted = _ffi.cast("const Set *", s) - srid_converted = _ffi.cast("int32", srid) +def geoset_set_srid(s: 'const Set *', srid: int) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + srid_converted = _ffi.cast('int32', srid) result = _lib.geoset_set_srid(s_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_start_value(s: "const Set *") -> "GSERIALIZED *": - s_converted = _ffi.cast("const Set *", s) +def geoset_start_value(s: 'const Set *') -> 'GSERIALIZED *': + s_converted = _ffi.cast('const Set *', s) result = _lib.geoset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_value_n(s: "const Set *", n: int) -> "GSERIALIZED **": - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("GSERIALIZED **") +def geoset_value_n(s: 'const Set *', n: int) -> 'GSERIALIZED **': + s_converted = _ffi.cast('const Set *', s) + out_result = _ffi.new('GSERIALIZED **') result = _lib.geoset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1559,30 +1525,30 @@ def geoset_value_n(s: "const Set *", n: int) -> "GSERIALIZED **": return None -def geoset_values(s: "const Set *") -> "GSERIALIZED **": - s_converted = _ffi.cast("const Set *", s) +def geoset_values(s: 'const Set *') -> 'GSERIALIZED **': + s_converted = _ffi.cast('const Set *', s) result = _lib.geoset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def intset_end_value(s: "const Set *") -> "int": - s_converted = _ffi.cast("const Set *", s) +def intset_end_value(s: 'const Set *') -> 'int': + s_converted = _ffi.cast('const Set *', s) result = _lib.intset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def intset_start_value(s: "const Set *") -> "int": - s_converted = _ffi.cast("const Set *", s) +def intset_start_value(s: 'const Set *') -> 'int': + s_converted = _ffi.cast('const Set *', s) result = _lib.intset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def intset_value_n(s: "const Set *", n: int) -> "int": - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("int *") +def intset_value_n(s: 'const Set *', n: int) -> 'int': + s_converted = _ffi.cast('const Set *', s) + out_result = _ffi.new('int *') result = _lib.intset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1590,210 +1556,210 @@ def intset_value_n(s: "const Set *", n: int) -> "int": return None -def intset_values(s: "const Set *") -> "int *": - s_converted = _ffi.cast("const Set *", s) +def intset_values(s: 'const Set *') -> 'int *': + s_converted = _ffi.cast('const Set *', s) result = _lib.intset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def intspan_lower(s: "const Span *") -> "int": - s_converted = _ffi.cast("const Span *", s) +def intspan_lower(s: 'const Span *') -> 'int': + s_converted = _ffi.cast('const Span *', s) result = _lib.intspan_lower(s_converted) _check_error() return result if result != _ffi.NULL else None -def intspan_upper(s: "const Span *") -> "int": - s_converted = _ffi.cast("const Span *", s) +def intspan_upper(s: 'const Span *') -> 'int': + s_converted = _ffi.cast('const Span *', s) result = _lib.intspan_upper(s_converted) _check_error() return result if result != _ffi.NULL else None -def intspanset_lower(ss: "const SpanSet *") -> "int": - ss_converted = _ffi.cast("const SpanSet *", ss) +def intspanset_lower(ss: 'const SpanSet *') -> 'int': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.intspanset_lower(ss_converted) _check_error() return result if result != _ffi.NULL else None -def intspanset_upper(ss: "const SpanSet *") -> "int": - ss_converted = _ffi.cast("const SpanSet *", ss) +def intspanset_upper(ss: 'const SpanSet *') -> 'int': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.intspanset_upper(ss_converted) _check_error() return result if result != _ffi.NULL else None -def set_hash(s: "const Set *") -> "uint32": - s_converted = _ffi.cast("const Set *", s) +def set_hash(s: 'const Set *') -> 'uint32': + s_converted = _ffi.cast('const Set *', s) result = _lib.set_hash(s_converted) _check_error() return result if result != _ffi.NULL else None -def set_hash_extended(s: "const Set *", seed: int) -> "uint64": - s_converted = _ffi.cast("const Set *", s) - seed_converted = _ffi.cast("uint64", seed) +def set_hash_extended(s: 'const Set *', seed: int) -> 'uint64': + s_converted = _ffi.cast('const Set *', s) + seed_converted = _ffi.cast('uint64', seed) result = _lib.set_hash_extended(s_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def set_num_values(s: "const Set *") -> "int": - s_converted = _ffi.cast("const Set *", s) +def set_num_values(s: 'const Set *') -> 'int': + s_converted = _ffi.cast('const Set *', s) result = _lib.set_num_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def set_to_span(s: "const Set *") -> "Span *": - s_converted = _ffi.cast("const Set *", s) +def set_to_span(s: 'const Set *') -> 'Span *': + s_converted = _ffi.cast('const Set *', s) result = _lib.set_to_span(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_hash(s: "const Span *") -> "uint32": - s_converted = _ffi.cast("const Span *", s) +def span_hash(s: 'const Span *') -> 'uint32': + s_converted = _ffi.cast('const Span *', s) result = _lib.span_hash(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_hash_extended(s: "const Span *", seed: int) -> "uint64": - s_converted = _ffi.cast("const Span *", s) - seed_converted = _ffi.cast("uint64", seed) +def span_hash_extended(s: 'const Span *', seed: int) -> 'uint64': + s_converted = _ffi.cast('const Span *', s) + seed_converted = _ffi.cast('uint64', seed) result = _lib.span_hash_extended(s_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def span_lower_inc(s: "const Span *") -> "bool": - s_converted = _ffi.cast("const Span *", s) +def span_lower_inc(s: 'const Span *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.span_lower_inc(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_upper_inc(s: "const Span *") -> "bool": - s_converted = _ffi.cast("const Span *", s) +def span_upper_inc(s: 'const Span *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.span_upper_inc(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_width(s: "const Span *") -> "double": - s_converted = _ffi.cast("const Span *", s) +def span_width(s: 'const Span *') -> 'double': + s_converted = _ffi.cast('const Span *', s) result = _lib.span_width(s_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_end_span(ss: "const SpanSet *") -> "const Span *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_end_span(ss: 'const SpanSet *') -> 'const Span *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_end_span(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_hash(ss: "const SpanSet *") -> "uint32": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_hash(ss: 'const SpanSet *') -> 'uint32': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_hash(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_hash_extended(ss: "const SpanSet *", seed: int) -> "uint64": - ss_converted = _ffi.cast("const SpanSet *", ss) - seed_converted = _ffi.cast("uint64", seed) +def spanset_hash_extended(ss: 'const SpanSet *', seed: int) -> 'uint64': + ss_converted = _ffi.cast('const SpanSet *', ss) + seed_converted = _ffi.cast('uint64', seed) result = _lib.spanset_hash_extended(ss_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_lower_inc(ss: "const SpanSet *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_lower_inc(ss: 'const SpanSet *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_lower_inc(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_num_spans(ss: "const SpanSet *") -> "int": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_num_spans(ss: 'const SpanSet *') -> 'int': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_num_spans(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_span(ss: "const SpanSet *") -> "Span *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_span(ss: 'const SpanSet *') -> 'Span *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_span(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_span_n(ss: "const SpanSet *", i: int) -> "const Span *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_span_n(ss: 'const SpanSet *', i: int) -> 'const Span *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_span_n(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def spanset_spans(ss: "const SpanSet *") -> "const Span **": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_spans(ss: 'const SpanSet *') -> 'const Span **': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_spans(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_start_span(ss: "const SpanSet *") -> "const Span *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_start_span(ss: 'const SpanSet *') -> 'const Span *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_start_span(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_upper_inc(ss: "const SpanSet *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_upper_inc(ss: 'const SpanSet *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_upper_inc(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_width(ss: "const SpanSet *", boundspan: bool) -> "double": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_width(ss: 'const SpanSet *', boundspan: bool) -> 'double': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_width(ss_converted, boundspan) _check_error() return result if result != _ffi.NULL else None -def spatialset_to_stbox(s: "const Set *") -> "STBox *": - s_converted = _ffi.cast("const Set *", s) +def spatialset_to_stbox(s: 'const Set *') -> 'STBox *': + s_converted = _ffi.cast('const Set *', s) result = _lib.spatialset_to_stbox(s_converted) _check_error() return result if result != _ffi.NULL else None -def textset_end_value(s: "const Set *") -> str: - s_converted = _ffi.cast("const Set *", s) +def textset_end_value(s: 'const Set *') -> str: + s_converted = _ffi.cast('const Set *', s) result = _lib.textset_end_value(s_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def textset_start_value(s: "const Set *") -> str: - s_converted = _ffi.cast("const Set *", s) +def textset_start_value(s: 'const Set *') -> str: + s_converted = _ffi.cast('const Set *', s) result = _lib.textset_start_value(s_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def textset_value_n(s: "const Set *", n: int) -> "text **": - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("text **") +def textset_value_n(s: 'const Set *', n: int) -> 'text **': + s_converted = _ffi.cast('const Set *', s) + out_result = _ffi.new('text **') result = _lib.textset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1801,30 +1767,30 @@ def textset_value_n(s: "const Set *", n: int) -> "text **": return None -def textset_values(s: "const Set *") -> "text **": - s_converted = _ffi.cast("const Set *", s) +def textset_values(s: 'const Set *') -> 'text **': + s_converted = _ffi.cast('const Set *', s) result = _lib.textset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_end_value(s: "const Set *") -> "TimestampTz": - s_converted = _ffi.cast("const Set *", s) +def tstzset_end_value(s: 'const Set *') -> 'TimestampTz': + s_converted = _ffi.cast('const Set *', s) result = _lib.tstzset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_start_value(s: "const Set *") -> "TimestampTz": - s_converted = _ffi.cast("const Set *", s) +def tstzset_start_value(s: 'const Set *') -> 'TimestampTz': + s_converted = _ffi.cast('const Set *', s) result = _lib.tstzset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_value_n(s: "const Set *", n: int) -> int: - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("TimestampTz *") +def tstzset_value_n(s: 'const Set *', n: int) -> int: + s_converted = _ffi.cast('const Set *', s) + out_result = _ffi.new('TimestampTz *') result = _lib.tstzset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1832,72 +1798,72 @@ def tstzset_value_n(s: "const Set *", n: int) -> int: return None -def tstzset_values(s: "const Set *") -> "TimestampTz *": - s_converted = _ffi.cast("const Set *", s) +def tstzset_values(s: 'const Set *') -> 'TimestampTz *': + s_converted = _ffi.cast('const Set *', s) result = _lib.tstzset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_duration(s: "const Span *") -> "Interval *": - s_converted = _ffi.cast("const Span *", s) +def tstzspan_duration(s: 'const Span *') -> 'Interval *': + s_converted = _ffi.cast('const Span *', s) result = _lib.tstzspan_duration(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_lower(s: "const Span *") -> "TimestampTz": - s_converted = _ffi.cast("const Span *", s) +def tstzspan_lower(s: 'const Span *') -> 'TimestampTz': + s_converted = _ffi.cast('const Span *', s) result = _lib.tstzspan_lower(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_upper(s: "const Span *") -> "TimestampTz": - s_converted = _ffi.cast("const Span *", s) +def tstzspan_upper(s: 'const Span *') -> 'TimestampTz': + s_converted = _ffi.cast('const Span *', s) result = _lib.tstzspan_upper(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_duration(ss: "const SpanSet *", boundspan: bool) -> "Interval *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_duration(ss: 'const SpanSet *', boundspan: bool) -> 'Interval *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tstzspanset_duration(ss_converted, boundspan) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_end_timestamptz(ss: "const SpanSet *") -> "TimestampTz": - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_end_timestamptz(ss: 'const SpanSet *') -> 'TimestampTz': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tstzspanset_end_timestamptz(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_lower(ss: "const SpanSet *") -> "TimestampTz": - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_lower(ss: 'const SpanSet *') -> 'TimestampTz': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tstzspanset_lower(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_num_timestamps(ss: "const SpanSet *") -> "int": - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_num_timestamps(ss: 'const SpanSet *') -> 'int': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tstzspanset_num_timestamps(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_start_timestamptz(ss: "const SpanSet *") -> "TimestampTz": - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_start_timestamptz(ss: 'const SpanSet *') -> 'TimestampTz': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tstzspanset_start_timestamptz(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_timestamptz_n(ss: "const SpanSet *", n: int) -> int: - ss_converted = _ffi.cast("const SpanSet *", ss) - out_result = _ffi.new("TimestampTz *") +def tstzspanset_timestamptz_n(ss: 'const SpanSet *', n: int) -> int: + ss_converted = _ffi.cast('const SpanSet *', ss) + out_result = _ffi.new('TimestampTz *') result = _lib.tstzspanset_timestamptz_n(ss_converted, n, out_result) _check_error() if result: @@ -1905,3479 +1871,3363 @@ def tstzspanset_timestamptz_n(ss: "const SpanSet *", n: int) -> int: return None -def tstzspanset_timestamps(ss: "const SpanSet *") -> "Tuple['TimestampTz *', 'int']": - ss_converted = _ffi.cast("const SpanSet *", ss) - count = _ffi.new("int *") +def tstzspanset_timestamps(ss: 'const SpanSet *') -> "Tuple['TimestampTz *', 'int']": + ss_converted = _ffi.cast('const SpanSet *', ss) + count = _ffi.new('int *') result = _lib.tstzspanset_timestamps(ss_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tstzspanset_upper(ss: "const SpanSet *") -> "TimestampTz": - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_upper(ss: 'const SpanSet *') -> 'TimestampTz': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tstzspanset_upper(ss_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_shift_scale( - s: "const Set *", shift: int, width: int, hasshift: bool, haswidth: bool -) -> "Set *": - s_converted = _ffi.cast("const Set *", s) - shift_converted = _ffi.cast("int64", shift) - width_converted = _ffi.cast("int64", width) - result = _lib.bigintset_shift_scale( - s_converted, shift_converted, width_converted, hasshift, haswidth - ) +def bigintset_shift_scale(s: 'const Set *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + shift_converted = _ffi.cast('int64', shift) + width_converted = _ffi.cast('int64', width) + result = _lib.bigintset_shift_scale(s_converted, shift_converted, width_converted, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def bigintspan_shift_scale( - s: "const Span *", shift: int, width: int, hasshift: bool, haswidth: bool -) -> "Span *": - s_converted = _ffi.cast("const Span *", s) - shift_converted = _ffi.cast("int64", shift) - width_converted = _ffi.cast("int64", width) - result = _lib.bigintspan_shift_scale( - s_converted, shift_converted, width_converted, hasshift, haswidth - ) +def bigintspan_shift_scale(s: 'const Span *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Span *': + s_converted = _ffi.cast('const Span *', s) + shift_converted = _ffi.cast('int64', shift) + width_converted = _ffi.cast('int64', width) + result = _lib.bigintspan_shift_scale(s_converted, shift_converted, width_converted, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def bigintspanset_shift_scale( - ss: "const SpanSet *", shift: int, width: int, hasshift: bool, haswidth: bool -) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - shift_converted = _ffi.cast("int64", shift) - width_converted = _ffi.cast("int64", width) - result = _lib.bigintspanset_shift_scale( - ss_converted, shift_converted, width_converted, hasshift, haswidth - ) +def bigintspanset_shift_scale(ss: 'const SpanSet *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + shift_converted = _ffi.cast('int64', shift) + width_converted = _ffi.cast('int64', width) + result = _lib.bigintspanset_shift_scale(ss_converted, shift_converted, width_converted, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def dateset_shift_scale( - s: "const Set *", shift: int, width: int, hasshift: bool, haswidth: bool -) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def dateset_shift_scale(s: 'const Set *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.dateset_shift_scale(s_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def dateset_to_tstzset(s: "const Set *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def dateset_to_tstzset(s: 'const Set *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.dateset_to_tstzset(s_converted) _check_error() return result if result != _ffi.NULL else None -def datespan_shift_scale( - s: "const Span *", shift: int, width: int, hasshift: bool, haswidth: bool -) -> "Span *": - s_converted = _ffi.cast("const Span *", s) +def datespan_shift_scale(s: 'const Span *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Span *': + s_converted = _ffi.cast('const Span *', s) result = _lib.datespan_shift_scale(s_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def datespan_to_tstzspan(s: "const Span *") -> "Span *": - s_converted = _ffi.cast("const Span *", s) +def datespan_to_tstzspan(s: 'const Span *') -> 'Span *': + s_converted = _ffi.cast('const Span *', s) result = _lib.datespan_to_tstzspan(s_converted) _check_error() return result if result != _ffi.NULL else None -def datespanset_shift_scale( - ss: "const SpanSet *", shift: int, width: int, hasshift: bool, haswidth: bool -) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - result = _lib.datespanset_shift_scale( - ss_converted, shift, width, hasshift, haswidth - ) +def datespanset_shift_scale(ss: 'const SpanSet *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + result = _lib.datespanset_shift_scale(ss_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def datespanset_to_tstzspanset(ss: "const SpanSet *") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def datespanset_to_tstzspanset(ss: 'const SpanSet *') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.datespanset_to_tstzspanset(ss_converted) _check_error() return result if result != _ffi.NULL else None -def floatset_round(s: "const Set *", maxdd: int) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def floatset_round(s: 'const Set *', maxdd: int) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.floatset_round(s_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def floatset_shift_scale( - s: "const Set *", shift: float, width: float, hasshift: bool, haswidth: bool -) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def floatset_shift_scale(s: 'const Set *', shift: float, width: float, hasshift: bool, haswidth: bool) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.floatset_shift_scale(s_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def floatset_to_intset(s: "const Set *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def floatset_to_intset(s: 'const Set *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.floatset_to_intset(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_round(s: "const Span *", maxdd: int) -> "Span *": - s_converted = _ffi.cast("const Span *", s) +def floatspan_round(s: 'const Span *', maxdd: int) -> 'Span *': + s_converted = _ffi.cast('const Span *', s) result = _lib.floatspan_round(s_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def floatspan_shift_scale( - s: "const Span *", shift: float, width: float, hasshift: bool, haswidth: bool -) -> "Span *": - s_converted = _ffi.cast("const Span *", s) +def floatspan_shift_scale(s: 'const Span *', shift: float, width: float, hasshift: bool, haswidth: bool) -> 'Span *': + s_converted = _ffi.cast('const Span *', s) result = _lib.floatspan_shift_scale(s_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def floatspan_to_intspan(s: "const Span *") -> "Span *": - s_converted = _ffi.cast("const Span *", s) +def floatspan_to_intspan(s: 'const Span *') -> 'Span *': + s_converted = _ffi.cast('const Span *', s) result = _lib.floatspan_to_intspan(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_to_intspanset(ss: "const SpanSet *") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_to_intspanset(ss: 'const SpanSet *') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.floatspanset_to_intspanset(ss_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_round(ss: "const SpanSet *", maxdd: int) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def floatspanset_round(ss: 'const SpanSet *', maxdd: int) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.floatspanset_round(ss_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def floatspanset_shift_scale( - ss: "const SpanSet *", shift: float, width: float, hasshift: bool, haswidth: bool -) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - result = _lib.floatspanset_shift_scale( - ss_converted, shift, width, hasshift, haswidth - ) +def floatspanset_shift_scale(ss: 'const SpanSet *', shift: float, width: float, hasshift: bool, haswidth: bool) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + result = _lib.floatspanset_shift_scale(ss_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def geoset_round(s: "const Set *", maxdd: int) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def geoset_round(s: 'const Set *', maxdd: int) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.geoset_round(s_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def intset_shift_scale( - s: "const Set *", shift: int, width: int, hasshift: bool, haswidth: bool -) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def intset_shift_scale(s: 'const Set *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.intset_shift_scale(s_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def intset_to_floatset(s: "const Set *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def intset_to_floatset(s: 'const Set *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.intset_to_floatset(s_converted) _check_error() return result if result != _ffi.NULL else None -def intspan_shift_scale( - s: "const Span *", shift: int, width: int, hasshift: bool, haswidth: bool -) -> "Span *": - s_converted = _ffi.cast("const Span *", s) +def intspan_shift_scale(s: 'const Span *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Span *': + s_converted = _ffi.cast('const Span *', s) result = _lib.intspan_shift_scale(s_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def intspan_to_floatspan(s: "const Span *") -> "Span *": - s_converted = _ffi.cast("const Span *", s) +def intspan_to_floatspan(s: 'const Span *') -> 'Span *': + s_converted = _ffi.cast('const Span *', s) result = _lib.intspan_to_floatspan(s_converted) _check_error() return result if result != _ffi.NULL else None -def intspanset_to_floatspanset(ss: "const SpanSet *") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def intspanset_to_floatspanset(ss: 'const SpanSet *') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.intspanset_to_floatspanset(ss_converted) _check_error() return result if result != _ffi.NULL else None -def intspanset_shift_scale( - ss: "const SpanSet *", shift: int, width: int, hasshift: bool, haswidth: bool -) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def intspanset_shift_scale(ss: 'const SpanSet *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.intspanset_shift_scale(ss_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def textset_lower(s: "const Set *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def textset_lower(s: 'const Set *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.textset_lower(s_converted) _check_error() return result if result != _ffi.NULL else None -def textset_upper(s: "const Set *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def textset_upper(s: 'const Set *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.textset_upper(s_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_tprecision( - t: int, duration: "const Interval *", torigin: int -) -> "TimestampTz": - t_converted = _ffi.cast("TimestampTz", t) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - result = _lib.timestamptz_tprecision( - t_converted, duration_converted, torigin_converted - ) +def timestamptz_tprecision(t: int, duration: 'const Interval *', torigin: int) -> 'TimestampTz': + t_converted = _ffi.cast('TimestampTz', t) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + result = _lib.timestamptz_tprecision(t_converted, duration_converted, torigin_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_shift_scale( - s: "const Set *", - shift: "Optional['const Interval *']", - duration: "Optional['const Interval *']", -) -> "Set *": - s_converted = _ffi.cast("const Set *", s) - shift_converted = ( - _ffi.cast("const Interval *", shift) if shift is not None else _ffi.NULL - ) - duration_converted = ( - _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL - ) +def tstzset_shift_scale(s: 'const Set *', shift: "Optional['const Interval *']", duration: "Optional['const Interval *']") -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + shift_converted = _ffi.cast('const Interval *', shift) if shift is not None else _ffi.NULL + duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL result = _lib.tstzset_shift_scale(s_converted, shift_converted, duration_converted) _check_error() return result if result != _ffi.NULL else None -def datespan_shift_scale( - s: "const Span *", shift: int, width: int, hasshift: bool, haswidth: bool -) -> "Span *": - s_converted = _ffi.cast("const Span *", s) +def datespan_shift_scale(s: 'const Span *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Span *': + s_converted = _ffi.cast('const Span *', s) result = _lib.datespan_shift_scale(s_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def tstzspan_shift_scale( - s: "const Span *", - shift: "Optional['const Interval *']", - duration: "Optional['const Interval *']", -) -> "Span *": - s_converted = _ffi.cast("const Span *", s) - shift_converted = ( - _ffi.cast("const Interval *", shift) if shift is not None else _ffi.NULL - ) - duration_converted = ( - _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL - ) +def tstzspan_shift_scale(s: 'const Span *', shift: "Optional['const Interval *']", duration: "Optional['const Interval *']") -> 'Span *': + s_converted = _ffi.cast('const Span *', s) + shift_converted = _ffi.cast('const Interval *', shift) if shift is not None else _ffi.NULL + duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL result = _lib.tstzspan_shift_scale(s_converted, shift_converted, duration_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_tprecision( - s: "const Span *", duration: "const Interval *", torigin: int -) -> "Span *": - s_converted = _ffi.cast("const Span *", s) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - result = _lib.tstzspan_tprecision( - s_converted, duration_converted, torigin_converted - ) +def tstzspan_tprecision(s: 'const Span *', duration: 'const Interval *', torigin: int) -> 'Span *': + s_converted = _ffi.cast('const Span *', s) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + result = _lib.tstzspan_tprecision(s_converted, duration_converted, torigin_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_to_dateset(s: "const Set *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def tstzset_to_dateset(s: 'const Set *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.tstzset_to_dateset(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_to_datespan(s: "const Span *") -> "Span *": - s_converted = _ffi.cast("const Span *", s) +def tstzspan_to_datespan(s: 'const Span *') -> 'Span *': + s_converted = _ffi.cast('const Span *', s) result = _lib.tstzspan_to_datespan(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_to_datespanset(ss: "const SpanSet *") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_to_datespanset(ss: 'const SpanSet *') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tstzspanset_to_datespanset(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_shift_scale( - ss: "const SpanSet *", - shift: "Optional['const Interval *']", - duration: "Optional['const Interval *']", -) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - shift_converted = ( - _ffi.cast("const Interval *", shift) if shift is not None else _ffi.NULL - ) - duration_converted = ( - _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL - ) - result = _lib.tstzspanset_shift_scale( - ss_converted, shift_converted, duration_converted - ) +def tstzspanset_shift_scale(ss: 'const SpanSet *', shift: "Optional['const Interval *']", duration: "Optional['const Interval *']") -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + shift_converted = _ffi.cast('const Interval *', shift) if shift is not None else _ffi.NULL + duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL + result = _lib.tstzspanset_shift_scale(ss_converted, shift_converted, duration_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_tprecision( - ss: "const SpanSet *", duration: "const Interval *", torigin: int -) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - duration_converted = _ffi.cast("const Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - result = _lib.tstzspanset_tprecision( - ss_converted, duration_converted, torigin_converted - ) +def tstzspanset_tprecision(ss: 'const SpanSet *', duration: 'const Interval *', torigin: int) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + duration_converted = _ffi.cast('const Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + result = _lib.tstzspanset_tprecision(ss_converted, duration_converted, torigin_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_bigint(s: "const Set *", i: int) -> "Set *": - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def intersection_set_bigint(s: 'const Set *', i: int) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + i_converted = _ffi.cast('int64', i) result = _lib.intersection_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_date(s: "const Set *", d: "DateADT") -> "Set *": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def intersection_set_date(s: 'const Set *', d: 'DateADT') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.intersection_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_float(s: "const Set *", d: float) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def intersection_set_float(s: 'const Set *', d: float) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.intersection_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def intersection_set_geo(s: "const Set *", gs: "const GSERIALIZED *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def intersection_set_geo(s: 'const Set *', gs: 'const GSERIALIZED *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.intersection_set_geo(s_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_int(s: "const Set *", i: int) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def intersection_set_int(s: 'const Set *', i: int) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.intersection_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def intersection_set_set(s1: "const Set *", s2: "const Set *") -> "Set *": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def intersection_set_set(s1: 'const Set *', s2: 'const Set *') -> 'Set *': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.intersection_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_text(s: "const Set *", txt: str) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def intersection_set_text(s: 'const Set *', txt: str) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) txt_converted = cstring2text(txt) result = _lib.intersection_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_timestamptz(s: "const Set *", t: int) -> "Set *": - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def intersection_set_timestamptz(s: 'const Set *', t: int) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.intersection_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_span_bigint(s: "const Span *", i: int) -> "Span *": - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def intersection_span_bigint(s: 'const Span *', i: int) -> 'Span *': + s_converted = _ffi.cast('const Span *', s) + i_converted = _ffi.cast('int64', i) result = _lib.intersection_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_span_date(s: "const Span *", d: "DateADT") -> "Span *": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def intersection_span_date(s: 'const Span *', d: 'DateADT') -> 'Span *': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.intersection_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_span_float(s: "const Span *", d: float) -> "Span *": - s_converted = _ffi.cast("const Span *", s) +def intersection_span_float(s: 'const Span *', d: float) -> 'Span *': + s_converted = _ffi.cast('const Span *', s) result = _lib.intersection_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def intersection_span_int(s: "const Span *", i: int) -> "Span *": - s_converted = _ffi.cast("const Span *", s) +def intersection_span_int(s: 'const Span *', i: int) -> 'Span *': + s_converted = _ffi.cast('const Span *', s) result = _lib.intersection_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def intersection_span_timestamptz(s: "const Span *", t: int) -> "Span *": - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def intersection_span_timestamptz(s: 'const Span *', t: int) -> 'Span *': + s_converted = _ffi.cast('const Span *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.intersection_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_span_span(s1: "const Span *", s2: "const Span *") -> "Span *": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def intersection_span_span(s1: 'const Span *', s2: 'const Span *') -> 'Span *': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.intersection_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_bigint(ss: "const SpanSet *", i: int) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def intersection_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + i_converted = _ffi.cast('int64', i) result = _lib.intersection_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def intersection_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('DateADT', d) result = _lib.intersection_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_float(ss: "const SpanSet *", d: float) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def intersection_spanset_float(ss: 'const SpanSet *', d: float) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.intersection_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_int(ss: "const SpanSet *", i: int) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def intersection_spanset_int(ss: 'const SpanSet *', i: int) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.intersection_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def intersection_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.intersection_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_spanset( - ss1: "const SpanSet *", ss2: "const SpanSet *" -) -> "SpanSet *": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def intersection_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'SpanSet *': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.intersection_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def intersection_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.intersection_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def minus_bigint_set(i: int, s: "const Set *") -> "Set *": - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def minus_bigint_set(i: int, s: 'const Set *') -> 'Set *': + i_converted = _ffi.cast('int64', i) + s_converted = _ffi.cast('const Set *', s) result = _lib.minus_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_bigint_span(i: int, s: "const Span *") -> "SpanSet *": - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Span *", s) +def minus_bigint_span(i: int, s: 'const Span *') -> 'SpanSet *': + i_converted = _ffi.cast('int64', i) + s_converted = _ffi.cast('const Span *', s) result = _lib.minus_bigint_span(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_bigint_spanset(i: int, ss: "const SpanSet *") -> "SpanSet *": - i_converted = _ffi.cast("int64", i) - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_bigint_spanset(i: int, ss: 'const SpanSet *') -> 'SpanSet *': + i_converted = _ffi.cast('int64', i) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.minus_bigint_spanset(i_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_date_set(d: "DateADT", s: "const Set *") -> "Set *": - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Set *", s) +def minus_date_set(d: 'DateADT', s: 'const Set *') -> 'Set *': + d_converted = _ffi.cast('DateADT', d) + s_converted = _ffi.cast('const Set *', s) result = _lib.minus_date_set(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_date_span(d: "DateADT", s: "const Span *") -> "SpanSet *": - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Span *", s) +def minus_date_span(d: 'DateADT', s: 'const Span *') -> 'SpanSet *': + d_converted = _ffi.cast('DateADT', d) + s_converted = _ffi.cast('const Span *', s) result = _lib.minus_date_span(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_date_spanset(d: "DateADT", ss: "const SpanSet *") -> "SpanSet *": - d_converted = _ffi.cast("DateADT", d) - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_date_spanset(d: 'DateADT', ss: 'const SpanSet *') -> 'SpanSet *': + d_converted = _ffi.cast('DateADT', d) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.minus_date_spanset(d_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_float_set(d: float, s: "const Set *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def minus_float_set(d: float, s: 'const Set *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.minus_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_float_span(d: float, s: "const Span *") -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) +def minus_float_span(d: float, s: 'const Span *') -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) result = _lib.minus_float_span(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_float_spanset(d: float, ss: "const SpanSet *") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_float_spanset(d: float, ss: 'const SpanSet *') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.minus_float_spanset(d, ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_geo_set(gs: "const GSERIALIZED *", s: "const Set *") -> "Set *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - s_converted = _ffi.cast("const Set *", s) +def minus_geo_set(gs: 'const GSERIALIZED *', s: 'const Set *') -> 'Set *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + s_converted = _ffi.cast('const Set *', s) result = _lib.minus_geo_set(gs_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_int_set(i: int, s: "const Set *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def minus_int_set(i: int, s: 'const Set *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.minus_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_int_span(i: int, s: "const Span *") -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) +def minus_int_span(i: int, s: 'const Span *') -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) result = _lib.minus_int_span(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_int_spanset(i: int, ss: "const SpanSet *") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_int_spanset(i: int, ss: 'const SpanSet *') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.minus_int_spanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_bigint(s: "const Set *", i: int) -> "Set *": - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def minus_set_bigint(s: 'const Set *', i: int) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + i_converted = _ffi.cast('int64', i) result = _lib.minus_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_date(s: "const Set *", d: "DateADT") -> "Set *": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def minus_set_date(s: 'const Set *', d: 'DateADT') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.minus_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_float(s: "const Set *", d: float) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def minus_set_float(s: 'const Set *', d: float) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.minus_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def minus_set_geo(s: "const Set *", gs: "const GSERIALIZED *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def minus_set_geo(s: 'const Set *', gs: 'const GSERIALIZED *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.minus_set_geo(s_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_int(s: "const Set *", i: int) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def minus_set_int(s: 'const Set *', i: int) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.minus_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def minus_set_set(s1: "const Set *", s2: "const Set *") -> "Set *": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def minus_set_set(s1: 'const Set *', s2: 'const Set *') -> 'Set *': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.minus_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_text(s: "const Set *", txt: str) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def minus_set_text(s: 'const Set *', txt: str) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) txt_converted = cstring2text(txt) result = _lib.minus_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_timestamptz(s: "const Set *", t: int) -> "Set *": - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def minus_set_timestamptz(s: 'const Set *', t: int) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.minus_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_bigint(s: "const Span *", i: int) -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def minus_span_bigint(s: 'const Span *', i: int) -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) + i_converted = _ffi.cast('int64', i) result = _lib.minus_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_date(s: "const Span *", d: "DateADT") -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def minus_span_date(s: 'const Span *', d: 'DateADT') -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.minus_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_float(s: "const Span *", d: float) -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) +def minus_span_float(s: 'const Span *', d: float) -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) result = _lib.minus_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def minus_span_int(s: "const Span *", i: int) -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) +def minus_span_int(s: 'const Span *', i: int) -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) result = _lib.minus_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def minus_span_span(s1: "const Span *", s2: "const Span *") -> "SpanSet *": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def minus_span_span(s1: 'const Span *', s2: 'const Span *') -> 'SpanSet *': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.minus_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.minus_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_timestamptz(s: "const Span *", t: int) -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def minus_span_timestamptz(s: 'const Span *', t: int) -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.minus_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_bigint(ss: "const SpanSet *", i: int) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def minus_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + i_converted = _ffi.cast('int64', i) result = _lib.minus_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def minus_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('DateADT', d) result = _lib.minus_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_float(ss: "const SpanSet *", d: float) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_spanset_float(ss: 'const SpanSet *', d: float) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.minus_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_int(ss: "const SpanSet *", i: int) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_spanset_int(ss: 'const SpanSet *', i: int) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.minus_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def minus_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.minus_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_spanset( - ss1: "const SpanSet *", ss2: "const SpanSet *" -) -> "SpanSet *": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def minus_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'SpanSet *': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.minus_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def minus_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.minus_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def minus_text_set(txt: str, s: "const Set *") -> "Set *": +def minus_text_set(txt: str, s: 'const Set *') -> 'Set *': txt_converted = cstring2text(txt) - s_converted = _ffi.cast("const Set *", s) + s_converted = _ffi.cast('const Set *', s) result = _lib.minus_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_timestamptz_span(t: int, s: "const Span *") -> "SpanSet *": - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Span *", s) +def minus_timestamptz_span(t: int, s: 'const Span *') -> 'SpanSet *': + t_converted = _ffi.cast('TimestampTz', t) + s_converted = _ffi.cast('const Span *', s) result = _lib.minus_timestamptz_span(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_timestamptz_spanset(t: int, ss: "const SpanSet *") -> "SpanSet *": - t_converted = _ffi.cast("TimestampTz", t) - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_timestamptz_spanset(t: int, ss: 'const SpanSet *') -> 'SpanSet *': + t_converted = _ffi.cast('TimestampTz', t) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.minus_timestamptz_spanset(t_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_timestamptz_set(t: int, s: "const Set *") -> "Set *": - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def minus_timestamptz_set(t: int, s: 'const Set *') -> 'Set *': + t_converted = _ffi.cast('TimestampTz', t) + s_converted = _ffi.cast('const Set *', s) result = _lib.minus_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def super_union_span_span(s1: "const Span *", s2: "const Span *") -> "Span *": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def super_union_span_span(s1: 'const Span *', s2: 'const Span *') -> 'Span *': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.super_union_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_bigint(s: "const Set *", i: int) -> "Set *": - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def union_set_bigint(s: 'const Set *', i: int) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + i_converted = _ffi.cast('int64', i) result = _lib.union_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_date(s: "const Set *", d: "DateADT") -> "Set *": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def union_set_date(s: 'const Set *', d: 'DateADT') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.union_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_float(s: "const Set *", d: float) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def union_set_float(s: 'const Set *', d: float) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.union_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def union_set_geo(s: "const Set *", gs: "const GSERIALIZED *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def union_set_geo(s: 'const Set *', gs: 'const GSERIALIZED *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.union_set_geo(s_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_int(s: "const Set *", i: int) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def union_set_int(s: 'const Set *', i: int) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.union_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def union_set_set(s1: "const Set *", s2: "const Set *") -> "Set *": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def union_set_set(s1: 'const Set *', s2: 'const Set *') -> 'Set *': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.union_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_text(s: "const Set *", txt: str) -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def union_set_text(s: 'const Set *', txt: str) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) txt_converted = cstring2text(txt) result = _lib.union_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_timestamptz(s: "const Set *", t: int) -> "Set *": - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("const TimestampTz", t) +def union_set_timestamptz(s: 'const Set *', t: int) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + t_converted = _ffi.cast('const TimestampTz', t) result = _lib.union_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_bigint(s: "const Span *", i: int) -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def union_span_bigint(s: 'const Span *', i: int) -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) + i_converted = _ffi.cast('int64', i) result = _lib.union_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_date(s: "const Span *", d: "DateADT") -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def union_span_date(s: 'const Span *', d: 'DateADT') -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.union_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_float(s: "const Span *", d: float) -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) +def union_span_float(s: 'const Span *', d: float) -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) result = _lib.union_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def union_span_int(s: "const Span *", i: int) -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) +def union_span_int(s: 'const Span *', i: int) -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) result = _lib.union_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def union_span_span(s1: "const Span *", s2: "const Span *") -> "SpanSet *": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def union_span_span(s1: 'const Span *', s2: 'const Span *') -> 'SpanSet *': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.union_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_timestamptz(s: "const Span *", t: int) -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def union_span_timestamptz(s: 'const Span *', t: int) -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.union_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_bigint(ss: "const SpanSet *", i: int) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def union_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + i_converted = _ffi.cast('int64', i) result = _lib.union_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def union_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('DateADT', d) result = _lib.union_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_float(ss: "const SpanSet *", d: float) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def union_spanset_float(ss: 'const SpanSet *', d: float) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.union_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def union_spanset_int(ss: "const SpanSet *", i: int) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def union_spanset_int(ss: 'const SpanSet *', i: int) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.union_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def union_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def union_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.union_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_spanset( - ss1: "const SpanSet *", ss2: "const SpanSet *" -) -> "SpanSet *": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def union_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'SpanSet *': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.union_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def union_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.union_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_bigint(s: "const Span *", i: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def adjacent_span_bigint(s: 'const Span *', i: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) + i_converted = _ffi.cast('int64', i) result = _lib.adjacent_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_date(s: "const Span *", d: "DateADT") -> "bool": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def adjacent_span_date(s: 'const Span *', d: 'DateADT') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.adjacent_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_float(s: "const Span *", d: float) -> "bool": - s_converted = _ffi.cast("const Span *", s) +def adjacent_span_float(s: 'const Span *', d: float) -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.adjacent_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_int(s: "const Span *", i: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) +def adjacent_span_int(s: 'const Span *', i: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.adjacent_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def adjacent_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.adjacent_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_timestamptz(s: "const Span *", t: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def adjacent_span_timestamptz(s: 'const Span *', t: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.adjacent_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_bigint(ss: "const SpanSet *", i: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def adjacent_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + i_converted = _ffi.cast('int64', i) result = _lib.adjacent_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def adjacent_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('DateADT', d) result = _lib.adjacent_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_float(ss: "const SpanSet *", d: float) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def adjacent_spanset_float(ss: 'const SpanSet *', d: float) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.adjacent_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_int(ss: "const SpanSet *", i: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def adjacent_spanset_int(ss: 'const SpanSet *', i: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.adjacent_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def adjacent_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.adjacent_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def adjacent_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.adjacent_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def adjacent_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.adjacent_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_bigint_set(i: int, s: "const Set *") -> "bool": - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def contained_bigint_set(i: int, s: 'const Set *') -> 'bool': + i_converted = _ffi.cast('int64', i) + s_converted = _ffi.cast('const Set *', s) result = _lib.contained_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_bigint_span(i: int, s: "const Span *") -> "bool": - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Span *", s) +def contained_bigint_span(i: int, s: 'const Span *') -> 'bool': + i_converted = _ffi.cast('int64', i) + s_converted = _ffi.cast('const Span *', s) result = _lib.contained_bigint_span(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_bigint_spanset(i: int, ss: "const SpanSet *") -> "bool": - i_converted = _ffi.cast("int64", i) - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_bigint_spanset(i: int, ss: 'const SpanSet *') -> 'bool': + i_converted = _ffi.cast('int64', i) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.contained_bigint_spanset(i_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contained_date_set(d: "DateADT", s: "const Set *") -> "bool": - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Set *", s) +def contained_date_set(d: 'DateADT', s: 'const Set *') -> 'bool': + d_converted = _ffi.cast('DateADT', d) + s_converted = _ffi.cast('const Set *', s) result = _lib.contained_date_set(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_date_span(d: "DateADT", s: "const Span *") -> "bool": - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Span *", s) +def contained_date_span(d: 'DateADT', s: 'const Span *') -> 'bool': + d_converted = _ffi.cast('DateADT', d) + s_converted = _ffi.cast('const Span *', s) result = _lib.contained_date_span(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_date_spanset(d: "DateADT", ss: "const SpanSet *") -> "bool": - d_converted = _ffi.cast("DateADT", d) - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_date_spanset(d: 'DateADT', ss: 'const SpanSet *') -> 'bool': + d_converted = _ffi.cast('DateADT', d) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.contained_date_spanset(d_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contained_float_set(d: float, s: "const Set *") -> "bool": - s_converted = _ffi.cast("const Set *", s) +def contained_float_set(d: float, s: 'const Set *') -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.contained_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_float_span(d: float, s: "const Span *") -> "bool": - s_converted = _ffi.cast("const Span *", s) +def contained_float_span(d: float, s: 'const Span *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.contained_float_span(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_float_spanset(d: float, ss: "const SpanSet *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_float_spanset(d: float, ss: 'const SpanSet *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.contained_float_spanset(d, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contained_geo_set(gs: "GSERIALIZED *", s: "const Set *") -> "bool": - gs_converted = _ffi.cast("GSERIALIZED *", gs) - s_converted = _ffi.cast("const Set *", s) +def contained_geo_set(gs: 'GSERIALIZED *', s: 'const Set *') -> 'bool': + gs_converted = _ffi.cast('GSERIALIZED *', gs) + s_converted = _ffi.cast('const Set *', s) result = _lib.contained_geo_set(gs_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_int_set(i: int, s: "const Set *") -> "bool": - s_converted = _ffi.cast("const Set *", s) +def contained_int_set(i: int, s: 'const Set *') -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.contained_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_int_span(i: int, s: "const Span *") -> "bool": - s_converted = _ffi.cast("const Span *", s) +def contained_int_span(i: int, s: 'const Span *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.contained_int_span(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_int_spanset(i: int, ss: "const SpanSet *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_int_spanset(i: int, ss: 'const SpanSet *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.contained_int_spanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contained_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def contained_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.contained_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def contained_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.contained_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.contained_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contained_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def contained_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.contained_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def contained_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.contained_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_text_set(txt: str, s: "const Set *") -> "bool": +def contained_text_set(txt: str, s: 'const Set *') -> 'bool': txt_converted = cstring2text(txt) - s_converted = _ffi.cast("const Set *", s) + s_converted = _ffi.cast('const Set *', s) result = _lib.contained_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_timestamptz_set(t: int, s: "const Set *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def contained_timestamptz_set(t: int, s: 'const Set *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + s_converted = _ffi.cast('const Set *', s) result = _lib.contained_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_timestamptz_span(t: int, s: "const Span *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Span *", s) +def contained_timestamptz_span(t: int, s: 'const Span *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + s_converted = _ffi.cast('const Span *', s) result = _lib.contained_timestamptz_span(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_timestamptz_spanset(t: int, ss: "const SpanSet *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_timestamptz_spanset(t: int, ss: 'const SpanSet *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.contained_timestamptz_spanset(t_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_bigint(s: "const Set *", i: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def contains_set_bigint(s: 'const Set *', i: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) + i_converted = _ffi.cast('int64', i) result = _lib.contains_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_date(s: "const Set *", d: "DateADT") -> "bool": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def contains_set_date(s: 'const Set *', d: 'DateADT') -> 'bool': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.contains_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_float(s: "const Set *", d: float) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def contains_set_float(s: 'const Set *', d: float) -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.contains_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def contains_set_geo(s: "const Set *", gs: "GSERIALIZED *") -> "bool": - s_converted = _ffi.cast("const Set *", s) - gs_converted = _ffi.cast("GSERIALIZED *", gs) +def contains_set_geo(s: 'const Set *', gs: 'GSERIALIZED *') -> 'bool': + s_converted = _ffi.cast('const Set *', s) + gs_converted = _ffi.cast('GSERIALIZED *', gs) result = _lib.contains_set_geo(s_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_int(s: "const Set *", i: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def contains_set_int(s: 'const Set *', i: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.contains_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def contains_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def contains_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.contains_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_text(s: "const Set *", t: str) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def contains_set_text(s: 'const Set *', t: str) -> 'bool': + s_converted = _ffi.cast('const Set *', s) t_converted = cstring2text(t) result = _lib.contains_set_text(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_timestamptz(s: "const Set *", t: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def contains_set_timestamptz(s: 'const Set *', t: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.contains_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_bigint(s: "const Span *", i: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def contains_span_bigint(s: 'const Span *', i: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) + i_converted = _ffi.cast('int64', i) result = _lib.contains_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_float(s: "const Span *", d: float) -> "bool": - s_converted = _ffi.cast("const Span *", s) +def contains_span_float(s: 'const Span *', d: float) -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.contains_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def contains_span_int(s: "const Span *", i: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) +def contains_span_int(s: 'const Span *', i: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.contains_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def contains_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def contains_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.contains_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def contains_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.contains_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_timestamptz(s: "const Span *", t: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def contains_span_timestamptz(s: 'const Span *', t: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.contains_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_date(s: "const Span *", d: "DateADT") -> "bool": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def contains_span_date(s: 'const Span *', d: 'DateADT') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.contains_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_bigint(ss: "const SpanSet *", i: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def contains_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + i_converted = _ffi.cast('int64', i) result = _lib.contains_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_float(ss: "const SpanSet *", d: float) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def contains_spanset_float(ss: 'const SpanSet *', d: float) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.contains_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_int(ss: "const SpanSet *", i: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def contains_spanset_int(ss: 'const SpanSet *', i: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.contains_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def contains_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.contains_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def contains_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.contains_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def contains_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.contains_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def contains_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('DateADT', d) result = _lib.contains_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def overlaps_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.overlaps_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def overlaps_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.overlaps_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def overlaps_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.overlaps_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def overlaps_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.overlaps_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def after_date_set(d: "DateADT", s: "const Set *") -> "bool": - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Set *", s) +def after_date_set(d: 'DateADT', s: 'const Set *') -> 'bool': + d_converted = _ffi.cast('DateADT', d) + s_converted = _ffi.cast('const Set *', s) result = _lib.after_date_set(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def after_date_span(d: "DateADT", s: "const Span *") -> "bool": - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Span *", s) +def after_date_span(d: 'DateADT', s: 'const Span *') -> 'bool': + d_converted = _ffi.cast('DateADT', d) + s_converted = _ffi.cast('const Span *', s) result = _lib.after_date_span(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def after_date_spanset(d: "DateADT", ss: "const SpanSet *") -> "bool": - d_converted = _ffi.cast("DateADT", d) - ss_converted = _ffi.cast("const SpanSet *", ss) +def after_date_spanset(d: 'DateADT', ss: 'const SpanSet *') -> 'bool': + d_converted = _ffi.cast('DateADT', d) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.after_date_spanset(d_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def after_set_date(s: "const Set *", d: "DateADT") -> "bool": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def after_set_date(s: 'const Set *', d: 'DateADT') -> 'bool': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.after_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def after_set_timestamptz(s: "const Set *", t: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def after_set_timestamptz(s: 'const Set *', t: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.after_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def after_span_date(s: "const Span *", d: "DateADT") -> "bool": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def after_span_date(s: 'const Span *', d: 'DateADT') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.after_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def after_span_timestamptz(s: "const Span *", t: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def after_span_timestamptz(s: 'const Span *', t: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.after_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def after_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def after_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('DateADT', d) result = _lib.after_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def after_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def after_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.after_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def after_timestamptz_set(t: int, s: "const Set *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def after_timestamptz_set(t: int, s: 'const Set *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + s_converted = _ffi.cast('const Set *', s) result = _lib.after_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def after_timestamptz_span(t: int, s: "const Span *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Span *", s) +def after_timestamptz_span(t: int, s: 'const Span *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + s_converted = _ffi.cast('const Span *', s) result = _lib.after_timestamptz_span(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def after_timestamptz_spanset(t: int, ss: "const SpanSet *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - ss_converted = _ffi.cast("const SpanSet *", ss) +def after_timestamptz_spanset(t: int, ss: 'const SpanSet *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.after_timestamptz_spanset(t_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def before_date_set(d: "DateADT", s: "const Set *") -> "bool": - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Set *", s) +def before_date_set(d: 'DateADT', s: 'const Set *') -> 'bool': + d_converted = _ffi.cast('DateADT', d) + s_converted = _ffi.cast('const Set *', s) result = _lib.before_date_set(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def before_date_span(d: "DateADT", s: "const Span *") -> "bool": - d_converted = _ffi.cast("DateADT", d) - s_converted = _ffi.cast("const Span *", s) +def before_date_span(d: 'DateADT', s: 'const Span *') -> 'bool': + d_converted = _ffi.cast('DateADT', d) + s_converted = _ffi.cast('const Span *', s) result = _lib.before_date_span(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def before_date_spanset(d: "DateADT", ss: "const SpanSet *") -> "bool": - d_converted = _ffi.cast("DateADT", d) - ss_converted = _ffi.cast("const SpanSet *", ss) +def before_date_spanset(d: 'DateADT', ss: 'const SpanSet *') -> 'bool': + d_converted = _ffi.cast('DateADT', d) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.before_date_spanset(d_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def before_set_date(s: "const Set *", d: "DateADT") -> "bool": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def before_set_date(s: 'const Set *', d: 'DateADT') -> 'bool': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.before_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def before_set_timestamptz(s: "const Set *", t: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def before_set_timestamptz(s: 'const Set *', t: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.before_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def before_span_date(s: "const Span *", d: "DateADT") -> "bool": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def before_span_date(s: 'const Span *', d: 'DateADT') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.before_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def before_span_timestamptz(s: "const Span *", t: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def before_span_timestamptz(s: 'const Span *', t: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.before_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def before_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def before_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('DateADT', d) result = _lib.before_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def before_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def before_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.before_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def before_timestamptz_set(t: int, s: "const Set *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def before_timestamptz_set(t: int, s: 'const Set *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + s_converted = _ffi.cast('const Set *', s) result = _lib.before_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def before_timestamptz_span(t: int, s: "const Span *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Span *", s) +def before_timestamptz_span(t: int, s: 'const Span *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + s_converted = _ffi.cast('const Span *', s) result = _lib.before_timestamptz_span(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def before_timestamptz_spanset(t: int, ss: "const SpanSet *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - ss_converted = _ffi.cast("const SpanSet *", ss) +def before_timestamptz_spanset(t: int, ss: 'const SpanSet *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.before_timestamptz_spanset(t_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def left_bigint_set(i: int, s: "const Set *") -> "bool": - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def left_bigint_set(i: int, s: 'const Set *') -> 'bool': + i_converted = _ffi.cast('int64', i) + s_converted = _ffi.cast('const Set *', s) result = _lib.left_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_bigint_span(i: int, s: "const Span *") -> "bool": - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Span *", s) +def left_bigint_span(i: int, s: 'const Span *') -> 'bool': + i_converted = _ffi.cast('int64', i) + s_converted = _ffi.cast('const Span *', s) result = _lib.left_bigint_span(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_bigint_spanset(i: int, ss: "const SpanSet *") -> "bool": - i_converted = _ffi.cast("int64", i) - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_bigint_spanset(i: int, ss: 'const SpanSet *') -> 'bool': + i_converted = _ffi.cast('int64', i) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.left_bigint_spanset(i_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def left_float_set(d: float, s: "const Set *") -> "bool": - s_converted = _ffi.cast("const Set *", s) +def left_float_set(d: float, s: 'const Set *') -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.left_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_float_span(d: float, s: "const Span *") -> "bool": - s_converted = _ffi.cast("const Span *", s) +def left_float_span(d: float, s: 'const Span *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.left_float_span(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_float_spanset(d: float, ss: "const SpanSet *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_float_spanset(d: float, ss: 'const SpanSet *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.left_float_spanset(d, ss_converted) _check_error() return result if result != _ffi.NULL else None -def left_int_set(i: int, s: "const Set *") -> "bool": - s_converted = _ffi.cast("const Set *", s) +def left_int_set(i: int, s: 'const Set *') -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.left_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_int_span(i: int, s: "const Span *") -> "bool": - s_converted = _ffi.cast("const Span *", s) +def left_int_span(i: int, s: 'const Span *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.left_int_span(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_int_spanset(i: int, ss: "const SpanSet *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_int_spanset(i: int, ss: 'const SpanSet *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.left_int_spanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def left_set_bigint(s: "const Set *", i: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def left_set_bigint(s: 'const Set *', i: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) + i_converted = _ffi.cast('int64', i) result = _lib.left_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def left_set_float(s: "const Set *", d: float) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def left_set_float(s: 'const Set *', d: float) -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.left_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def left_set_int(s: "const Set *", i: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def left_set_int(s: 'const Set *', i: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.left_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def left_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def left_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.left_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def left_set_text(s: "const Set *", txt: str) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def left_set_text(s: 'const Set *', txt: str) -> 'bool': + s_converted = _ffi.cast('const Set *', s) txt_converted = cstring2text(txt) result = _lib.left_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def left_span_bigint(s: "const Span *", i: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def left_span_bigint(s: 'const Span *', i: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) + i_converted = _ffi.cast('int64', i) result = _lib.left_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def left_span_float(s: "const Span *", d: float) -> "bool": - s_converted = _ffi.cast("const Span *", s) +def left_span_float(s: 'const Span *', d: float) -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.left_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def left_span_int(s: "const Span *", i: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) +def left_span_int(s: 'const Span *', i: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.left_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def left_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def left_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.left_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def left_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.left_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def left_spanset_bigint(ss: "const SpanSet *", i: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def left_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + i_converted = _ffi.cast('int64', i) result = _lib.left_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def left_spanset_float(ss: "const SpanSet *", d: float) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_spanset_float(ss: 'const SpanSet *', d: float) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.left_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def left_spanset_int(ss: "const SpanSet *", i: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_spanset_int(ss: 'const SpanSet *', i: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.left_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def left_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def left_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.left_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def left_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.left_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def left_text_set(txt: str, s: "const Set *") -> "bool": +def left_text_set(txt: str, s: 'const Set *') -> 'bool': txt_converted = cstring2text(txt) - s_converted = _ffi.cast("const Set *", s) + s_converted = _ffi.cast('const Set *', s) result = _lib.left_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_set_date(s: "const Set *", d: "DateADT") -> "bool": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def overafter_set_date(s: 'const Set *', d: 'DateADT') -> 'bool': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.overafter_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_set_timestamptz(s: "const Set *", t: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def overafter_set_timestamptz(s: 'const Set *', t: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.overafter_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_span_timestamptz(s: "const Span *", t: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def overafter_span_timestamptz(s: 'const Span *', t: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.overafter_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_span_date(s: "const Span *", d: "DateADT") -> "bool": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def overafter_span_date(s: 'const Span *', d: 'DateADT') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.overafter_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def overafter_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.overafter_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def overafter_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('DateADT', d) result = _lib.overafter_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_timestamptz_set(t: int, s: "const Set *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def overafter_timestamptz_set(t: int, s: 'const Set *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + s_converted = _ffi.cast('const Set *', s) result = _lib.overafter_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_timestamptz_span(t: int, s: "const Span *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Span *", s) +def overafter_timestamptz_span(t: int, s: 'const Span *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + s_converted = _ffi.cast('const Span *', s) result = _lib.overafter_timestamptz_span(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_timestamptz_spanset(t: int, ss: "const SpanSet *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overafter_timestamptz_spanset(t: int, ss: 'const SpanSet *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overafter_timestamptz_spanset(t_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_set_date(s: "const Set *", d: "DateADT") -> "bool": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def overbefore_set_date(s: 'const Set *', d: 'DateADT') -> 'bool': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.overbefore_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_set_timestamptz(s: "const Set *", t: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def overbefore_set_timestamptz(s: 'const Set *', t: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.overbefore_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_span_timestamptz(s: "const Span *", t: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def overbefore_span_timestamptz(s: 'const Span *', t: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.overbefore_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_span_date(s: "const Span *", d: "DateADT") -> "bool": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def overbefore_span_date(s: 'const Span *', d: 'DateADT') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.overbefore_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def overbefore_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.overbefore_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def overbefore_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('DateADT', d) result = _lib.overbefore_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_timestamptz_set(t: int, s: "const Set *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Set *", s) +def overbefore_timestamptz_set(t: int, s: 'const Set *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + s_converted = _ffi.cast('const Set *', s) result = _lib.overbefore_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_timestamptz_span(t: int, s: "const Span *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - s_converted = _ffi.cast("const Span *", s) +def overbefore_timestamptz_span(t: int, s: 'const Span *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + s_converted = _ffi.cast('const Span *', s) result = _lib.overbefore_timestamptz_span(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_timestamptz_spanset(t: int, ss: "const SpanSet *") -> "bool": - t_converted = _ffi.cast("TimestampTz", t) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overbefore_timestamptz_spanset(t: int, ss: 'const SpanSet *') -> 'bool': + t_converted = _ffi.cast('TimestampTz', t) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overbefore_timestamptz_spanset(t_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_bigint_set(i: int, s: "const Set *") -> "bool": - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def overleft_bigint_set(i: int, s: 'const Set *') -> 'bool': + i_converted = _ffi.cast('int64', i) + s_converted = _ffi.cast('const Set *', s) result = _lib.overleft_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_bigint_span(i: int, s: "const Span *") -> "bool": - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Span *", s) +def overleft_bigint_span(i: int, s: 'const Span *') -> 'bool': + i_converted = _ffi.cast('int64', i) + s_converted = _ffi.cast('const Span *', s) result = _lib.overleft_bigint_span(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_bigint_spanset(i: int, ss: "const SpanSet *") -> "bool": - i_converted = _ffi.cast("int64", i) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_bigint_spanset(i: int, ss: 'const SpanSet *') -> 'bool': + i_converted = _ffi.cast('int64', i) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overleft_bigint_spanset(i_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_float_set(d: float, s: "const Set *") -> "bool": - s_converted = _ffi.cast("const Set *", s) +def overleft_float_set(d: float, s: 'const Set *') -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.overleft_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_float_span(d: float, s: "const Span *") -> "bool": - s_converted = _ffi.cast("const Span *", s) +def overleft_float_span(d: float, s: 'const Span *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.overleft_float_span(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_float_spanset(d: float, ss: "const SpanSet *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_float_spanset(d: float, ss: 'const SpanSet *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overleft_float_spanset(d, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_int_set(i: int, s: "const Set *") -> "bool": - s_converted = _ffi.cast("const Set *", s) +def overleft_int_set(i: int, s: 'const Set *') -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.overleft_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_int_span(i: int, s: "const Span *") -> "bool": - s_converted = _ffi.cast("const Span *", s) +def overleft_int_span(i: int, s: 'const Span *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.overleft_int_span(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_int_spanset(i: int, ss: "const SpanSet *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_int_spanset(i: int, ss: 'const SpanSet *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overleft_int_spanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_set_bigint(s: "const Set *", i: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def overleft_set_bigint(s: 'const Set *', i: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) + i_converted = _ffi.cast('int64', i) result = _lib.overleft_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_set_float(s: "const Set *", d: float) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def overleft_set_float(s: 'const Set *', d: float) -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.overleft_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def overleft_set_int(s: "const Set *", i: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def overleft_set_int(s: 'const Set *', i: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.overleft_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def overleft_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def overleft_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.overleft_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_set_text(s: "const Set *", txt: str) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def overleft_set_text(s: 'const Set *', txt: str) -> 'bool': + s_converted = _ffi.cast('const Set *', s) txt_converted = cstring2text(txt) result = _lib.overleft_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_span_bigint(s: "const Span *", i: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def overleft_span_bigint(s: 'const Span *', i: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) + i_converted = _ffi.cast('int64', i) result = _lib.overleft_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_span_float(s: "const Span *", d: float) -> "bool": - s_converted = _ffi.cast("const Span *", s) +def overleft_span_float(s: 'const Span *', d: float) -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.overleft_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def overleft_span_int(s: "const Span *", i: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) +def overleft_span_int(s: 'const Span *', i: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.overleft_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def overleft_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def overleft_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.overleft_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overleft_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_spanset_bigint(ss: "const SpanSet *", i: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def overleft_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + i_converted = _ffi.cast('int64', i) result = _lib.overleft_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_spanset_float(ss: "const SpanSet *", d: float) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_spanset_float(ss: 'const SpanSet *', d: float) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overleft_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def overleft_spanset_int(ss: "const SpanSet *", i: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_spanset_int(ss: 'const SpanSet *', i: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overleft_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def overleft_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def overleft_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.overleft_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def overleft_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.overleft_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_text_set(txt: str, s: "const Set *") -> "bool": +def overleft_text_set(txt: str, s: 'const Set *') -> 'bool': txt_converted = cstring2text(txt) - s_converted = _ffi.cast("const Set *", s) + s_converted = _ffi.cast('const Set *', s) result = _lib.overleft_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_bigint_set(i: int, s: "const Set *") -> "bool": - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def overright_bigint_set(i: int, s: 'const Set *') -> 'bool': + i_converted = _ffi.cast('int64', i) + s_converted = _ffi.cast('const Set *', s) result = _lib.overright_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_bigint_span(i: int, s: "const Span *") -> "bool": - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Span *", s) +def overright_bigint_span(i: int, s: 'const Span *') -> 'bool': + i_converted = _ffi.cast('int64', i) + s_converted = _ffi.cast('const Span *', s) result = _lib.overright_bigint_span(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_bigint_spanset(i: int, ss: "const SpanSet *") -> "bool": - i_converted = _ffi.cast("int64", i) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_bigint_spanset(i: int, ss: 'const SpanSet *') -> 'bool': + i_converted = _ffi.cast('int64', i) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overright_bigint_spanset(i_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overright_float_set(d: float, s: "const Set *") -> "bool": - s_converted = _ffi.cast("const Set *", s) +def overright_float_set(d: float, s: 'const Set *') -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.overright_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_float_span(d: float, s: "const Span *") -> "bool": - s_converted = _ffi.cast("const Span *", s) +def overright_float_span(d: float, s: 'const Span *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.overright_float_span(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_float_spanset(d: float, ss: "const SpanSet *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_float_spanset(d: float, ss: 'const SpanSet *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overright_float_spanset(d, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overright_int_set(i: int, s: "const Set *") -> "bool": - s_converted = _ffi.cast("const Set *", s) +def overright_int_set(i: int, s: 'const Set *') -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.overright_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_int_span(i: int, s: "const Span *") -> "bool": - s_converted = _ffi.cast("const Span *", s) +def overright_int_span(i: int, s: 'const Span *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.overright_int_span(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_int_spanset(i: int, ss: "const SpanSet *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_int_spanset(i: int, ss: 'const SpanSet *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overright_int_spanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overright_set_bigint(s: "const Set *", i: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def overright_set_bigint(s: 'const Set *', i: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) + i_converted = _ffi.cast('int64', i) result = _lib.overright_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def overright_set_float(s: "const Set *", d: float) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def overright_set_float(s: 'const Set *', d: float) -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.overright_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def overright_set_int(s: "const Set *", i: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def overright_set_int(s: 'const Set *', i: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.overright_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def overright_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def overright_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.overright_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_set_text(s: "const Set *", txt: str) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def overright_set_text(s: 'const Set *', txt: str) -> 'bool': + s_converted = _ffi.cast('const Set *', s) txt_converted = cstring2text(txt) result = _lib.overright_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def overright_span_bigint(s: "const Span *", i: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def overright_span_bigint(s: 'const Span *', i: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) + i_converted = _ffi.cast('int64', i) result = _lib.overright_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def overright_span_float(s: "const Span *", d: float) -> "bool": - s_converted = _ffi.cast("const Span *", s) +def overright_span_float(s: 'const Span *', d: float) -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.overright_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def overright_span_int(s: "const Span *", i: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) +def overright_span_int(s: 'const Span *', i: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.overright_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def overright_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def overright_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.overright_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overright_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overright_spanset_bigint(ss: "const SpanSet *", i: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def overright_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + i_converted = _ffi.cast('int64', i) result = _lib.overright_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def overright_spanset_float(ss: "const SpanSet *", d: float) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_spanset_float(ss: 'const SpanSet *', d: float) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overright_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def overright_spanset_int(ss: "const SpanSet *", i: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_spanset_int(ss: 'const SpanSet *', i: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overright_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def overright_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def overright_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.overright_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def overright_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.overright_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_text_set(txt: str, s: "const Set *") -> "bool": +def overright_text_set(txt: str, s: 'const Set *') -> 'bool': txt_converted = cstring2text(txt) - s_converted = _ffi.cast("const Set *", s) + s_converted = _ffi.cast('const Set *', s) result = _lib.overright_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_bigint_set(i: int, s: "const Set *") -> "bool": - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Set *", s) +def right_bigint_set(i: int, s: 'const Set *') -> 'bool': + i_converted = _ffi.cast('int64', i) + s_converted = _ffi.cast('const Set *', s) result = _lib.right_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_bigint_span(i: int, s: "const Span *") -> "bool": - i_converted = _ffi.cast("int64", i) - s_converted = _ffi.cast("const Span *", s) +def right_bigint_span(i: int, s: 'const Span *') -> 'bool': + i_converted = _ffi.cast('int64', i) + s_converted = _ffi.cast('const Span *', s) result = _lib.right_bigint_span(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_bigint_spanset(i: int, ss: "const SpanSet *") -> "bool": - i_converted = _ffi.cast("int64", i) - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_bigint_spanset(i: int, ss: 'const SpanSet *') -> 'bool': + i_converted = _ffi.cast('int64', i) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.right_bigint_spanset(i_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def right_float_set(d: float, s: "const Set *") -> "bool": - s_converted = _ffi.cast("const Set *", s) +def right_float_set(d: float, s: 'const Set *') -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.right_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_float_span(d: float, s: "const Span *") -> "bool": - s_converted = _ffi.cast("const Span *", s) +def right_float_span(d: float, s: 'const Span *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.right_float_span(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_float_spanset(d: float, ss: "const SpanSet *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_float_spanset(d: float, ss: 'const SpanSet *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.right_float_spanset(d, ss_converted) _check_error() return result if result != _ffi.NULL else None -def right_int_set(i: int, s: "const Set *") -> "bool": - s_converted = _ffi.cast("const Set *", s) +def right_int_set(i: int, s: 'const Set *') -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.right_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_int_span(i: int, s: "const Span *") -> "bool": - s_converted = _ffi.cast("const Span *", s) +def right_int_span(i: int, s: 'const Span *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.right_int_span(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_int_spanset(i: int, ss: "const SpanSet *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_int_spanset(i: int, ss: 'const SpanSet *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.right_int_spanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def right_set_bigint(s: "const Set *", i: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def right_set_bigint(s: 'const Set *', i: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) + i_converted = _ffi.cast('int64', i) result = _lib.right_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def right_set_float(s: "const Set *", d: float) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def right_set_float(s: 'const Set *', d: float) -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.right_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def right_set_int(s: "const Set *", i: int) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def right_set_int(s: 'const Set *', i: int) -> 'bool': + s_converted = _ffi.cast('const Set *', s) result = _lib.right_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def right_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def right_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.right_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def right_set_text(s: "const Set *", txt: str) -> "bool": - s_converted = _ffi.cast("const Set *", s) +def right_set_text(s: 'const Set *', txt: str) -> 'bool': + s_converted = _ffi.cast('const Set *', s) txt_converted = cstring2text(txt) result = _lib.right_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def right_span_bigint(s: "const Span *", i: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def right_span_bigint(s: 'const Span *', i: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) + i_converted = _ffi.cast('int64', i) result = _lib.right_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def right_span_float(s: "const Span *", d: float) -> "bool": - s_converted = _ffi.cast("const Span *", s) +def right_span_float(s: 'const Span *', d: float) -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.right_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def right_span_int(s: "const Span *", i: int) -> "bool": - s_converted = _ffi.cast("const Span *", s) +def right_span_int(s: 'const Span *', i: int) -> 'bool': + s_converted = _ffi.cast('const Span *', s) result = _lib.right_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def right_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def right_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.right_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def right_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.right_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def right_spanset_bigint(ss: "const SpanSet *", i: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def right_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + i_converted = _ffi.cast('int64', i) result = _lib.right_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def right_spanset_float(ss: "const SpanSet *", d: float) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_spanset_float(ss: 'const SpanSet *', d: float) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.right_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def right_spanset_int(ss: "const SpanSet *", i: int) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_spanset_int(ss: 'const SpanSet *', i: int) -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.right_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def right_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def right_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.right_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def right_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.right_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def right_text_set(txt: str, s: "const Set *") -> "bool": +def right_text_set(txt: str, s: 'const Set *') -> 'bool': txt_converted = cstring2text(txt) - s_converted = _ffi.cast("const Set *", s) + s_converted = _ffi.cast('const Set *', s) result = _lib.right_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def distance_set_bigint(s: "const Set *", i: int) -> "double": - s_converted = _ffi.cast("const Set *", s) - i_converted = _ffi.cast("int64", i) +def distance_set_bigint(s: 'const Set *', i: int) -> 'double': + s_converted = _ffi.cast('const Set *', s) + i_converted = _ffi.cast('int64', i) result = _lib.distance_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def distance_set_float(s: "const Set *", d: float) -> "double": - s_converted = _ffi.cast("const Set *", s) +def distance_set_float(s: 'const Set *', d: float) -> 'double': + s_converted = _ffi.cast('const Set *', s) result = _lib.distance_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def distance_set_int(s: "const Set *", i: int) -> "double": - s_converted = _ffi.cast("const Set *", s) +def distance_set_int(s: 'const Set *', i: int) -> 'double': + s_converted = _ffi.cast('const Set *', s) result = _lib.distance_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def distance_set_set(s1: "const Set *", s2: "const Set *") -> "double": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def distance_set_set(s1: 'const Set *', s2: 'const Set *') -> 'double': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.distance_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def distance_set_timestamptz(s: "const Set *", t: int) -> "double": - s_converted = _ffi.cast("const Set *", s) - t_converted = _ffi.cast("TimestampTz", t) +def distance_set_timestamptz(s: 'const Set *', t: int) -> 'double': + s_converted = _ffi.cast('const Set *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.distance_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def distance_set_date(s: "const Set *", d: "DateADT") -> "double": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("DateADT", d) +def distance_set_date(s: 'const Set *', d: 'DateADT') -> 'double': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.distance_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def distance_span_bigint(s: "const Span *", i: int) -> "double": - s_converted = _ffi.cast("const Span *", s) - i_converted = _ffi.cast("int64", i) +def distance_span_bigint(s: 'const Span *', i: int) -> 'double': + s_converted = _ffi.cast('const Span *', s) + i_converted = _ffi.cast('int64', i) result = _lib.distance_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def distance_span_float(s: "const Span *", d: float) -> "double": - s_converted = _ffi.cast("const Span *", s) +def distance_span_float(s: 'const Span *', d: float) -> 'double': + s_converted = _ffi.cast('const Span *', s) result = _lib.distance_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def distance_span_int(s: "const Span *", i: int) -> "double": - s_converted = _ffi.cast("const Span *", s) +def distance_span_int(s: 'const Span *', i: int) -> 'double': + s_converted = _ffi.cast('const Span *', s) result = _lib.distance_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def distance_span_span(s1: "const Span *", s2: "const Span *") -> "double": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def distance_span_span(s1: 'const Span *', s2: 'const Span *') -> 'double': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.distance_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def distance_span_timestamptz(s: "const Span *", t: int) -> "double": - s_converted = _ffi.cast("const Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def distance_span_timestamptz(s: 'const Span *', t: int) -> 'double': + s_converted = _ffi.cast('const Span *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.distance_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def distance_span_date(s: "const Span *", d: "DateADT") -> "double": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("DateADT", d) +def distance_span_date(s: 'const Span *', d: 'DateADT') -> 'double': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('DateADT', d) result = _lib.distance_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_bigint(ss: "const SpanSet *", i: int) -> "double": - ss_converted = _ffi.cast("const SpanSet *", ss) - i_converted = _ffi.cast("int64", i) +def distance_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'double': + ss_converted = _ffi.cast('const SpanSet *', ss) + i_converted = _ffi.cast('int64', i) result = _lib.distance_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_float(ss: "const SpanSet *", d: float) -> "double": - ss_converted = _ffi.cast("const SpanSet *", ss) +def distance_spanset_float(ss: 'const SpanSet *', d: float) -> 'double': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.distance_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_int(ss: "const SpanSet *", i: int) -> "double": - ss_converted = _ffi.cast("const SpanSet *", ss) +def distance_spanset_int(ss: 'const SpanSet *', i: int) -> 'double': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.distance_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "double": - ss_converted = _ffi.cast("const SpanSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def distance_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'double': + ss_converted = _ffi.cast('const SpanSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.distance_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "double": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("DateADT", d) +def distance_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'double': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('DateADT', d) result = _lib.distance_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "double": - ss_converted = _ffi.cast("const SpanSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def distance_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'double': + ss_converted = _ffi.cast('const SpanSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.distance_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_spanset( - ss1: "const SpanSet *", ss2: "const SpanSet *" -) -> "double": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def distance_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'double': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.distance_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def set_cmp(s1: "const Set *", s2: "const Set *") -> "int": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_cmp(s1: 'const Set *', s2: 'const Set *') -> 'int': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.set_cmp(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def set_eq(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_eq(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.set_eq(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def set_ge(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_ge(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.set_ge(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def set_gt(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_gt(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.set_gt(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def set_le(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_le(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.set_le(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def set_lt(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_lt(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.set_lt(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def set_ne(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_ne(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.set_ne(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def span_cmp(s1: "const Span *", s2: "const Span *") -> "int": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_cmp(s1: 'const Span *', s2: 'const Span *') -> 'int': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.span_cmp(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def span_eq(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_eq(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.span_eq(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def span_ge(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_ge(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.span_ge(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def span_gt(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_gt(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.span_gt(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def span_le(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_le(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.span_le(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def span_lt(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_lt(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.span_lt(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def span_ne(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_ne(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.span_ne(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_cmp(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "int": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_cmp(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'int': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.spanset_cmp(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_eq(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_eq(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.spanset_eq(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_ge(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_ge(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.spanset_ge(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_gt(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_gt(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.spanset_gt(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_le(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_le(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.spanset_le(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_lt(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_lt(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.spanset_lt(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_ne(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_ne(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.spanset_ne(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def bigint_extent_transfn(s: "Span *", i: int) -> "Span *": - s_converted = _ffi.cast("Span *", s) - i_converted = _ffi.cast("int64", i) +def bigint_extent_transfn(s: 'Span *', i: int) -> 'Span *': + s_converted = _ffi.cast('Span *', s) + i_converted = _ffi.cast('int64', i) result = _lib.bigint_extent_transfn(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def bigint_union_transfn(state: "Set *", i: int) -> "Set *": - state_converted = _ffi.cast("Set *", state) - i_converted = _ffi.cast("int64", i) +def bigint_union_transfn(state: 'Set *', i: int) -> 'Set *': + state_converted = _ffi.cast('Set *', state) + i_converted = _ffi.cast('int64', i) result = _lib.bigint_union_transfn(state_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def float_extent_transfn(s: "Span *", d: float) -> "Span *": - s_converted = _ffi.cast("Span *", s) +def float_extent_transfn(s: 'Span *', d: float) -> 'Span *': + s_converted = _ffi.cast('Span *', s) result = _lib.float_extent_transfn(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def float_union_transfn(state: "Set *", d: float) -> "Set *": - state_converted = _ffi.cast("Set *", state) +def float_union_transfn(state: 'Set *', d: float) -> 'Set *': + state_converted = _ffi.cast('Set *', state) result = _lib.float_union_transfn(state_converted, d) _check_error() return result if result != _ffi.NULL else None -def int_extent_transfn(s: "Span *", i: int) -> "Span *": - s_converted = _ffi.cast("Span *", s) +def int_extent_transfn(s: 'Span *', i: int) -> 'Span *': + s_converted = _ffi.cast('Span *', s) result = _lib.int_extent_transfn(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def int_union_transfn(state: "Set *", i: int) -> "Set *": - state_converted = _ffi.cast("Set *", state) +def int_union_transfn(state: 'Set *', i: int) -> 'Set *': + state_converted = _ffi.cast('Set *', state) result = _lib.int_union_transfn(state_converted, i) _check_error() return result if result != _ffi.NULL else None -def set_extent_transfn(span: "Span *", set: "const Set *") -> "Span *": - span_converted = _ffi.cast("Span *", span) - set_converted = _ffi.cast("const Set *", set) +def set_extent_transfn(span: 'Span *', set: 'const Set *') -> 'Span *': + span_converted = _ffi.cast('Span *', span) + set_converted = _ffi.cast('const Set *', set) result = _lib.set_extent_transfn(span_converted, set_converted) _check_error() return result if result != _ffi.NULL else None -def set_union_finalfn(state: "Set *") -> "Set *": - state_converted = _ffi.cast("Set *", state) +def set_union_finalfn(state: 'Set *') -> 'Set *': + state_converted = _ffi.cast('Set *', state) result = _lib.set_union_finalfn(state_converted) _check_error() return result if result != _ffi.NULL else None -def set_union_transfn(state: "Set *", set: "Set *") -> "Set *": - state_converted = _ffi.cast("Set *", state) - set_converted = _ffi.cast("Set *", set) +def set_union_transfn(state: 'Set *', set: 'Set *') -> 'Set *': + state_converted = _ffi.cast('Set *', state) + set_converted = _ffi.cast('Set *', set) result = _lib.set_union_transfn(state_converted, set_converted) _check_error() return result if result != _ffi.NULL else None -def span_extent_transfn(s1: "Span *", s2: "const Span *") -> "Span *": - s1_converted = _ffi.cast("Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_extent_transfn(s1: 'Span *', s2: 'const Span *') -> 'Span *': + s1_converted = _ffi.cast('Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.span_extent_transfn(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def span_union_transfn(state: "SpanSet *", span: "const Span *") -> "SpanSet *": - state_converted = _ffi.cast("SpanSet *", state) - span_converted = _ffi.cast("const Span *", span) +def span_union_transfn(state: 'SpanSet *', span: 'const Span *') -> 'SpanSet *': + state_converted = _ffi.cast('SpanSet *', state) + span_converted = _ffi.cast('const Span *', span) result = _lib.span_union_transfn(state_converted, span_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_extent_transfn(s: "Span *", ss: "const SpanSet *") -> "Span *": - s_converted = _ffi.cast("Span *", s) - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_extent_transfn(s: 'Span *', ss: 'const SpanSet *') -> 'Span *': + s_converted = _ffi.cast('Span *', s) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_extent_transfn(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_union_finalfn(state: "SpanSet *") -> "SpanSet *": - state_converted = _ffi.cast("SpanSet *", state) +def spanset_union_finalfn(state: 'SpanSet *') -> 'SpanSet *': + state_converted = _ffi.cast('SpanSet *', state) result = _lib.spanset_union_finalfn(state_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_union_transfn(state: "SpanSet *", ss: "const SpanSet *") -> "SpanSet *": - state_converted = _ffi.cast("SpanSet *", state) - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_union_transfn(state: 'SpanSet *', ss: 'const SpanSet *') -> 'SpanSet *': + state_converted = _ffi.cast('SpanSet *', state) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_union_transfn(state_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def text_union_transfn(state: "Set *", txt: str) -> "Set *": - state_converted = _ffi.cast("Set *", state) +def text_union_transfn(state: 'Set *', txt: str) -> 'Set *': + state_converted = _ffi.cast('Set *', state) txt_converted = cstring2text(txt) result = _lib.text_union_transfn(state_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_extent_transfn(s: "Span *", t: int) -> "Span *": - s_converted = _ffi.cast("Span *", s) - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_extent_transfn(s: 'Span *', t: int) -> 'Span *': + s_converted = _ffi.cast('Span *', s) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.timestamptz_extent_transfn(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_tcount_transfn(state: "Optional['SkipList *']", t: int) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_tcount_transfn(state: "Optional['SkipList *']", t: int) -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + t_converted = _ffi.cast('TimestampTz', t) result = _lib.timestamptz_tcount_transfn(state_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_union_transfn(state: "Set *", t: int) -> "Set *": - state_converted = _ffi.cast("Set *", state) - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_union_transfn(state: 'Set *', t: int) -> 'Set *': + state_converted = _ffi.cast('Set *', state) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.timestamptz_union_transfn(state_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_tcount_transfn( - state: "Optional['SkipList *']", s: "const Set *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - s_converted = _ffi.cast("const Set *", s) +def tstzset_tcount_transfn(state: "Optional['SkipList *']", s: 'const Set *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + s_converted = _ffi.cast('const Set *', s) result = _lib.tstzset_tcount_transfn(state_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_tcount_transfn( - state: "Optional['SkipList *']", s: "const Span *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - s_converted = _ffi.cast("const Span *", s) +def tstzspan_tcount_transfn(state: "Optional['SkipList *']", s: 'const Span *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + s_converted = _ffi.cast('const Span *', s) result = _lib.tstzspan_tcount_transfn(state_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_tcount_transfn( - state: "Optional['SkipList *']", ss: "const SpanSet *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_tcount_transfn(state: "Optional['SkipList *']", ss: 'const SpanSet *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tstzspanset_tcount_transfn(state_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_in(string: str) -> "TBox *": - string_converted = string.encode("utf-8") +def tbox_in(string: str) -> 'TBox *': + string_converted = string.encode('utf-8') result = _lib.tbox_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_out(box: "const TBox *", maxdd: int) -> str: - box_converted = _ffi.cast("const TBox *", box) +def tbox_out(box: 'const TBox *', maxdd: int) -> str: + box_converted = _ffi.cast('const TBox *', box) result = _lib.tbox_out(box_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tbox_from_wkb(wkb: bytes) -> "TBOX *": - wkb_converted = _ffi.new("uint8_t []", wkb) +def tbox_from_wkb(wkb: bytes) -> 'TBOX *': + wkb_converted = _ffi.new('uint8_t []', wkb) result = _lib.tbox_from_wkb(wkb_converted, len(wkb)) return result if result != _ffi.NULL else None -def tbox_from_hexwkb(hexwkb: str) -> "TBox *": - hexwkb_converted = hexwkb.encode("utf-8") +def tbox_from_hexwkb(hexwkb: str) -> 'TBox *': + hexwkb_converted = hexwkb.encode('utf-8') result = _lib.tbox_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_from_wkb(wkb: bytes) -> "STBOX *": - wkb_converted = _ffi.new("uint8_t []", wkb) +def stbox_from_wkb(wkb: bytes) -> 'STBOX *': + wkb_converted = _ffi.new('uint8_t []', wkb) result = _lib.stbox_from_wkb(wkb_converted, len(wkb)) return result if result != _ffi.NULL else None -def stbox_from_hexwkb(hexwkb: str) -> "STBox *": - hexwkb_converted = hexwkb.encode("utf-8") +def stbox_from_hexwkb(hexwkb: str) -> 'STBox *': + hexwkb_converted = hexwkb.encode('utf-8') result = _lib.stbox_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_as_wkb(box: "const TBox *", variant: int) -> bytes: - box_converted = _ffi.cast("const TBox *", box) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") +def tbox_as_wkb(box: 'const TBox *', variant: int) -> bytes: + box_converted = _ffi.cast('const TBox *', box) + variant_converted = _ffi.cast('uint8_t', variant) + size_out = _ffi.new('size_t *') result = _lib.tbox_as_wkb(box_converted, variant_converted, size_out) _check_error() - result_converted = ( - bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None - ) + result_converted = bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None return result_converted -def tbox_as_hexwkb(box: "const TBox *", variant: int) -> "Tuple[str, 'size_t *']": - box_converted = _ffi.cast("const TBox *", box) - variant_converted = _ffi.cast("uint8_t", variant) - size = _ffi.new("size_t *") +def tbox_as_hexwkb(box: 'const TBox *', variant: int) -> "Tuple[str, 'size_t *']": + box_converted = _ffi.cast('const TBox *', box) + variant_converted = _ffi.cast('uint8_t', variant) + size = _ffi.new('size_t *') result = _lib.tbox_as_hexwkb(box_converted, variant_converted, size) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None, size[0] -def stbox_as_wkb(box: "const STBox *", variant: int) -> bytes: - box_converted = _ffi.cast("const STBox *", box) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") +def stbox_as_wkb(box: 'const STBox *', variant: int) -> bytes: + box_converted = _ffi.cast('const STBox *', box) + variant_converted = _ffi.cast('uint8_t', variant) + size_out = _ffi.new('size_t *') result = _lib.stbox_as_wkb(box_converted, variant_converted, size_out) _check_error() - result_converted = ( - bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None - ) + result_converted = bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None return result_converted -def stbox_as_hexwkb(box: "const STBox *", variant: int) -> "Tuple[str, 'size_t *']": - box_converted = _ffi.cast("const STBox *", box) - variant_converted = _ffi.cast("uint8_t", variant) - size = _ffi.new("size_t *") +def stbox_as_hexwkb(box: 'const STBox *', variant: int) -> "Tuple[str, 'size_t *']": + box_converted = _ffi.cast('const STBox *', box) + variant_converted = _ffi.cast('uint8_t', variant) + size = _ffi.new('size_t *') result = _lib.stbox_as_hexwkb(box_converted, variant_converted, size) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None, size[0] -def stbox_in(string: str) -> "STBox *": - string_converted = string.encode("utf-8") +def stbox_in(string: str) -> 'STBox *': + string_converted = string.encode('utf-8') result = _lib.stbox_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_out(box: "const STBox *", maxdd: int) -> str: - box_converted = _ffi.cast("const STBox *", box) +def stbox_out(box: 'const STBox *', maxdd: int) -> str: + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_out(box_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def float_tstzspan_to_tbox(d: float, s: "const Span *") -> "TBox *": - s_converted = _ffi.cast("const Span *", s) +def float_tstzspan_to_tbox(d: float, s: 'const Span *') -> 'TBox *': + s_converted = _ffi.cast('const Span *', s) result = _lib.float_tstzspan_to_tbox(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def float_timestamptz_to_tbox(d: float, t: int) -> "TBox *": - t_converted = _ffi.cast("TimestampTz", t) +def float_timestamptz_to_tbox(d: float, t: int) -> 'TBox *': + t_converted = _ffi.cast('TimestampTz', t) result = _lib.float_timestamptz_to_tbox(d, t_converted) _check_error() return result if result != _ffi.NULL else None -def geo_tstzspan_to_stbox(gs: "const GSERIALIZED *", s: "const Span *") -> "STBox *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - s_converted = _ffi.cast("const Span *", s) +def geo_tstzspan_to_stbox(gs: 'const GSERIALIZED *', s: 'const Span *') -> 'STBox *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + s_converted = _ffi.cast('const Span *', s) result = _lib.geo_tstzspan_to_stbox(gs_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def geo_timestamptz_to_stbox(gs: "const GSERIALIZED *", t: int) -> "STBox *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - t_converted = _ffi.cast("TimestampTz", t) +def geo_timestamptz_to_stbox(gs: 'const GSERIALIZED *', t: int) -> 'STBox *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.geo_timestamptz_to_stbox(gs_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def int_tstzspan_to_tbox(i: int, s: "const Span *") -> "TBox *": - s_converted = _ffi.cast("const Span *", s) +def int_tstzspan_to_tbox(i: int, s: 'const Span *') -> 'TBox *': + s_converted = _ffi.cast('const Span *', s) result = _lib.int_tstzspan_to_tbox(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def int_timestamptz_to_tbox(i: int, t: int) -> "TBox *": - t_converted = _ffi.cast("TimestampTz", t) +def int_timestamptz_to_tbox(i: int, t: int) -> 'TBox *': + t_converted = _ffi.cast('TimestampTz', t) result = _lib.int_timestamptz_to_tbox(i, t_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_tstzspan_to_tbox(span: "const Span *", s: "const Span *") -> "TBox *": - span_converted = _ffi.cast("const Span *", span) - s_converted = _ffi.cast("const Span *", s) +def numspan_tstzspan_to_tbox(span: 'const Span *', s: 'const Span *') -> 'TBox *': + span_converted = _ffi.cast('const Span *', span) + s_converted = _ffi.cast('const Span *', s) result = _lib.numspan_tstzspan_to_tbox(span_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_timestamptz_to_tbox(span: "const Span *", t: int) -> "TBox *": - span_converted = _ffi.cast("const Span *", span) - t_converted = _ffi.cast("TimestampTz", t) +def numspan_timestamptz_to_tbox(span: 'const Span *', t: int) -> 'TBox *': + span_converted = _ffi.cast('const Span *', span) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.numspan_timestamptz_to_tbox(span_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_copy(box: "const STBox *") -> "STBox *": - box_converted = _ffi.cast("const STBox *", box) +def stbox_copy(box: 'const STBox *') -> 'STBox *': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_copy(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_make( - hasx: bool, - hasz: bool, - geodetic: bool, - srid: int, - xmin: float, - xmax: float, - ymin: float, - ymax: float, - zmin: float, - zmax: float, - s: "const Span *", -) -> "STBox *": - srid_converted = _ffi.cast("int32", srid) - s_converted = _ffi.cast("const Span *", s) - result = _lib.stbox_make( - hasx, - hasz, - geodetic, - srid_converted, - xmin, - xmax, - ymin, - ymax, - zmin, - zmax, - s_converted, - ) +def stbox_make(hasx: bool, hasz: bool, geodetic: bool, srid: int, xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float, s: 'const Span *') -> 'STBox *': + srid_converted = _ffi.cast('int32', srid) + s_converted = _ffi.cast('const Span *', s) + result = _lib.stbox_make(hasx, hasz, geodetic, srid_converted, xmin, xmax, ymin, ymax, zmin, zmax, s_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_copy(box: "const TBox *") -> "TBox *": - box_converted = _ffi.cast("const TBox *", box) +def tbox_copy(box: 'const TBox *') -> 'TBox *': + box_converted = _ffi.cast('const TBox *', box) result = _lib.tbox_copy(box_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_make(s: "Optional['const Span *']", p: "Optional['const Span *']") -> "TBox *": - s_converted = _ffi.cast("const Span *", s) if s is not None else _ffi.NULL - p_converted = _ffi.cast("const Span *", p) if p is not None else _ffi.NULL +def tbox_make(s: "Optional['const Span *']", p: "Optional['const Span *']") -> 'TBox *': + s_converted = _ffi.cast('const Span *', s) if s is not None else _ffi.NULL + p_converted = _ffi.cast('const Span *', p) if p is not None else _ffi.NULL result = _lib.tbox_make(s_converted, p_converted) _check_error() return result if result != _ffi.NULL else None -def box3d_to_stbox(box: "const BOX3D *") -> "STBox *": - box_converted = _ffi.cast("const BOX3D *", box) +def box3d_to_stbox(box: 'const BOX3D *') -> 'STBox *': + box_converted = _ffi.cast('const BOX3D *', box) result = _lib.box3d_to_stbox(box_converted) _check_error() return result if result != _ffi.NULL else None -def gbox_to_stbox(box: "const GBOX *") -> "STBox *": - box_converted = _ffi.cast("const GBOX *", box) +def gbox_to_stbox(box: 'const GBOX *') -> 'STBox *': + box_converted = _ffi.cast('const GBOX *', box) result = _lib.gbox_to_stbox(box_converted) _check_error() return result if result != _ffi.NULL else None -def float_to_tbox(d: float) -> "TBox *": +def float_to_tbox(d: float) -> 'TBox *': result = _lib.float_to_tbox(d) _check_error() return result if result != _ffi.NULL else None -def geo_to_stbox(gs: "const GSERIALIZED *") -> "STBox *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_to_stbox(gs: 'const GSERIALIZED *') -> 'STBox *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geo_to_stbox(gs_converted) _check_error() return result if result != _ffi.NULL else None -def int_to_tbox(i: int) -> "TBox *": +def int_to_tbox(i: int) -> 'TBox *': result = _lib.int_to_tbox(i) _check_error() return result if result != _ffi.NULL else None -def numset_to_tbox(s: "const Set *") -> "TBox *": - s_converted = _ffi.cast("const Set *", s) +def numset_to_tbox(s: 'const Set *') -> 'TBox *': + s_converted = _ffi.cast('const Set *', s) result = _lib.numset_to_tbox(s_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_to_tbox(s: "const Span *") -> "TBox *": - s_converted = _ffi.cast("const Span *", s) +def numspan_to_tbox(s: 'const Span *') -> 'TBox *': + s_converted = _ffi.cast('const Span *', s) result = _lib.numspan_to_tbox(s_converted) _check_error() return result if result != _ffi.NULL else None -def numspanset_to_tbox(ss: "const SpanSet *") -> "TBox *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def numspanset_to_tbox(ss: 'const SpanSet *') -> 'TBox *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.numspanset_to_tbox(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_to_stbox(s: "const Span *") -> "STBox *": - s_converted = _ffi.cast("const Span *", s) +def tstzspan_to_stbox(s: 'const Span *') -> 'STBox *': + s_converted = _ffi.cast('const Span *', s) result = _lib.tstzspan_to_stbox(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_to_tbox(s: "const Span *") -> "TBox *": - s_converted = _ffi.cast("const Span *", s) +def tstzspan_to_tbox(s: 'const Span *') -> 'TBox *': + s_converted = _ffi.cast('const Span *', s) result = _lib.tstzspan_to_tbox(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_to_stbox(ss: "const SpanSet *") -> "STBox *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_to_stbox(ss: 'const SpanSet *') -> 'STBox *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tstzspanset_to_stbox(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_to_tbox(ss: "const SpanSet *") -> "TBox *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def tstzspanset_to_tbox(ss: 'const SpanSet *') -> 'TBox *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tstzspanset_to_tbox(ss_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_to_gbox(box: "const STBox *") -> "GBOX *": - box_converted = _ffi.cast("const STBox *", box) +def stbox_to_gbox(box: 'const STBox *') -> 'GBOX *': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_to_gbox(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_to_box3d(box: "const STBox *") -> "BOX3D *": - box_converted = _ffi.cast("const STBox *", box) +def stbox_to_box3d(box: 'const STBox *') -> 'BOX3D *': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_to_box3d(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_to_geo(box: "const STBox *") -> "GSERIALIZED *": - box_converted = _ffi.cast("const STBox *", box) +def stbox_to_geo(box: 'const STBox *') -> 'GSERIALIZED *': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_to_geo(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_to_tstzspan(box: "const STBox *") -> "Span *": - box_converted = _ffi.cast("const STBox *", box) +def stbox_to_tstzspan(box: 'const STBox *') -> 'Span *': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_to_tstzspan(box_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_to_intspan(box: "const TBox *") -> "Span *": - box_converted = _ffi.cast("const TBox *", box) +def tbox_to_intspan(box: 'const TBox *') -> 'Span *': + box_converted = _ffi.cast('const TBox *', box) result = _lib.tbox_to_intspan(box_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_to_floatspan(box: "const TBox *") -> "Span *": - box_converted = _ffi.cast("const TBox *", box) +def tbox_to_floatspan(box: 'const TBox *') -> 'Span *': + box_converted = _ffi.cast('const TBox *', box) result = _lib.tbox_to_floatspan(box_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_to_tstzspan(box: "const TBox *") -> "Span *": - box_converted = _ffi.cast("const TBox *", box) +def tbox_to_tstzspan(box: 'const TBox *') -> 'Span *': + box_converted = _ffi.cast('const TBox *', box) result = _lib.tbox_to_tstzspan(box_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_to_stbox(t: int) -> "STBox *": - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_to_stbox(t: int) -> 'STBox *': + t_converted = _ffi.cast('TimestampTz', t) result = _lib.timestamptz_to_stbox(t_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_to_tbox(t: int) -> "TBox *": - t_converted = _ffi.cast("TimestampTz", t) +def timestamptz_to_tbox(t: int) -> 'TBox *': + t_converted = _ffi.cast('TimestampTz', t) result = _lib.timestamptz_to_tbox(t_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_to_stbox(s: "const Set *") -> "STBox *": - s_converted = _ffi.cast("const Set *", s) +def tstzset_to_stbox(s: 'const Set *') -> 'STBox *': + s_converted = _ffi.cast('const Set *', s) result = _lib.tstzset_to_stbox(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_to_tbox(ss: "const Set *") -> "TBox *": - ss_converted = _ffi.cast("const Set *", ss) +def tstzset_to_tbox(ss: 'const Set *') -> 'TBox *': + ss_converted = _ffi.cast('const Set *', ss) result = _lib.tstzset_to_tbox(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_to_tbox(temp: "const Temporal *") -> "TBox *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_to_tbox(temp: 'const Temporal *') -> 'TBox *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_to_tbox(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_to_stbox(temp: "const Temporal *") -> "STBox *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_to_stbox(temp: 'const Temporal *') -> 'STBox *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_to_stbox(temp_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_hast(box: "const STBox *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) +def stbox_hast(box: 'const STBox *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_hast(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_hasx(box: "const STBox *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) +def stbox_hasx(box: 'const STBox *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_hasx(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_hasz(box: "const STBox *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) +def stbox_hasz(box: 'const STBox *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_hasz(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_isgeodetic(box: "const STBox *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) +def stbox_isgeodetic(box: 'const STBox *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_isgeodetic(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_srid(box: "const STBox *") -> "int32": - box_converted = _ffi.cast("const STBox *", box) +def stbox_srid(box: 'const STBox *') -> 'int32': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_srid(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_tmax(box: "const STBox *") -> int: - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("TimestampTz *") +def stbox_tmax(box: 'const STBox *') -> int: + box_converted = _ffi.cast('const STBox *', box) + out_result = _ffi.new('TimestampTz *') result = _lib.stbox_tmax(box_converted, out_result) _check_error() if result: @@ -5385,9 +5235,9 @@ def stbox_tmax(box: "const STBox *") -> int: return None -def stbox_tmax_inc(box: "const STBox *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("bool *") +def stbox_tmax_inc(box: 'const STBox *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + out_result = _ffi.new('bool *') result = _lib.stbox_tmax_inc(box_converted, out_result) _check_error() if result: @@ -5395,9 +5245,9 @@ def stbox_tmax_inc(box: "const STBox *") -> "bool": return None -def stbox_tmin(box: "const STBox *") -> int: - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("TimestampTz *") +def stbox_tmin(box: 'const STBox *') -> int: + box_converted = _ffi.cast('const STBox *', box) + out_result = _ffi.new('TimestampTz *') result = _lib.stbox_tmin(box_converted, out_result) _check_error() if result: @@ -5405,9 +5255,9 @@ def stbox_tmin(box: "const STBox *") -> int: return None -def stbox_tmin_inc(box: "const STBox *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("bool *") +def stbox_tmin_inc(box: 'const STBox *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + out_result = _ffi.new('bool *') result = _lib.stbox_tmin_inc(box_converted, out_result) _check_error() if result: @@ -5415,9 +5265,9 @@ def stbox_tmin_inc(box: "const STBox *") -> "bool": return None -def stbox_xmax(box: "const STBox *") -> "double": - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("double *") +def stbox_xmax(box: 'const STBox *') -> 'double': + box_converted = _ffi.cast('const STBox *', box) + out_result = _ffi.new('double *') result = _lib.stbox_xmax(box_converted, out_result) _check_error() if result: @@ -5425,9 +5275,9 @@ def stbox_xmax(box: "const STBox *") -> "double": return None -def stbox_xmin(box: "const STBox *") -> "double": - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("double *") +def stbox_xmin(box: 'const STBox *') -> 'double': + box_converted = _ffi.cast('const STBox *', box) + out_result = _ffi.new('double *') result = _lib.stbox_xmin(box_converted, out_result) _check_error() if result: @@ -5435,9 +5285,9 @@ def stbox_xmin(box: "const STBox *") -> "double": return None -def stbox_ymax(box: "const STBox *") -> "double": - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("double *") +def stbox_ymax(box: 'const STBox *') -> 'double': + box_converted = _ffi.cast('const STBox *', box) + out_result = _ffi.new('double *') result = _lib.stbox_ymax(box_converted, out_result) _check_error() if result: @@ -5445,9 +5295,9 @@ def stbox_ymax(box: "const STBox *") -> "double": return None -def stbox_ymin(box: "const STBox *") -> "double": - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("double *") +def stbox_ymin(box: 'const STBox *') -> 'double': + box_converted = _ffi.cast('const STBox *', box) + out_result = _ffi.new('double *') result = _lib.stbox_ymin(box_converted, out_result) _check_error() if result: @@ -5455,9 +5305,9 @@ def stbox_ymin(box: "const STBox *") -> "double": return None -def stbox_zmax(box: "const STBox *") -> "double": - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("double *") +def stbox_zmax(box: 'const STBox *') -> 'double': + box_converted = _ffi.cast('const STBox *', box) + out_result = _ffi.new('double *') result = _lib.stbox_zmax(box_converted, out_result) _check_error() if result: @@ -5465,9 +5315,9 @@ def stbox_zmax(box: "const STBox *") -> "double": return None -def stbox_zmin(box: "const STBox *") -> "double": - box_converted = _ffi.cast("const STBox *", box) - out_result = _ffi.new("double *") +def stbox_zmin(box: 'const STBox *') -> 'double': + box_converted = _ffi.cast('const STBox *', box) + out_result = _ffi.new('double *') result = _lib.stbox_zmin(box_converted, out_result) _check_error() if result: @@ -5475,23 +5325,23 @@ def stbox_zmin(box: "const STBox *") -> "double": return None -def tbox_hast(box: "const TBox *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) +def tbox_hast(box: 'const TBox *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) result = _lib.tbox_hast(box_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_hasx(box: "const TBox *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) +def tbox_hasx(box: 'const TBox *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) result = _lib.tbox_hasx(box_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_tmax(box: "const TBox *") -> int: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("TimestampTz *") +def tbox_tmax(box: 'const TBox *') -> int: + box_converted = _ffi.cast('const TBox *', box) + out_result = _ffi.new('TimestampTz *') result = _lib.tbox_tmax(box_converted, out_result) _check_error() if result: @@ -5499,9 +5349,9 @@ def tbox_tmax(box: "const TBox *") -> int: return None -def tbox_tmax_inc(box: "const TBox *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("bool *") +def tbox_tmax_inc(box: 'const TBox *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + out_result = _ffi.new('bool *') result = _lib.tbox_tmax_inc(box_converted, out_result) _check_error() if result: @@ -5509,9 +5359,9 @@ def tbox_tmax_inc(box: "const TBox *") -> "bool": return None -def tbox_tmin(box: "const TBox *") -> int: - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("TimestampTz *") +def tbox_tmin(box: 'const TBox *') -> int: + box_converted = _ffi.cast('const TBox *', box) + out_result = _ffi.new('TimestampTz *') result = _lib.tbox_tmin(box_converted, out_result) _check_error() if result: @@ -5519,9 +5369,9 @@ def tbox_tmin(box: "const TBox *") -> int: return None -def tbox_tmin_inc(box: "const TBox *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("bool *") +def tbox_tmin_inc(box: 'const TBox *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + out_result = _ffi.new('bool *') result = _lib.tbox_tmin_inc(box_converted, out_result) _check_error() if result: @@ -5529,9 +5379,9 @@ def tbox_tmin_inc(box: "const TBox *") -> "bool": return None -def tbox_xmax(box: "const TBox *") -> "double": - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("double *") +def tbox_xmax(box: 'const TBox *') -> 'double': + box_converted = _ffi.cast('const TBox *', box) + out_result = _ffi.new('double *') result = _lib.tbox_xmax(box_converted, out_result) _check_error() if result: @@ -5539,9 +5389,9 @@ def tbox_xmax(box: "const TBox *") -> "double": return None -def tbox_xmax_inc(box: "const TBox *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("bool *") +def tbox_xmax_inc(box: 'const TBox *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + out_result = _ffi.new('bool *') result = _lib.tbox_xmax_inc(box_converted, out_result) _check_error() if result: @@ -5549,9 +5399,9 @@ def tbox_xmax_inc(box: "const TBox *") -> "bool": return None -def tbox_xmin(box: "const TBox *") -> "double": - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("double *") +def tbox_xmin(box: 'const TBox *') -> 'double': + box_converted = _ffi.cast('const TBox *', box) + out_result = _ffi.new('double *') result = _lib.tbox_xmin(box_converted, out_result) _check_error() if result: @@ -5559,9 +5409,9 @@ def tbox_xmin(box: "const TBox *") -> "double": return None -def tbox_xmin_inc(box: "const TBox *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("bool *") +def tbox_xmin_inc(box: 'const TBox *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + out_result = _ffi.new('bool *') result = _lib.tbox_xmin_inc(box_converted, out_result) _check_error() if result: @@ -5569,9 +5419,9 @@ def tbox_xmin_inc(box: "const TBox *") -> "bool": return None -def tboxfloat_xmax(box: "const TBox *") -> "double": - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("double *") +def tboxfloat_xmax(box: 'const TBox *') -> 'double': + box_converted = _ffi.cast('const TBox *', box) + out_result = _ffi.new('double *') result = _lib.tboxfloat_xmax(box_converted, out_result) _check_error() if result: @@ -5579,9 +5429,9 @@ def tboxfloat_xmax(box: "const TBox *") -> "double": return None -def tboxfloat_xmin(box: "const TBox *") -> "double": - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("double *") +def tboxfloat_xmin(box: 'const TBox *') -> 'double': + box_converted = _ffi.cast('const TBox *', box) + out_result = _ffi.new('double *') result = _lib.tboxfloat_xmin(box_converted, out_result) _check_error() if result: @@ -5589,9 +5439,9 @@ def tboxfloat_xmin(box: "const TBox *") -> "double": return None -def tboxint_xmax(box: "const TBox *") -> "int": - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("int *") +def tboxint_xmax(box: 'const TBox *') -> 'int': + box_converted = _ffi.cast('const TBox *', box) + out_result = _ffi.new('int *') result = _lib.tboxint_xmax(box_converted, out_result) _check_error() if result: @@ -5599,9 +5449,9 @@ def tboxint_xmax(box: "const TBox *") -> "int": return None -def tboxint_xmin(box: "const TBox *") -> "int": - box_converted = _ffi.cast("const TBox *", box) - out_result = _ffi.new("int *") +def tboxint_xmin(box: 'const TBox *') -> 'int': + box_converted = _ffi.cast('const TBox *', box) + out_result = _ffi.new('int *') result = _lib.tboxint_xmin(box_converted, out_result) _check_error() if result: @@ -5609,146 +5459,118 @@ def tboxint_xmin(box: "const TBox *") -> "int": return None -def stbox_expand_space(box: "const STBox *", d: float) -> "STBox *": - box_converted = _ffi.cast("const STBox *", box) +def stbox_expand_space(box: 'const STBox *', d: float) -> 'STBox *': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_expand_space(box_converted, d) _check_error() return result if result != _ffi.NULL else None -def stbox_expand_time(box: "const STBox *", interval: "const Interval *") -> "STBox *": - box_converted = _ffi.cast("const STBox *", box) - interval_converted = _ffi.cast("const Interval *", interval) +def stbox_expand_time(box: 'const STBox *', interval: 'const Interval *') -> 'STBox *': + box_converted = _ffi.cast('const STBox *', box) + interval_converted = _ffi.cast('const Interval *', interval) result = _lib.stbox_expand_time(box_converted, interval_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_get_space(box: "const STBox *") -> "STBox *": - box_converted = _ffi.cast("const STBox *", box) +def stbox_get_space(box: 'const STBox *') -> 'STBox *': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_get_space(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_round(box: "const STBox *", maxdd: int) -> "STBox *": - box_converted = _ffi.cast("const STBox *", box) +def stbox_round(box: 'const STBox *', maxdd: int) -> 'STBox *': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_round(box_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def stbox_set_srid(box: "const STBox *", srid: int) -> "STBox *": - box_converted = _ffi.cast("const STBox *", box) - srid_converted = _ffi.cast("int32", srid) +def stbox_set_srid(box: 'const STBox *', srid: int) -> 'STBox *': + box_converted = _ffi.cast('const STBox *', box) + srid_converted = _ffi.cast('int32', srid) result = _lib.stbox_set_srid(box_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_shift_scale_time( - box: "const STBox *", - shift: "Optional['const Interval *']", - duration: "Optional['const Interval *']", -) -> "STBox *": - box_converted = _ffi.cast("const STBox *", box) - shift_converted = ( - _ffi.cast("const Interval *", shift) if shift is not None else _ffi.NULL - ) - duration_converted = ( - _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL - ) - result = _lib.stbox_shift_scale_time( - box_converted, shift_converted, duration_converted - ) +def stbox_shift_scale_time(box: 'const STBox *', shift: "Optional['const Interval *']", duration: "Optional['const Interval *']") -> 'STBox *': + box_converted = _ffi.cast('const STBox *', box) + shift_converted = _ffi.cast('const Interval *', shift) if shift is not None else _ffi.NULL + duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL + result = _lib.stbox_shift_scale_time(box_converted, shift_converted, duration_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_expand_time(box: "const TBox *", interval: "const Interval *") -> "TBox *": - box_converted = _ffi.cast("const TBox *", box) - interval_converted = _ffi.cast("const Interval *", interval) +def tbox_expand_time(box: 'const TBox *', interval: 'const Interval *') -> 'TBox *': + box_converted = _ffi.cast('const TBox *', box) + interval_converted = _ffi.cast('const Interval *', interval) result = _lib.tbox_expand_time(box_converted, interval_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_expand_float(box: "const TBox *", d: "const double") -> "TBox *": - box_converted = _ffi.cast("const TBox *", box) - d_converted = _ffi.cast("const double", d) +def tbox_expand_float(box: 'const TBox *', d: 'const double') -> 'TBox *': + box_converted = _ffi.cast('const TBox *', box) + d_converted = _ffi.cast('const double', d) result = _lib.tbox_expand_float(box_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_expand_int(box: "const TBox *", i: "const int") -> "TBox *": - box_converted = _ffi.cast("const TBox *", box) - i_converted = _ffi.cast("const int", i) +def tbox_expand_int(box: 'const TBox *', i: 'const int') -> 'TBox *': + box_converted = _ffi.cast('const TBox *', box) + i_converted = _ffi.cast('const int', i) result = _lib.tbox_expand_int(box_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_round(box: "const TBox *", maxdd: int) -> "TBox *": - box_converted = _ffi.cast("const TBox *", box) +def tbox_round(box: 'const TBox *', maxdd: int) -> 'TBox *': + box_converted = _ffi.cast('const TBox *', box) result = _lib.tbox_round(box_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def tbox_shift_scale_float( - box: "const TBox *", shift: float, width: float, hasshift: bool, haswidth: bool -) -> "TBox *": - box_converted = _ffi.cast("const TBox *", box) - result = _lib.tbox_shift_scale_float( - box_converted, shift, width, hasshift, haswidth - ) +def tbox_shift_scale_float(box: 'const TBox *', shift: float, width: float, hasshift: bool, haswidth: bool) -> 'TBox *': + box_converted = _ffi.cast('const TBox *', box) + result = _lib.tbox_shift_scale_float(box_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def tbox_shift_scale_int( - box: "const TBox *", shift: int, width: int, hasshift: bool, haswidth: bool -) -> "TBox *": - box_converted = _ffi.cast("const TBox *", box) +def tbox_shift_scale_int(box: 'const TBox *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'TBox *': + box_converted = _ffi.cast('const TBox *', box) result = _lib.tbox_shift_scale_int(box_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def tbox_shift_scale_time( - box: "const TBox *", - shift: "Optional['const Interval *']", - duration: "Optional['const Interval *']", -) -> "TBox *": - box_converted = _ffi.cast("const TBox *", box) - shift_converted = ( - _ffi.cast("const Interval *", shift) if shift is not None else _ffi.NULL - ) - duration_converted = ( - _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL - ) - result = _lib.tbox_shift_scale_time( - box_converted, shift_converted, duration_converted - ) +def tbox_shift_scale_time(box: 'const TBox *', shift: "Optional['const Interval *']", duration: "Optional['const Interval *']") -> 'TBox *': + box_converted = _ffi.cast('const TBox *', box) + shift_converted = _ffi.cast('const Interval *', shift) if shift is not None else _ffi.NULL + duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL + result = _lib.tbox_shift_scale_time(box_converted, shift_converted, duration_converted) _check_error() return result if result != _ffi.NULL else None -def union_tbox_tbox( - box1: "const TBox *", box2: "const TBox *", strict: bool -) -> "TBox *": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def union_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *', strict: bool) -> 'TBox *': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.union_tbox_tbox(box1_converted, box2_converted, strict) _check_error() return result if result != _ffi.NULL else None -def inter_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "TBox *": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) - out_result = _ffi.new("TBox *") +def inter_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'TBox *': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) + out_result = _ffi.new('TBox *') result = _lib.inter_tbox_tbox(box1_converted, box2_converted, out_result) _check_error() if result: @@ -5756,28 +5578,26 @@ def inter_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "TBox *": return None -def intersection_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "TBox *": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def intersection_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'TBox *': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.intersection_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def union_stbox_stbox( - box1: "const STBox *", box2: "const STBox *", strict: bool -) -> "STBox *": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def union_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *', strict: bool) -> 'STBox *': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.union_stbox_stbox(box1_converted, box2_converted, strict) _check_error() return result if result != _ffi.NULL else None -def inter_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "STBox *": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) - out_result = _ffi.new("STBox *") +def inter_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'STBox *': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) + out_result = _ffi.new('STBox *') result = _lib.inter_stbox_stbox(box1_converted, box2_converted, out_result) _check_error() if result: @@ -5785,1046 +5605,993 @@ def inter_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "STBox *" return None -def intersection_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "STBox *": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def intersection_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'STBox *': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.intersection_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def contains_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.contains_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def contained_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.contained_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def overlaps_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.overlaps_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def same_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def same_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.same_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def adjacent_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.adjacent_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def contains_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.contains_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def contained_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.contained_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overlaps_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.overlaps_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def same_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def same_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.same_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def adjacent_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.adjacent_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def left_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def left_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.left_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def overleft_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.overleft_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def right_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def right_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.right_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def overright_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.overright_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def before_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def before_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.before_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def overbefore_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.overbefore_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def after_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def after_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.after_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def overafter_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.overafter_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def left_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def left_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.left_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overleft_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.overleft_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def right_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def right_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.right_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overright_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.overright_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def below_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def below_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.below_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overbelow_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.overbelow_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def above_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def above_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.above_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overabove_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.overabove_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def front_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def front_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.front_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overfront_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.overfront_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def back_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def back_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.back_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overback_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overback_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.overback_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def before_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def before_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.before_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overbefore_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.overbefore_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def after_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def after_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.after_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def overafter_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.overafter_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_quad_split(box: "const STBox *") -> "Tuple['STBox *', 'int']": - box_converted = _ffi.cast("const STBox *", box) - count = _ffi.new("int *") +def stbox_quad_split(box: 'const STBox *') -> "Tuple['STBox *', 'int']": + box_converted = _ffi.cast('const STBox *', box) + count = _ffi.new('int *') result = _lib.stbox_quad_split(box_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tbox_eq(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_eq(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.tbox_eq(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_ne(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_ne(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.tbox_ne(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_cmp(box1: "const TBox *", box2: "const TBox *") -> "int": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_cmp(box1: 'const TBox *', box2: 'const TBox *') -> 'int': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.tbox_cmp(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_lt(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_lt(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.tbox_lt(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_le(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_le(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.tbox_le(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_ge(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_ge(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.tbox_ge(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_gt(box1: "const TBox *", box2: "const TBox *") -> "bool": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def tbox_gt(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.tbox_gt(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_eq(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_eq(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.stbox_eq(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_ne(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_ne(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.stbox_ne(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_cmp(box1: "const STBox *", box2: "const STBox *") -> "int": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_cmp(box1: 'const STBox *', box2: 'const STBox *') -> 'int': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.stbox_cmp(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_lt(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_lt(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.stbox_lt(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_le(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_le(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.stbox_le(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_ge(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_ge(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.stbox_ge(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_gt(box1: "const STBox *", box2: "const STBox *") -> "bool": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def stbox_gt(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.stbox_gt(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_in(string: str) -> "Temporal *": - string_converted = string.encode("utf-8") +def tbool_in(string: str) -> 'Temporal *': + string_converted = string.encode('utf-8') result = _lib.tbool_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_out(temp: "const Temporal *") -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_out(temp: 'const Temporal *') -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_out(temp_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def temporal_as_hexwkb( - temp: "const Temporal *", variant: int -) -> "Tuple[str, 'size_t *']": - temp_converted = _ffi.cast("const Temporal *", temp) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") +def temporal_as_hexwkb(temp: 'const Temporal *', variant: int) -> "Tuple[str, 'size_t *']": + temp_converted = _ffi.cast('const Temporal *', temp) + variant_converted = _ffi.cast('uint8_t', variant) + size_out = _ffi.new('size_t *') result = _lib.temporal_as_hexwkb(temp_converted, variant_converted, size_out) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None, size_out[0] -def temporal_as_mfjson( - temp: "const Temporal *", - with_bbox: bool, - flags: int, - precision: int, - srs: "Optional[str]", -) -> str: - temp_converted = _ffi.cast("const Temporal *", temp) - srs_converted = srs.encode("utf-8") if srs is not None else _ffi.NULL - result = _lib.temporal_as_mfjson( - temp_converted, with_bbox, flags, precision, srs_converted - ) +def temporal_as_mfjson(temp: 'const Temporal *', with_bbox: bool, flags: int, precision: int, srs: "Optional[str]") -> str: + temp_converted = _ffi.cast('const Temporal *', temp) + srs_converted = srs.encode('utf-8') if srs is not None else _ffi.NULL + result = _lib.temporal_as_mfjson(temp_converted, with_bbox, flags, precision, srs_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def temporal_as_wkb(temp: "const Temporal *", variant: int) -> bytes: - temp_converted = _ffi.cast("const Temporal *", temp) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") +def temporal_as_wkb(temp: 'const Temporal *', variant: int) -> bytes: + temp_converted = _ffi.cast('const Temporal *', temp) + variant_converted = _ffi.cast('uint8_t', variant) + size_out = _ffi.new('size_t *') result = _lib.temporal_as_wkb(temp_converted, variant_converted, size_out) _check_error() - result_converted = ( - bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None - ) + result_converted = bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None return result_converted -def temporal_from_hexwkb(hexwkb: str) -> "Temporal *": - hexwkb_converted = hexwkb.encode("utf-8") +def temporal_from_hexwkb(hexwkb: str) -> 'Temporal *': + hexwkb_converted = hexwkb.encode('utf-8') result = _lib.temporal_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_from_mfjson(mfjson: str) -> "Temporal *": - mfjson_converted = mfjson.encode("utf-8") +def temporal_from_mfjson(mfjson: str) -> 'Temporal *': + mfjson_converted = mfjson.encode('utf-8') result = _lib.temporal_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_from_wkb(wkb: bytes) -> "Temporal *": - wkb_converted = _ffi.new("uint8_t []", wkb) +def temporal_from_wkb(wkb: bytes) -> 'Temporal *': + wkb_converted = _ffi.new('uint8_t []', wkb) result = _lib.temporal_from_wkb(wkb_converted, len(wkb)) return result if result != _ffi.NULL else None -def tfloat_in(string: str) -> "Temporal *": - string_converted = string.encode("utf-8") +def tfloat_in(string: str) -> 'Temporal *': + string_converted = string.encode('utf-8') result = _lib.tfloat_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_out(temp: "const Temporal *", maxdd: int) -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_out(temp: 'const Temporal *', maxdd: int) -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_out(temp_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tgeogpoint_in(string: str) -> "Temporal *": - string_converted = string.encode("utf-8") +def tgeogpoint_in(string: str) -> 'Temporal *': + string_converted = string.encode('utf-8') result = _lib.tgeogpoint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_in(string: str) -> "Temporal *": - string_converted = string.encode("utf-8") +def tgeompoint_in(string: str) -> 'Temporal *': + string_converted = string.encode('utf-8') result = _lib.tgeompoint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tint_in(string: str) -> "Temporal *": - string_converted = string.encode("utf-8") +def tint_in(string: str) -> 'Temporal *': + string_converted = string.encode('utf-8') result = _lib.tint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tint_out(temp: "const Temporal *") -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_out(temp: 'const Temporal *') -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_out(temp_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tpoint_as_ewkt(temp: "const Temporal *", maxdd: int) -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_as_ewkt(temp: 'const Temporal *', maxdd: int) -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_as_ewkt(temp_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tpoint_as_text(temp: "const Temporal *", maxdd: int) -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_as_text(temp: 'const Temporal *', maxdd: int) -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_as_text(temp_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tpoint_out(temp: "const Temporal *", maxdd: int) -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_out(temp: 'const Temporal *', maxdd: int) -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_out(temp_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def ttext_in(string: str) -> "Temporal *": - string_converted = string.encode("utf-8") +def ttext_in(string: str) -> 'Temporal *': + string_converted = string.encode('utf-8') result = _lib.ttext_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_out(temp: "const Temporal *") -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_out(temp: 'const Temporal *') -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ttext_out(temp_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def temporal_cp(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_cp(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_cp(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_from_base_temp(b: bool, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_from_base_temp(b: bool, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_from_base_temp(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tboolinst_make(b: bool, t: int) -> "TInstant *": - t_converted = _ffi.cast("TimestampTz", t) +def tboolinst_make(b: bool, t: int) -> 'TInstant *': + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tboolinst_make(b, t_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseq_from_base_tstzset(b: bool, s: "const Set *") -> "TSequence *": - s_converted = _ffi.cast("const Set *", s) +def tboolseq_from_base_tstzset(b: bool, s: 'const Set *') -> 'TSequence *': + s_converted = _ffi.cast('const Set *', s) result = _lib.tboolseq_from_base_tstzset(b, s_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseq_from_base_tstzspan(b: bool, s: "const Span *") -> "TSequence *": - s_converted = _ffi.cast("const Span *", s) +def tboolseq_from_base_tstzspan(b: bool, s: 'const Span *') -> 'TSequence *': + s_converted = _ffi.cast('const Span *', s) result = _lib.tboolseq_from_base_tstzspan(b, s_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseqset_from_base_tstzspanset( - b: bool, ss: "const SpanSet *" -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def tboolseqset_from_base_tstzspanset(b: bool, ss: 'const SpanSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tboolseqset_from_base_tstzspanset(b, ss_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_copy(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_copy(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_copy(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_from_base_temp(d: float, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_from_base_temp(d: float, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_from_base_temp(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatinst_make(d: float, t: int) -> "TInstant *": - t_converted = _ffi.cast("TimestampTz", t) +def tfloatinst_make(d: float, t: int) -> 'TInstant *': + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tfloatinst_make(d, t_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseq_from_base_tstzspan( - d: float, s: "const Span *", interp: "interpType" -) -> "TSequence *": - s_converted = _ffi.cast("const Span *", s) - interp_converted = _ffi.cast("interpType", interp) +def tfloatseq_from_base_tstzspan(d: float, s: 'const Span *', interp: 'interpType') -> 'TSequence *': + s_converted = _ffi.cast('const Span *', s) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tfloatseq_from_base_tstzspan(d, s_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseq_from_base_tstzset(d: float, s: "const Set *") -> "TSequence *": - s_converted = _ffi.cast("const Set *", s) +def tfloatseq_from_base_tstzset(d: float, s: 'const Set *') -> 'TSequence *': + s_converted = _ffi.cast('const Set *', s) result = _lib.tfloatseq_from_base_tstzset(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseqset_from_base_tstzspanset( - d: float, ss: "const SpanSet *", interp: "interpType" -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - interp_converted = _ffi.cast("interpType", interp) +def tfloatseqset_from_base_tstzspanset(d: float, ss: 'const SpanSet *', interp: 'interpType') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tfloatseqset_from_base_tstzspanset(d, ss_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_from_base_temp(i: int, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_from_base_temp(i: int, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_from_base_temp(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tintinst_make(i: int, t: int) -> "TInstant *": - t_converted = _ffi.cast("TimestampTz", t) +def tintinst_make(i: int, t: int) -> 'TInstant *': + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tintinst_make(i, t_converted) _check_error() return result if result != _ffi.NULL else None -def tintseq_from_base_tstzspan(i: int, s: "const Span *") -> "TSequence *": - s_converted = _ffi.cast("const Span *", s) +def tintseq_from_base_tstzspan(i: int, s: 'const Span *') -> 'TSequence *': + s_converted = _ffi.cast('const Span *', s) result = _lib.tintseq_from_base_tstzspan(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def tintseq_from_base_tstzset(i: int, s: "const Set *") -> "TSequence *": - s_converted = _ffi.cast("const Set *", s) +def tintseq_from_base_tstzset(i: int, s: 'const Set *') -> 'TSequence *': + s_converted = _ffi.cast('const Set *', s) result = _lib.tintseq_from_base_tstzset(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def tintseqset_from_base_tstzspanset(i: int, ss: "const SpanSet *") -> "TSequenceSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def tintseqset_from_base_tstzspanset(i: int, ss: 'const SpanSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tintseqset_from_base_tstzspanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_from_base_temp( - gs: "const GSERIALIZED *", temp: "const Temporal *" -) -> "Temporal *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_from_base_temp(gs: 'const GSERIALIZED *', temp: 'const Temporal *') -> 'Temporal *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_from_base_temp(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpointinst_make(gs: "const GSERIALIZED *", t: int) -> "TInstant *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - t_converted = _ffi.cast("TimestampTz", t) +def tpointinst_make(gs: 'const GSERIALIZED *', t: int) -> 'TInstant *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tpointinst_make(gs_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_from_base_tstzspan( - gs: "const GSERIALIZED *", s: "const Span *", interp: "interpType" -) -> "TSequence *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - s_converted = _ffi.cast("const Span *", s) - interp_converted = _ffi.cast("interpType", interp) - result = _lib.tpointseq_from_base_tstzspan( - gs_converted, s_converted, interp_converted - ) +def tpointseq_from_base_tstzspan(gs: 'const GSERIALIZED *', s: 'const Span *', interp: 'interpType') -> 'TSequence *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + s_converted = _ffi.cast('const Span *', s) + interp_converted = _ffi.cast('interpType', interp) + result = _lib.tpointseq_from_base_tstzspan(gs_converted, s_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_from_base_tstzset( - gs: "const GSERIALIZED *", s: "const Set *" -) -> "TSequence *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - s_converted = _ffi.cast("const Set *", s) +def tpointseq_from_base_tstzset(gs: 'const GSERIALIZED *', s: 'const Set *') -> 'TSequence *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + s_converted = _ffi.cast('const Set *', s) result = _lib.tpointseq_from_base_tstzset(gs_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_from_base_tstzspanset( - gs: "const GSERIALIZED *", ss: "const SpanSet *", interp: "interpType" -) -> "TSequenceSet *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - ss_converted = _ffi.cast("const SpanSet *", ss) - interp_converted = _ffi.cast("interpType", interp) - result = _lib.tpointseqset_from_base_tstzspanset( - gs_converted, ss_converted, interp_converted - ) +def tpointseqset_from_base_tstzspanset(gs: 'const GSERIALIZED *', ss: 'const SpanSet *', interp: 'interpType') -> 'TSequenceSet *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + ss_converted = _ffi.cast('const SpanSet *', ss) + interp_converted = _ffi.cast('interpType', interp) + result = _lib.tpointseqset_from_base_tstzspanset(gs_converted, ss_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_make( - instants: "const TInstant **", - count: int, - lower_inc: bool, - upper_inc: bool, - interp: "interpType", - normalize: bool, -) -> "TSequence *": - instants_converted = [_ffi.cast("const TInstant *", x) for x in instants] - interp_converted = _ffi.cast("interpType", interp) - result = _lib.tsequence_make( - instants_converted, count, lower_inc, upper_inc, interp_converted, normalize - ) +def tsequence_make(instants: 'const TInstant **', count: int, lower_inc: bool, upper_inc: bool, interp: 'interpType', normalize: bool) -> 'TSequence *': + instants_converted = [_ffi.cast('const TInstant *', x) for x in instants] + interp_converted = _ffi.cast('interpType', interp) + result = _lib.tsequence_make(instants_converted, count, lower_inc, upper_inc, interp_converted, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_make( - sequences: "const TSequence **", count: int, normalize: bool -) -> "TSequenceSet *": - sequences_converted = [_ffi.cast("const TSequence *", x) for x in sequences] +def tsequenceset_make(sequences: 'const TSequence **', count: int, normalize: bool) -> 'TSequenceSet *': + sequences_converted = [_ffi.cast('const TSequence *', x) for x in sequences] result = _lib.tsequenceset_make(sequences_converted, count, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_make_gaps( - instants: "const TInstant **", - count: int, - interp: "interpType", - maxt: "Interval *", - maxdist: float, -) -> "TSequenceSet *": - instants_converted = [_ffi.cast("const TInstant *", x) for x in instants] - interp_converted = _ffi.cast("interpType", interp) - maxt_converted = _ffi.cast("Interval *", maxt) - result = _lib.tsequenceset_make_gaps( - instants_converted, count, interp_converted, maxt_converted, maxdist - ) +def tsequenceset_make_gaps(instants: 'const TInstant **', count: int, interp: 'interpType', maxt: 'Interval *', maxdist: float) -> 'TSequenceSet *': + instants_converted = [_ffi.cast('const TInstant *', x) for x in instants] + interp_converted = _ffi.cast('interpType', interp) + maxt_converted = _ffi.cast('Interval *', maxt) + result = _lib.tsequenceset_make_gaps(instants_converted, count, interp_converted, maxt_converted, maxdist) _check_error() return result if result != _ffi.NULL else None -def ttext_from_base_temp(txt: str, temp: "const Temporal *") -> "Temporal *": +def ttext_from_base_temp(txt: str, temp: 'const Temporal *') -> 'Temporal *': txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ttext_from_base_temp(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ttextinst_make(txt: str, t: int) -> "TInstant *": +def ttextinst_make(txt: str, t: int) -> 'TInstant *': txt_converted = cstring2text(txt) - t_converted = _ffi.cast("TimestampTz", t) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.ttextinst_make(txt_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def ttextseq_from_base_tstzspan(txt: str, s: "const Span *") -> "TSequence *": +def ttextseq_from_base_tstzspan(txt: str, s: 'const Span *') -> 'TSequence *': txt_converted = cstring2text(txt) - s_converted = _ffi.cast("const Span *", s) + s_converted = _ffi.cast('const Span *', s) result = _lib.ttextseq_from_base_tstzspan(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def ttextseq_from_base_tstzset(txt: str, s: "const Set *") -> "TSequence *": +def ttextseq_from_base_tstzset(txt: str, s: 'const Set *') -> 'TSequence *': txt_converted = cstring2text(txt) - s_converted = _ffi.cast("const Set *", s) + s_converted = _ffi.cast('const Set *', s) result = _lib.ttextseq_from_base_tstzset(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def ttextseqset_from_base_tstzspanset( - txt: str, ss: "const SpanSet *" -) -> "TSequenceSet *": +def ttextseqset_from_base_tstzspanset(txt: str, ss: 'const SpanSet *') -> 'TSequenceSet *': txt_converted = cstring2text(txt) - ss_converted = _ffi.cast("const SpanSet *", ss) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.ttextseqset_from_base_tstzspanset(txt_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_to_tstzspan(temp: "const Temporal *") -> "Span *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_to_tstzspan(temp: 'const Temporal *') -> 'Span *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_to_tstzspan(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_to_tint(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_to_tint(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_to_tint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_to_tfloat(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_to_tfloat(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_to_tfloat(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_to_span(temp: "const Temporal *") -> "Span *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_to_span(temp: 'const Temporal *') -> 'Span *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_to_span(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_end_value(temp: "const Temporal *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_end_value(temp: 'const Temporal *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_end_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_start_value(temp: "const Temporal *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_start_value(temp: 'const Temporal *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_start_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_values(temp: "const Temporal *") -> "Tuple['bool *', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - count = _ffi.new("int *") +def tbool_values(temp: 'const Temporal *') -> "Tuple['bool *', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') result = _lib.tbool_values(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_duration(temp: "const Temporal *", boundspan: bool) -> "Interval *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_duration(temp: 'const Temporal *', boundspan: bool) -> 'Interval *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_duration(temp_converted, boundspan) _check_error() return result if result != _ffi.NULL else None -def temporal_end_instant(temp: "const Temporal *") -> "const TInstant *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_end_instant(temp: 'const Temporal *') -> 'const TInstant *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_end_instant(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_end_sequence(temp: "const Temporal *") -> "TSequence *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_end_sequence(temp: 'const Temporal *') -> 'TSequence *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_end_sequence(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_end_timestamptz(temp: "const Temporal *") -> "TimestampTz": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_end_timestamptz(temp: 'const Temporal *') -> 'TimestampTz': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_end_timestamptz(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_hash(temp: "const Temporal *") -> "uint32": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_hash(temp: 'const Temporal *') -> 'uint32': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_hash(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_instant_n(temp: "const Temporal *", n: int) -> "const TInstant *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_instant_n(temp: 'const Temporal *', n: int) -> 'const TInstant *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_instant_n(temp_converted, n) _check_error() return result if result != _ffi.NULL else None -def temporal_instants(temp: "const Temporal *") -> "Tuple['const TInstant **', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - count = _ffi.new("int *") +def temporal_instants(temp: 'const Temporal *') -> "Tuple['const TInstant **', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') result = _lib.temporal_instants(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_interp(temp: "const Temporal *") -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_interp(temp: 'const Temporal *') -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_interp(temp_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def temporal_max_instant(temp: "const Temporal *") -> "const TInstant *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_max_instant(temp: 'const Temporal *') -> 'const TInstant *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_max_instant(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_min_instant(temp: "const Temporal *") -> "const TInstant *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_min_instant(temp: 'const Temporal *') -> 'const TInstant *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_min_instant(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_num_instants(temp: "const Temporal *") -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_num_instants(temp: 'const Temporal *') -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_num_instants(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_num_sequences(temp: "const Temporal *") -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_num_sequences(temp: 'const Temporal *') -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_num_sequences(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_num_timestamps(temp: "const Temporal *") -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_num_timestamps(temp: 'const Temporal *') -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_num_timestamps(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_segments(temp: "const Temporal *") -> "Tuple['TSequence **', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - count = _ffi.new("int *") +def temporal_segments(temp: 'const Temporal *') -> "Tuple['TSequence **', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') result = _lib.temporal_segments(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_sequence_n(temp: "const Temporal *", i: int) -> "TSequence *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_sequence_n(temp: 'const Temporal *', i: int) -> 'TSequence *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_sequence_n(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def temporal_sequences(temp: "const Temporal *") -> "Tuple['TSequence **', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - count = _ffi.new("int *") +def temporal_sequences(temp: 'const Temporal *') -> "Tuple['TSequence **', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') result = _lib.temporal_sequences(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_start_instant(temp: "const Temporal *") -> "const TInstant *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_start_instant(temp: 'const Temporal *') -> 'const TInstant *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_start_instant(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_start_sequence(temp: "const Temporal *") -> "TSequence *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_start_sequence(temp: 'const Temporal *') -> 'TSequence *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_start_sequence(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_start_timestamptz(temp: "const Temporal *") -> "TimestampTz": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_start_timestamptz(temp: 'const Temporal *') -> 'TimestampTz': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_start_timestamptz(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_stops( - temp: "const Temporal *", maxdist: float, minduration: "const Interval *" -) -> "TSequenceSet *": - temp_converted = _ffi.cast("const Temporal *", temp) - minduration_converted = _ffi.cast("const Interval *", minduration) +def temporal_stops(temp: 'const Temporal *', maxdist: float, minduration: 'const Interval *') -> 'TSequenceSet *': + temp_converted = _ffi.cast('const Temporal *', temp) + minduration_converted = _ffi.cast('const Interval *', minduration) result = _lib.temporal_stops(temp_converted, maxdist, minduration_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_subtype(temp: "const Temporal *") -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_subtype(temp: 'const Temporal *') -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_subtype(temp_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def temporal_time(temp: "const Temporal *") -> "SpanSet *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_time(temp: 'const Temporal *') -> 'SpanSet *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_time(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_timestamptz_n(temp: "const Temporal *", n: int) -> int: - temp_converted = _ffi.cast("const Temporal *", temp) - out_result = _ffi.new("TimestampTz *") +def temporal_timestamptz_n(temp: 'const Temporal *', n: int) -> int: + temp_converted = _ffi.cast('const Temporal *', temp) + out_result = _ffi.new('TimestampTz *') result = _lib.temporal_timestamptz_n(temp_converted, n, out_result) _check_error() if result: @@ -6832,3074 +6599,2866 @@ def temporal_timestamptz_n(temp: "const Temporal *", n: int) -> int: return None -def temporal_timestamps(temp: "const Temporal *") -> "Tuple['TimestampTz *', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - count = _ffi.new("int *") +def temporal_timestamps(temp: 'const Temporal *') -> "Tuple['TimestampTz *', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') result = _lib.temporal_timestamps(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tfloat_end_value(temp: "const Temporal *") -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_end_value(temp: 'const Temporal *') -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_end_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_max_value(temp: "const Temporal *") -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_max_value(temp: 'const Temporal *') -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_max_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_min_value(temp: "const Temporal *") -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_min_value(temp: 'const Temporal *') -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_min_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_start_value(temp: "const Temporal *") -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_start_value(temp: 'const Temporal *') -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_start_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_values(temp: "const Temporal *") -> "Tuple['double *', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - count = _ffi.new("int *") +def tfloat_values(temp: 'const Temporal *') -> "Tuple['double *', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') result = _lib.tfloat_values(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tint_end_value(temp: "const Temporal *") -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_end_value(temp: 'const Temporal *') -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_end_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_max_value(temp: "const Temporal *") -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_max_value(temp: 'const Temporal *') -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_max_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_min_value(temp: "const Temporal *") -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_min_value(temp: 'const Temporal *') -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_min_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_start_value(temp: "const Temporal *") -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_start_value(temp: 'const Temporal *') -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_start_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_values(temp: "const Temporal *") -> "Tuple['int *', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - count = _ffi.new("int *") +def tint_values(temp: 'const Temporal *') -> "Tuple['int *', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') result = _lib.tint_values(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tnumber_valuespans(temp: "const Temporal *") -> "SpanSet *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_valuespans(temp: 'const Temporal *') -> 'SpanSet *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_valuespans(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_end_value(temp: "const Temporal *") -> "GSERIALIZED *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_end_value(temp: 'const Temporal *') -> 'GSERIALIZED *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_end_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_start_value(temp: "const Temporal *") -> "GSERIALIZED *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_start_value(temp: 'const Temporal *') -> 'GSERIALIZED *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_start_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_values(temp: "const Temporal *") -> "Tuple['GSERIALIZED **', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - count = _ffi.new("int *") +def tpoint_values(temp: 'const Temporal *') -> "Tuple['GSERIALIZED **', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') result = _lib.tpoint_values(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def ttext_end_value(temp: "const Temporal *") -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_end_value(temp: 'const Temporal *') -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ttext_end_value(temp_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def ttext_max_value(temp: "const Temporal *") -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_max_value(temp: 'const Temporal *') -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ttext_max_value(temp_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def ttext_min_value(temp: "const Temporal *") -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_min_value(temp: 'const Temporal *') -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ttext_min_value(temp_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def ttext_start_value(temp: "const Temporal *") -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_start_value(temp: 'const Temporal *') -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ttext_start_value(temp_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def ttext_values(temp: "const Temporal *") -> "Tuple['text **', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - count = _ffi.new("int *") +def ttext_values(temp: 'const Temporal *') -> "Tuple['text **', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') result = _lib.ttext_values(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_scale_time( - temp: "const Temporal *", duration: "const Interval *" -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) +def temporal_scale_time(temp: 'const Temporal *', duration: 'const Interval *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) result = _lib.temporal_scale_time(temp_converted, duration_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_set_interp(temp: "const Temporal *", interp: "interpType") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - interp_converted = _ffi.cast("interpType", interp) +def temporal_set_interp(temp: 'const Temporal *', interp: 'interpType') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + interp_converted = _ffi.cast('interpType', interp) result = _lib.temporal_set_interp(temp_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_shift_scale_time( - temp: "const Temporal *", - shift: "Optional['const Interval *']", - duration: "Optional['const Interval *']", -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - shift_converted = ( - _ffi.cast("const Interval *", shift) if shift is not None else _ffi.NULL - ) - duration_converted = ( - _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL - ) - result = _lib.temporal_shift_scale_time( - temp_converted, shift_converted, duration_converted - ) +def temporal_shift_scale_time(temp: 'const Temporal *', shift: "Optional['const Interval *']", duration: "Optional['const Interval *']") -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + shift_converted = _ffi.cast('const Interval *', shift) if shift is not None else _ffi.NULL + duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL + result = _lib.temporal_shift_scale_time(temp_converted, shift_converted, duration_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_shift_time( - temp: "const Temporal *", shift: "const Interval *" -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - shift_converted = _ffi.cast("const Interval *", shift) +def temporal_shift_time(temp: 'const Temporal *', shift: 'const Interval *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + shift_converted = _ffi.cast('const Interval *', shift) result = _lib.temporal_shift_time(temp_converted, shift_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_to_tinstant(temp: "const Temporal *") -> "TInstant *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_to_tinstant(temp: 'const Temporal *') -> 'TInstant *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_to_tinstant(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_to_tsequence( - temp: "const Temporal *", interp: "interpType" -) -> "TSequence *": - temp_converted = _ffi.cast("const Temporal *", temp) - interp_converted = _ffi.cast("interpType", interp) +def temporal_to_tsequence(temp: 'const Temporal *', interp: 'interpType') -> 'TSequence *': + temp_converted = _ffi.cast('const Temporal *', temp) + interp_converted = _ffi.cast('interpType', interp) result = _lib.temporal_to_tsequence(temp_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_to_tsequenceset( - temp: "const Temporal *", interp: "interpType" -) -> "TSequenceSet *": - temp_converted = _ffi.cast("const Temporal *", temp) - interp_converted = _ffi.cast("interpType", interp) +def temporal_to_tsequenceset(temp: 'const Temporal *', interp: 'interpType') -> 'TSequenceSet *': + temp_converted = _ffi.cast('const Temporal *', temp) + interp_converted = _ffi.cast('interpType', interp) result = _lib.temporal_to_tsequenceset(temp_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_scale_value(temp: "const Temporal *", width: float) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_scale_value(temp: 'const Temporal *', width: float) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_scale_value(temp_converted, width) _check_error() return result if result != _ffi.NULL else None -def tfloat_shift_scale_value( - temp: "const Temporal *", shift: float, width: float -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_shift_scale_value(temp: 'const Temporal *', shift: float, width: float) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_shift_scale_value(temp_converted, shift, width) _check_error() return result if result != _ffi.NULL else None -def tfloat_shift_value(temp: "const Temporal *", shift: float) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_shift_value(temp: 'const Temporal *', shift: float) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_shift_value(temp_converted, shift) _check_error() return result if result != _ffi.NULL else None -def tint_scale_value(temp: "const Temporal *", width: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_scale_value(temp: 'const Temporal *', width: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_scale_value(temp_converted, width) _check_error() return result if result != _ffi.NULL else None -def tint_shift_scale_value( - temp: "const Temporal *", shift: int, width: int -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_shift_scale_value(temp: 'const Temporal *', shift: int, width: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_shift_scale_value(temp_converted, shift, width) _check_error() return result if result != _ffi.NULL else None -def tint_shift_value(temp: "const Temporal *", shift: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_shift_value(temp: 'const Temporal *', shift: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_shift_value(temp_converted, shift) _check_error() return result if result != _ffi.NULL else None -def temporal_append_tinstant( - temp: "Temporal *", - inst: "const TInstant *", - maxdist: float, - maxt: "Optional['Interval *']", - expand: bool, -) -> "Temporal *": - temp_converted = _ffi.cast("Temporal *", temp) - inst_converted = _ffi.cast("const TInstant *", inst) - maxt_converted = _ffi.cast("Interval *", maxt) if maxt is not None else _ffi.NULL - result = _lib.temporal_append_tinstant( - temp_converted, inst_converted, maxdist, maxt_converted, expand - ) +def temporal_append_tinstant(temp: 'Temporal *', inst: 'const TInstant *', maxdist: float, maxt: "Optional['Interval *']", expand: bool) -> 'Temporal *': + temp_converted = _ffi.cast('Temporal *', temp) + inst_converted = _ffi.cast('const TInstant *', inst) + maxt_converted = _ffi.cast('Interval *', maxt) if maxt is not None else _ffi.NULL + result = _lib.temporal_append_tinstant(temp_converted, inst_converted, maxdist, maxt_converted, expand) _check_error() return result if result != _ffi.NULL else None -def temporal_append_tsequence( - temp: "Temporal *", seq: "const TSequence *", expand: bool -) -> "Temporal *": - temp_converted = _ffi.cast("Temporal *", temp) - seq_converted = _ffi.cast("const TSequence *", seq) +def temporal_append_tsequence(temp: 'Temporal *', seq: 'const TSequence *', expand: bool) -> 'Temporal *': + temp_converted = _ffi.cast('Temporal *', temp) + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.temporal_append_tsequence(temp_converted, seq_converted, expand) _check_error() return result if result != _ffi.NULL else None -def temporal_delete_tstzspan( - temp: "const Temporal *", s: "const Span *", connect: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def temporal_delete_tstzspan(temp: 'const Temporal *', s: 'const Span *', connect: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.temporal_delete_tstzspan(temp_converted, s_converted, connect) _check_error() return result if result != _ffi.NULL else None -def temporal_delete_tstzspanset( - temp: "const Temporal *", ss: "const SpanSet *", connect: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def temporal_delete_tstzspanset(temp: 'const Temporal *', ss: 'const SpanSet *', connect: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.temporal_delete_tstzspanset(temp_converted, ss_converted, connect) _check_error() return result if result != _ffi.NULL else None -def temporal_delete_timestamptz( - temp: "const Temporal *", t: int, connect: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) +def temporal_delete_timestamptz(temp: 'const Temporal *', t: int, connect: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.temporal_delete_timestamptz(temp_converted, t_converted, connect) _check_error() return result if result != _ffi.NULL else None -def temporal_delete_tstzset( - temp: "const Temporal *", s: "const Set *", connect: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Set *", s) +def temporal_delete_tstzset(temp: 'const Temporal *', s: 'const Set *', connect: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Set *', s) result = _lib.temporal_delete_tstzset(temp_converted, s_converted, connect) _check_error() return result if result != _ffi.NULL else None -def temporal_insert( - temp1: "const Temporal *", temp2: "const Temporal *", connect: bool -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_insert(temp1: 'const Temporal *', temp2: 'const Temporal *', connect: bool) -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.temporal_insert(temp1_converted, temp2_converted, connect) _check_error() return result if result != _ffi.NULL else None -def temporal_merge( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_merge(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.temporal_merge(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_merge_array(temparr: "Temporal **", count: int) -> "Temporal *": - temparr_converted = [_ffi.cast("Temporal *", x) for x in temparr] +def temporal_merge_array(temparr: 'Temporal **', count: int) -> 'Temporal *': + temparr_converted = [_ffi.cast('Temporal *', x) for x in temparr] result = _lib.temporal_merge_array(temparr_converted, count) _check_error() return result if result != _ffi.NULL else None -def temporal_update( - temp1: "const Temporal *", temp2: "const Temporal *", connect: bool -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_update(temp1: 'const Temporal *', temp2: 'const Temporal *', connect: bool) -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.temporal_update(temp1_converted, temp2_converted, connect) _check_error() return result if result != _ffi.NULL else None -def tbool_at_value(temp: "const Temporal *", b: bool) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_at_value(temp: 'const Temporal *', b: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_at_value(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def tbool_minus_value(temp: "const Temporal *", b: bool) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_minus_value(temp: 'const Temporal *', b: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_minus_value(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def tbool_value_at_timestamptz( - temp: "const Temporal *", t: int, strict: bool -) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("bool *") - result = _lib.tbool_value_at_timestamptz( - temp_converted, t_converted, strict, out_result - ) +def tbool_value_at_timestamptz(temp: 'const Temporal *', t: int, strict: bool) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + t_converted = _ffi.cast('TimestampTz', t) + out_result = _ffi.new('bool *') + result = _lib.tbool_value_at_timestamptz(temp_converted, t_converted, strict, out_result) _check_error() if result: return out_result[0] if out_result[0] != _ffi.NULL else None return None -def temporal_at_max(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_at_max(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_at_max(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_at_min(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_at_min(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_at_min(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_at_tstzspan(temp: "const Temporal *", s: "const Span *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def temporal_at_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.temporal_at_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_at_tstzspanset( - temp: "const Temporal *", ss: "const SpanSet *" -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def temporal_at_tstzspanset(temp: 'const Temporal *', ss: 'const SpanSet *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.temporal_at_tstzspanset(temp_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_at_timestamptz(temp: "const Temporal *", t: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) +def temporal_at_timestamptz(temp: 'const Temporal *', t: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.temporal_at_timestamptz(temp_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_at_tstzset(temp: "const Temporal *", s: "const Set *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Set *", s) +def temporal_at_tstzset(temp: 'const Temporal *', s: 'const Set *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Set *', s) result = _lib.temporal_at_tstzset(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_at_values(temp: "const Temporal *", set: "const Set *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - set_converted = _ffi.cast("const Set *", set) +def temporal_at_values(temp: 'const Temporal *', set: 'const Set *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + set_converted = _ffi.cast('const Set *', set) result = _lib.temporal_at_values(temp_converted, set_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_max(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_minus_max(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_minus_max(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_min(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_minus_min(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_minus_min(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_tstzspan( - temp: "const Temporal *", s: "const Span *" -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def temporal_minus_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.temporal_minus_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_tstzspanset( - temp: "const Temporal *", ss: "const SpanSet *" -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def temporal_minus_tstzspanset(temp: 'const Temporal *', ss: 'const SpanSet *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.temporal_minus_tstzspanset(temp_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_timestamptz(temp: "const Temporal *", t: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) +def temporal_minus_timestamptz(temp: 'const Temporal *', t: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.temporal_minus_timestamptz(temp_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_tstzset(temp: "const Temporal *", s: "const Set *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Set *", s) +def temporal_minus_tstzset(temp: 'const Temporal *', s: 'const Set *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Set *', s) result = _lib.temporal_minus_tstzset(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_values(temp: "const Temporal *", set: "const Set *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - set_converted = _ffi.cast("const Set *", set) +def temporal_minus_values(temp: 'const Temporal *', set: 'const Set *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + set_converted = _ffi.cast('const Set *', set) result = _lib.temporal_minus_values(temp_converted, set_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_at_value(temp: "const Temporal *", d: float) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_at_value(temp: 'const Temporal *', d: float) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_at_value(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tfloat_minus_value(temp: "const Temporal *", d: float) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_minus_value(temp: 'const Temporal *', d: float) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_minus_value(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tfloat_value_at_timestamptz( - temp: "const Temporal *", t: int, strict: bool -) -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("double *") - result = _lib.tfloat_value_at_timestamptz( - temp_converted, t_converted, strict, out_result - ) +def tfloat_value_at_timestamptz(temp: 'const Temporal *', t: int, strict: bool) -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) + t_converted = _ffi.cast('TimestampTz', t) + out_result = _ffi.new('double *') + result = _lib.tfloat_value_at_timestamptz(temp_converted, t_converted, strict, out_result) _check_error() if result: return out_result[0] if out_result[0] != _ffi.NULL else None return None -def tint_at_value(temp: "const Temporal *", i: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_at_value(temp: 'const Temporal *', i: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_at_value(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tint_minus_value(temp: "const Temporal *", i: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_minus_value(temp: 'const Temporal *', i: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_minus_value(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tint_value_at_timestamptz(temp: "const Temporal *", t: int, strict: bool) -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("int *") - result = _lib.tint_value_at_timestamptz( - temp_converted, t_converted, strict, out_result - ) +def tint_value_at_timestamptz(temp: 'const Temporal *', t: int, strict: bool) -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) + t_converted = _ffi.cast('TimestampTz', t) + out_result = _ffi.new('int *') + result = _lib.tint_value_at_timestamptz(temp_converted, t_converted, strict, out_result) _check_error() if result: return out_result[0] if out_result[0] != _ffi.NULL else None return None -def tnumber_at_span(temp: "const Temporal *", span: "const Span *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - span_converted = _ffi.cast("const Span *", span) +def tnumber_at_span(temp: 'const Temporal *', span: 'const Span *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + span_converted = _ffi.cast('const Span *', span) result = _lib.tnumber_at_span(temp_converted, span_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_at_spanset(temp: "const Temporal *", ss: "const SpanSet *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tnumber_at_spanset(temp: 'const Temporal *', ss: 'const SpanSet *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tnumber_at_spanset(temp_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_at_tbox(temp: "const Temporal *", box: "const TBox *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def tnumber_at_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.tnumber_at_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_minus_span(temp: "const Temporal *", span: "const Span *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - span_converted = _ffi.cast("const Span *", span) +def tnumber_minus_span(temp: 'const Temporal *', span: 'const Span *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + span_converted = _ffi.cast('const Span *', span) result = _lib.tnumber_minus_span(temp_converted, span_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_minus_spanset( - temp: "const Temporal *", ss: "const SpanSet *" -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tnumber_minus_spanset(temp: 'const Temporal *', ss: 'const SpanSet *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tnumber_minus_spanset(temp_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_minus_tbox(temp: "const Temporal *", box: "const TBox *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def tnumber_minus_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.tnumber_minus_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_at_geom_time( - temp: "const Temporal *", - gs: "const GSERIALIZED *", - zspan: "Optional['const Span *']", - period: "const Span *", -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - zspan_converted = ( - _ffi.cast("const Span *", zspan) if zspan is not None else _ffi.NULL - ) - period_converted = _ffi.cast("const Span *", period) - result = _lib.tpoint_at_geom_time( - temp_converted, gs_converted, zspan_converted, period_converted - ) +def tpoint_at_geom_time(temp: 'const Temporal *', gs: 'const GSERIALIZED *', zspan: "Optional['const Span *']", period: 'const Span *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + zspan_converted = _ffi.cast('const Span *', zspan) if zspan is not None else _ffi.NULL + period_converted = _ffi.cast('const Span *', period) + result = _lib.tpoint_at_geom_time(temp_converted, gs_converted, zspan_converted, period_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_at_stbox( - temp: "const Temporal *", box: "const STBox *", border_inc: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def tpoint_at_stbox(temp: 'const Temporal *', box: 'const STBox *', border_inc: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.tpoint_at_stbox(temp_converted, box_converted, border_inc) _check_error() return result if result != _ffi.NULL else None -def tpoint_at_value(temp: "const Temporal *", gs: "GSERIALIZED *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("GSERIALIZED *", gs) +def tpoint_at_value(temp: 'const Temporal *', gs: 'GSERIALIZED *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('GSERIALIZED *', gs) result = _lib.tpoint_at_value(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_minus_geom_time( - temp: "const Temporal *", - gs: "const GSERIALIZED *", - zspan: "Optional['const Span *']", - period: "const Span *", -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - zspan_converted = ( - _ffi.cast("const Span *", zspan) if zspan is not None else _ffi.NULL - ) - period_converted = _ffi.cast("const Span *", period) - result = _lib.tpoint_minus_geom_time( - temp_converted, gs_converted, zspan_converted, period_converted - ) +def tpoint_minus_geom_time(temp: 'const Temporal *', gs: 'const GSERIALIZED *', zspan: "Optional['const Span *']", period: 'const Span *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + zspan_converted = _ffi.cast('const Span *', zspan) if zspan is not None else _ffi.NULL + period_converted = _ffi.cast('const Span *', period) + result = _lib.tpoint_minus_geom_time(temp_converted, gs_converted, zspan_converted, period_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_minus_stbox( - temp: "const Temporal *", box: "const STBox *", border_inc: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def tpoint_minus_stbox(temp: 'const Temporal *', box: 'const STBox *', border_inc: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.tpoint_minus_stbox(temp_converted, box_converted, border_inc) _check_error() return result if result != _ffi.NULL else None -def tpoint_minus_value(temp: "const Temporal *", gs: "GSERIALIZED *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("GSERIALIZED *", gs) +def tpoint_minus_value(temp: 'const Temporal *', gs: 'GSERIALIZED *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('GSERIALIZED *', gs) result = _lib.tpoint_minus_value(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_value_at_timestamptz( - temp: "const Temporal *", t: int, strict: bool -) -> "GSERIALIZED **": - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("GSERIALIZED **") - result = _lib.tpoint_value_at_timestamptz( - temp_converted, t_converted, strict, out_result - ) +def tpoint_value_at_timestamptz(temp: 'const Temporal *', t: int, strict: bool) -> 'GSERIALIZED **': + temp_converted = _ffi.cast('const Temporal *', temp) + t_converted = _ffi.cast('TimestampTz', t) + out_result = _ffi.new('GSERIALIZED **') + result = _lib.tpoint_value_at_timestamptz(temp_converted, t_converted, strict, out_result) _check_error() if result: return out_result if out_result != _ffi.NULL else None return None -def ttext_at_value(temp: "const Temporal *", txt: str) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_at_value(temp: 'const Temporal *', txt: str) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.ttext_at_value(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_minus_value(temp: "const Temporal *", txt: str) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_minus_value(temp: 'const Temporal *', txt: str) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.ttext_minus_value(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_value_at_timestamptz( - temp: "const Temporal *", t: int, strict: bool -) -> "text **": - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("text **") - result = _lib.ttext_value_at_timestamptz( - temp_converted, t_converted, strict, out_result - ) +def ttext_value_at_timestamptz(temp: 'const Temporal *', t: int, strict: bool) -> 'text **': + temp_converted = _ffi.cast('const Temporal *', temp) + t_converted = _ffi.cast('TimestampTz', t) + out_result = _ffi.new('text **') + result = _lib.ttext_value_at_timestamptz(temp_converted, t_converted, strict, out_result) _check_error() if result: return out_result if out_result != _ffi.NULL else None return None -def temporal_cmp(temp1: "const Temporal *", temp2: "const Temporal *") -> "int": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_cmp(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'int': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.temporal_cmp(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_eq(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_eq(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.temporal_eq(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_ge(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_ge(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.temporal_ge(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_gt(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_gt(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.temporal_gt(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_le(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_le(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.temporal_le(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_lt(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_lt(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.temporal_lt(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_ne(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_ne(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.temporal_ne(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_always_eq(temp: "const Temporal *", b: bool) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_always_eq(temp: 'const Temporal *', b: bool) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_always_eq(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def tbool_ever_eq(temp: "const Temporal *", b: bool) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_ever_eq(temp: 'const Temporal *', b: bool) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_ever_eq(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def tfloat_always_eq(temp: "const Temporal *", d: float) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_always_eq(temp: 'const Temporal *', d: float) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_always_eq(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tfloat_always_le(temp: "const Temporal *", d: float) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_always_le(temp: 'const Temporal *', d: float) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_always_le(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tfloat_always_lt(temp: "const Temporal *", d: float) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_always_lt(temp: 'const Temporal *', d: float) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_always_lt(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tfloat_ever_eq(temp: "const Temporal *", d: float) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_ever_eq(temp: 'const Temporal *', d: float) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_ever_eq(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tfloat_ever_le(temp: "const Temporal *", d: float) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_ever_le(temp: 'const Temporal *', d: float) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_ever_le(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tfloat_ever_lt(temp: "const Temporal *", d: float) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_ever_lt(temp: 'const Temporal *', d: float) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_ever_lt(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tint_always_eq(temp: "const Temporal *", i: int) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_always_eq(temp: 'const Temporal *', i: int) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_always_eq(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tint_always_le(temp: "const Temporal *", i: int) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_always_le(temp: 'const Temporal *', i: int) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_always_le(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tint_always_lt(temp: "const Temporal *", i: int) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_always_lt(temp: 'const Temporal *', i: int) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_always_lt(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tint_ever_eq(temp: "const Temporal *", i: int) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_ever_eq(temp: 'const Temporal *', i: int) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_ever_eq(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tint_ever_le(temp: "const Temporal *", i: int) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_ever_le(temp: 'const Temporal *', i: int) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_ever_le(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tint_ever_lt(temp: "const Temporal *", i: int) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_ever_lt(temp: 'const Temporal *', i: int) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_ever_lt(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tpoint_always_eq(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tpoint_always_eq(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tpoint_always_eq(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_ever_eq(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tpoint_ever_eq(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tpoint_ever_eq(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_always_eq(temp: "const Temporal *", txt: str) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_always_eq(temp: 'const Temporal *', txt: str) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.ttext_always_eq(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_always_le(temp: "const Temporal *", txt: str) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_always_le(temp: 'const Temporal *', txt: str) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.ttext_always_le(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_always_lt(temp: "const Temporal *", txt: str) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_always_lt(temp: 'const Temporal *', txt: str) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.ttext_always_lt(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_ever_eq(temp: "const Temporal *", txt: str) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_ever_eq(temp: 'const Temporal *', txt: str) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.ttext_ever_eq(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_ever_le(temp: "const Temporal *", txt: str) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_ever_le(temp: 'const Temporal *', txt: str) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.ttext_ever_le(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_ever_lt(temp: "const Temporal *", txt: str) -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_ever_lt(temp: 'const Temporal *', txt: str) -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.ttext_ever_lt(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def teq_bool_tbool(b: bool, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_bool_tbool(b: bool, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.teq_bool_tbool(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def teq_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_float_tfloat(d: float, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.teq_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def teq_int_tint(i: int, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_int_tint(i: int, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.teq_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def teq_point_tpoint( - gs: "const GSERIALIZED *", temp: "const Temporal *" -) -> "Temporal *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_point_tpoint(gs: 'const GSERIALIZED *', temp: 'const Temporal *') -> 'Temporal *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.teq_point_tpoint(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def teq_tbool_bool(temp: "const Temporal *", b: bool) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_tbool_bool(temp: 'const Temporal *', b: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.teq_tbool_bool(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def teq_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def teq_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.teq_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def teq_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": +def teq_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.teq_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def teq_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.teq_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def teq_tpoint_point( - temp: "const Temporal *", gs: "const GSERIALIZED *" -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def teq_tpoint_point(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.teq_tpoint_point(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def teq_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.teq_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def teq_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def teq_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.teq_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def tge_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tge_float_tfloat(d: float, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tge_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tge_int_tint(i: int, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tge_int_tint(i: int, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tge_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tge_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tge_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tge_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tge_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": +def tge_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tge_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tge_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tge_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tge_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tge_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tge_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tge_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tge_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tge_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.tge_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def tgt_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tgt_float_tfloat(d: float, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgt_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgt_int_tint(i: int, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tgt_int_tint(i: int, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgt_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgt_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tgt_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tgt_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tgt_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": +def tgt_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgt_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgt_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tgt_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgt_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tgt_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tgt_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgt_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tgt_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tgt_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.tgt_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def tle_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tle_float_tfloat(d: float, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tle_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tle_int_tint(i: int, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tle_int_tint(i: int, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tle_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tle_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tle_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tle_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tle_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": +def tle_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tle_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tle_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tle_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tle_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tle_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tle_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tle_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tle_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tle_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.tle_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def tlt_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tlt_float_tfloat(d: float, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tlt_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tlt_int_tint(i: int, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tlt_int_tint(i: int, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tlt_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tlt_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tlt_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tlt_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tlt_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": +def tlt_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tlt_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tlt_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tlt_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tlt_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tlt_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tlt_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tlt_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tlt_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tlt_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.tlt_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def tne_bool_tbool(b: bool, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_bool_tbool(b: bool, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tne_bool_tbool(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tne_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_float_tfloat(d: float, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tne_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tne_int_tint(i: int, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_int_tint(i: int, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tne_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tne_point_tpoint( - gs: "const GSERIALIZED *", temp: "const Temporal *" -) -> "Temporal *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_point_tpoint(gs: 'const GSERIALIZED *', temp: 'const Temporal *') -> 'Temporal *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tne_point_tpoint(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tne_tbool_bool(temp: "const Temporal *", b: bool) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_tbool_bool(temp: 'const Temporal *', b: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tne_tbool_bool(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def tne_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tne_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tne_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tne_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": +def tne_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tne_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tne_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tne_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tne_tpoint_point( - temp: "const Temporal *", gs: "const GSERIALIZED *" -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tne_tpoint_point(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tne_tpoint_point(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tne_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tne_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tne_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tne_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.tne_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def adjacent_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.adjacent_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def adjacent_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.adjacent_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def adjacent_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.adjacent_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def adjacent_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.adjacent_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def adjacent_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.adjacent_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def adjacent_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.adjacent_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def adjacent_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.adjacent_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def adjacent_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.adjacent_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def adjacent_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.adjacent_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def adjacent_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.adjacent_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def adjacent_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.adjacent_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contained_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def contained_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.contained_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contained_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def contained_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.contained_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def contained_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.contained_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contained_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def contained_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.contained_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def contained_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.contained_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def contained_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.contained_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def contained_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.contained_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def contained_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.contained_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def contained_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.contained_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def contained_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.contained_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def contained_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.contained_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contains_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def contains_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.contains_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contains_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def contains_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.contains_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def contains_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.contains_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contains_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def contains_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.contains_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contains_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def contains_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.contains_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def contains_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.contains_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def contains_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.contains_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def contains_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.contains_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def contains_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.contains_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def contains_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.contains_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def contains_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.contains_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def overlaps_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overlaps_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overlaps_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overlaps_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overlaps_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overlaps_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overlaps_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overlaps_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def overlaps_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.overlaps_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def overlaps_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.overlaps_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def overlaps_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.overlaps_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overlaps_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overlaps_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overlaps_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overlaps_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overlaps_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overlaps_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def overlaps_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overlaps_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def same_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def same_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.same_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def same_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def same_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.same_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def same_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def same_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.same_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def same_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def same_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.same_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def same_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def same_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.same_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def same_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def same_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.same_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def same_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def same_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.same_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def same_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def same_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.same_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def same_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def same_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.same_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def same_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def same_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.same_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def same_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def same_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.same_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def above_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def above_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.above_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def above_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def above_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.above_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def above_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def above_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.above_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def after_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def after_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.after_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def after_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def after_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.after_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def after_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def after_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.after_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def after_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def after_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.after_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def after_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def after_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.after_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def after_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def after_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.after_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def after_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def after_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.after_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def after_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def after_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.after_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def after_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def after_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.after_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def back_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def back_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.back_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def back_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def back_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.back_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def back_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def back_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.back_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def before_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def before_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.before_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def before_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def before_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.before_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def before_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def before_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.before_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def before_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def before_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.before_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def before_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def before_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.before_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def before_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def before_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.before_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def before_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def before_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.before_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def before_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def before_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.before_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def before_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def before_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.before_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def below_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def below_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.below_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def below_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def below_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.below_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def below_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def below_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.below_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def front_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def front_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.front_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def front_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def front_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.front_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def front_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def front_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.front_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def left_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def left_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.left_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def left_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def left_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.left_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def left_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def left_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.left_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def left_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def left_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.left_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def left_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.left_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def left_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def left_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.left_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def left_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def left_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.left_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def left_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def left_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.left_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overabove_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overabove_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overabove_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overabove_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overabove_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overabove_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overafter_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overafter_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overafter_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overafter_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def overafter_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.overafter_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overafter_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overafter_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def overafter_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.overafter_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overafter_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overafter_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overafter_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overafter_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overafter_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overafter_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def overafter_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overafter_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overback_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overback_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overback_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overback_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overback_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overback_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overback_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overback_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overback_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overbefore_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overbefore_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overbefore_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overbefore_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def overbefore_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.overbefore_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_temporal_temporal( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overbefore_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overbefore_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def overbefore_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.overbefore_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overbefore_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overbefore_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overbefore_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overbefore_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overbefore_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overbefore_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def overbefore_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overbefore_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overbelow_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overbelow_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overbelow_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overbelow_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overbelow_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overbelow_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overfront_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overfront_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overfront_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overfront_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overfront_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overfront_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def overleft_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overleft_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overleft_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overleft_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overleft_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overleft_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def overleft_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.overleft_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def overleft_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.overleft_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overleft_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overleft_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overleft_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overleft_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overleft_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overleft_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def overright_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overright_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overright_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overright_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overright_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def overright_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.overright_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def overright_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.overright_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def overright_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.overright_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overright_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overright_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def overright_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.overright_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def overright_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.overright_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def right_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": - s_converted = _ffi.cast("const Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def right_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.right_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def right_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const STBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def right_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const STBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.right_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def right_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": - box_converted = _ffi.cast("const TBox *", box) - temp_converted = _ffi.cast("const Temporal *", temp) +def right_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': + box_converted = _ffi.cast('const TBox *', box) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.right_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def right_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def right_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.right_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def right_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.right_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def right_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def right_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.right_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def right_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def right_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.right_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def right_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def right_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.right_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tand_bool_tbool(b: bool, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tand_bool_tbool(b: bool, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tand_bool_tbool(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tand_tbool_bool(temp: "const Temporal *", b: bool) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tand_tbool_bool(temp: 'const Temporal *', b: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tand_tbool_bool(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def tand_tbool_tbool( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tand_tbool_tbool(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tand_tbool_tbool(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_when_true(temp: "const Temporal *") -> "SpanSet *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_when_true(temp: 'const Temporal *') -> 'SpanSet *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_when_true(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnot_tbool(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tnot_tbool(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnot_tbool(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tor_bool_tbool(b: bool, temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tor_bool_tbool(b: bool, temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tor_bool_tbool(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tor_tbool_bool(temp: "const Temporal *", b: bool) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tor_tbool_bool(temp: 'const Temporal *', b: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tor_tbool_bool(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def tor_tbool_tbool( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def tor_tbool_tbool(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.tor_tbool_tbool(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def add_float_tfloat(d: float, tnumber: "const Temporal *") -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def add_float_tfloat(d: float, tnumber: 'const Temporal *') -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.add_float_tfloat(d, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def add_int_tint(i: int, tnumber: "const Temporal *") -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def add_int_tint(i: int, tnumber: 'const Temporal *') -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.add_int_tint(i, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def add_tfloat_float(tnumber: "const Temporal *", d: float) -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def add_tfloat_float(tnumber: 'const Temporal *', d: float) -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.add_tfloat_float(tnumber_converted, d) _check_error() return result if result != _ffi.NULL else None -def add_tint_int(tnumber: "const Temporal *", i: int) -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def add_tint_int(tnumber: 'const Temporal *', i: int) -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.add_tint_int(tnumber_converted, i) _check_error() return result if result != _ffi.NULL else None -def add_tnumber_tnumber( - tnumber1: "const Temporal *", tnumber2: "const Temporal *" -) -> "Temporal *": - tnumber1_converted = _ffi.cast("const Temporal *", tnumber1) - tnumber2_converted = _ffi.cast("const Temporal *", tnumber2) +def add_tnumber_tnumber(tnumber1: 'const Temporal *', tnumber2: 'const Temporal *') -> 'Temporal *': + tnumber1_converted = _ffi.cast('const Temporal *', tnumber1) + tnumber2_converted = _ffi.cast('const Temporal *', tnumber2) result = _lib.add_tnumber_tnumber(tnumber1_converted, tnumber2_converted) _check_error() return result if result != _ffi.NULL else None -def div_float_tfloat(d: float, tnumber: "const Temporal *") -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def div_float_tfloat(d: float, tnumber: 'const Temporal *') -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.div_float_tfloat(d, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def div_int_tint(i: int, tnumber: "const Temporal *") -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def div_int_tint(i: int, tnumber: 'const Temporal *') -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.div_int_tint(i, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def div_tfloat_float(tnumber: "const Temporal *", d: float) -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def div_tfloat_float(tnumber: 'const Temporal *', d: float) -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.div_tfloat_float(tnumber_converted, d) _check_error() return result if result != _ffi.NULL else None -def div_tint_int(tnumber: "const Temporal *", i: int) -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def div_tint_int(tnumber: 'const Temporal *', i: int) -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.div_tint_int(tnumber_converted, i) _check_error() return result if result != _ffi.NULL else None -def div_tnumber_tnumber( - tnumber1: "const Temporal *", tnumber2: "const Temporal *" -) -> "Temporal *": - tnumber1_converted = _ffi.cast("const Temporal *", tnumber1) - tnumber2_converted = _ffi.cast("const Temporal *", tnumber2) +def div_tnumber_tnumber(tnumber1: 'const Temporal *', tnumber2: 'const Temporal *') -> 'Temporal *': + tnumber1_converted = _ffi.cast('const Temporal *', tnumber1) + tnumber2_converted = _ffi.cast('const Temporal *', tnumber2) result = _lib.div_tnumber_tnumber(tnumber1_converted, tnumber2_converted) _check_error() return result if result != _ffi.NULL else None -def float_degrees(value: float, normalize: bool) -> "double": +def float_degrees(value: float, normalize: bool) -> 'double': result = _lib.float_degrees(value, normalize) _check_error() return result if result != _ffi.NULL else None -def mult_float_tfloat(d: float, tnumber: "const Temporal *") -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def mult_float_tfloat(d: float, tnumber: 'const Temporal *') -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.mult_float_tfloat(d, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def mult_int_tint(i: int, tnumber: "const Temporal *") -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def mult_int_tint(i: int, tnumber: 'const Temporal *') -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.mult_int_tint(i, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def mult_tfloat_float(tnumber: "const Temporal *", d: float) -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def mult_tfloat_float(tnumber: 'const Temporal *', d: float) -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.mult_tfloat_float(tnumber_converted, d) _check_error() return result if result != _ffi.NULL else None -def mult_tint_int(tnumber: "const Temporal *", i: int) -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def mult_tint_int(tnumber: 'const Temporal *', i: int) -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.mult_tint_int(tnumber_converted, i) _check_error() return result if result != _ffi.NULL else None -def mult_tnumber_tnumber( - tnumber1: "const Temporal *", tnumber2: "const Temporal *" -) -> "Temporal *": - tnumber1_converted = _ffi.cast("const Temporal *", tnumber1) - tnumber2_converted = _ffi.cast("const Temporal *", tnumber2) +def mult_tnumber_tnumber(tnumber1: 'const Temporal *', tnumber2: 'const Temporal *') -> 'Temporal *': + tnumber1_converted = _ffi.cast('const Temporal *', tnumber1) + tnumber2_converted = _ffi.cast('const Temporal *', tnumber2) result = _lib.mult_tnumber_tnumber(tnumber1_converted, tnumber2_converted) _check_error() return result if result != _ffi.NULL else None -def sub_float_tfloat(d: float, tnumber: "const Temporal *") -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def sub_float_tfloat(d: float, tnumber: 'const Temporal *') -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.sub_float_tfloat(d, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def sub_int_tint(i: int, tnumber: "const Temporal *") -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def sub_int_tint(i: int, tnumber: 'const Temporal *') -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.sub_int_tint(i, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def sub_tfloat_float(tnumber: "const Temporal *", d: float) -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def sub_tfloat_float(tnumber: 'const Temporal *', d: float) -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.sub_tfloat_float(tnumber_converted, d) _check_error() return result if result != _ffi.NULL else None -def sub_tint_int(tnumber: "const Temporal *", i: int) -> "Temporal *": - tnumber_converted = _ffi.cast("const Temporal *", tnumber) +def sub_tint_int(tnumber: 'const Temporal *', i: int) -> 'Temporal *': + tnumber_converted = _ffi.cast('const Temporal *', tnumber) result = _lib.sub_tint_int(tnumber_converted, i) _check_error() return result if result != _ffi.NULL else None -def sub_tnumber_tnumber( - tnumber1: "const Temporal *", tnumber2: "const Temporal *" -) -> "Temporal *": - tnumber1_converted = _ffi.cast("const Temporal *", tnumber1) - tnumber2_converted = _ffi.cast("const Temporal *", tnumber2) +def sub_tnumber_tnumber(tnumber1: 'const Temporal *', tnumber2: 'const Temporal *') -> 'Temporal *': + tnumber1_converted = _ffi.cast('const Temporal *', tnumber1) + tnumber2_converted = _ffi.cast('const Temporal *', tnumber2) result = _lib.sub_tnumber_tnumber(tnumber1_converted, tnumber2_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_round(temp: "const Temporal *", maxdd: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_round(temp: 'const Temporal *', maxdd: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_round(temp_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def tfloatarr_round(temp: "const Temporal **", count: int, maxdd: int) -> "Temporal **": - temp_converted = [_ffi.cast("const Temporal *", x) for x in temp] +def tfloatarr_round(temp: 'const Temporal **', count: int, maxdd: int) -> 'Temporal **': + temp_converted = [_ffi.cast('const Temporal *', x) for x in temp] result = _lib.tfloatarr_round(temp_converted, count, maxdd) _check_error() return result if result != _ffi.NULL else None -def tfloat_degrees(temp: "const Temporal *", normalize: bool) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_degrees(temp: 'const Temporal *', normalize: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_degrees(temp_converted, normalize) _check_error() return result if result != _ffi.NULL else None -def tfloat_derivative(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_derivative(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_derivative(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_radians(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_radians(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_radians(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_abs(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_abs(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_abs(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_angular_difference(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_angular_difference(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_angular_difference(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_delta_value(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_delta_value(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_delta_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def textcat_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": +def textcat_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': txt_converted = cstring2text(txt) - temp_converted = _ffi.cast("const Temporal *", temp) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.textcat_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def textcat_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def textcat_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) txt_converted = cstring2text(txt) result = _lib.textcat_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def textcat_ttext_ttext( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def textcat_ttext_ttext(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.textcat_ttext_ttext(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_upper(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_upper(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ttext_upper(temp_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_lower(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_lower(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ttext_lower(temp_converted) _check_error() return result if result != _ffi.NULL else None -def distance_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def distance_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.distance_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def distance_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def distance_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.distance_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def distance_tnumber_tnumber( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def distance_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.distance_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def distance_tpoint_point( - temp: "const Temporal *", gs: "const GSERIALIZED *" -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def distance_tpoint_point(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.distance_tpoint_point(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def distance_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def distance_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.distance_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_stbox_geo(box: "const STBox *", gs: "const GSERIALIZED *") -> "double": - box_converted = _ffi.cast("const STBox *", box) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def nad_stbox_geo(box: 'const STBox *', gs: 'const GSERIALIZED *') -> 'double': + box_converted = _ffi.cast('const STBox *', box) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.nad_stbox_geo(box_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def nad_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "double": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) +def nad_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'double': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) result = _lib.nad_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "double": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) +def nad_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'double': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) result = _lib.nad_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tfloat_float(temp: "const Temporal *", d: float) -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) +def nad_tfloat_float(temp: 'const Temporal *', d: float) -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.nad_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def nad_tfloat_tfloat(temp1: "const Temporal *", temp2: "const Temporal *") -> "double": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def nad_tfloat_tfloat(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'double': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.nad_tfloat_tfloat(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tint_int(temp: "const Temporal *", i: int) -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) +def nad_tint_int(temp: 'const Temporal *', i: int) -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.nad_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def nad_tint_tint(temp1: "const Temporal *", temp2: "const Temporal *") -> "int": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def nad_tint_tint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'int': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.nad_tint_tint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const TBox *", box) +def nad_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const TBox *', box) result = _lib.nad_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tpoint_geo(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def nad_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.nad_tpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) +def nad_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) result = _lib.nad_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "double": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def nad_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'double': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.nad_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tpoint_geo(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "TInstant *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def nai_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'TInstant *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.nai_tpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "TInstant *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def nai_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'TInstant *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.nai_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def shortestline_tpoint_geo( - temp: "const Temporal *", gs: "const GSERIALIZED *" -) -> "GSERIALIZED **": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - out_result = _ffi.new("GSERIALIZED **") +def shortestline_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'GSERIALIZED **': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + out_result = _ffi.new('GSERIALIZED **') result = _lib.shortestline_tpoint_geo(temp_converted, gs_converted, out_result) _check_error() if result: @@ -9907,27 +9466,21 @@ def shortestline_tpoint_geo( return None -def shortestline_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "GSERIALIZED **": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - out_result = _ffi.new("GSERIALIZED **") - result = _lib.shortestline_tpoint_tpoint( - temp1_converted, temp2_converted, out_result - ) +def shortestline_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'GSERIALIZED **': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) + out_result = _ffi.new('GSERIALIZED **') + result = _lib.shortestline_tpoint_tpoint(temp1_converted, temp2_converted, out_result) _check_error() if result: return out_result if out_result != _ffi.NULL else None return None -def bearing_point_point( - gs1: "const GSERIALIZED *", gs2: "const GSERIALIZED *" -) -> "double": - gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) - gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) - out_result = _ffi.new("double *") +def bearing_point_point(gs1: 'const GSERIALIZED *', gs2: 'const GSERIALIZED *') -> 'double': + gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) + gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) + out_result = _ffi.new('double *') result = _lib.bearing_point_point(gs1_converted, gs2_converted, out_result) _check_error() if result: @@ -9935,57 +9488,53 @@ def bearing_point_point( return None -def bearing_tpoint_point( - temp: "const Temporal *", gs: "const GSERIALIZED *", invert: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def bearing_tpoint_point(temp: 'const Temporal *', gs: 'const GSERIALIZED *', invert: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.bearing_tpoint_point(temp_converted, gs_converted, invert) _check_error() return result if result != _ffi.NULL else None -def bearing_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def bearing_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.bearing_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_angular_difference(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_angular_difference(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_angular_difference(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_azimuth(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_azimuth(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_azimuth(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_convex_hull(temp: "const Temporal *") -> "GSERIALIZED *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_convex_hull(temp: 'const Temporal *') -> 'GSERIALIZED *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_convex_hull(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_cumulative_length(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_cumulative_length(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_cumulative_length(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_direction(temp: "const Temporal *") -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) - out_result = _ffi.new("double *") +def tpoint_direction(temp: 'const Temporal *') -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) + out_result = _ffi.new('double *') result = _lib.tpoint_direction(temp_converted, out_result) _check_error() if result: @@ -9993,1772 +9542,1462 @@ def tpoint_direction(temp: "const Temporal *") -> "double": return None -def tpoint_get_x(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_get_x(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_get_x(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_get_y(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_get_y(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_get_y(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_get_z(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_get_z(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_get_z(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_is_simple(temp: "const Temporal *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_is_simple(temp: 'const Temporal *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_is_simple(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_length(temp: "const Temporal *") -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_length(temp: 'const Temporal *') -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_length(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_speed(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_speed(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_speed(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_srid(temp: "const Temporal *") -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_srid(temp: 'const Temporal *') -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_srid(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_stboxes(temp: "const Temporal *") -> "Tuple['STBox *', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - count = _ffi.new("int *") +def tpoint_stboxes(temp: 'const Temporal *') -> "Tuple['STBox *', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') result = _lib.tpoint_stboxes(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tpoint_trajectory(temp: "const Temporal *") -> "GSERIALIZED *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_trajectory(temp: 'const Temporal *') -> 'GSERIALIZED *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_trajectory(temp_converted) _check_error() return result if result != _ffi.NULL else None -def geo_expand_space(gs: "const GSERIALIZED *", d: float) -> "STBox *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geo_expand_space(gs: 'const GSERIALIZED *', d: float) -> 'STBox *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geo_expand_space(gs_converted, d) _check_error() return result if result != _ffi.NULL else None -def geomeas_to_tpoint(gs: "const GSERIALIZED *") -> "Temporal *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def geomeas_to_tpoint(gs: 'const GSERIALIZED *') -> 'Temporal *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.geomeas_to_tpoint(gs_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpoint_to_tgeompoint(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeogpoint_to_tgeompoint(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeogpoint_to_tgeompoint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_to_tgeogpoint(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeompoint_to_tgeogpoint(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeompoint_to_tgeogpoint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_AsMVTGeom( - temp: "const Temporal *", - bounds: "const STBox *", - extent: "int32_t", - buffer: "int32_t", - clip_geom: bool, - gsarr: "GSERIALIZED **", - timesarr: "int64 **", -) -> "Tuple['bool', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - bounds_converted = _ffi.cast("const STBox *", bounds) - extent_converted = _ffi.cast("int32_t", extent) - buffer_converted = _ffi.cast("int32_t", buffer) - gsarr_converted = [_ffi.cast("GSERIALIZED *", x) for x in gsarr] - timesarr_converted = [_ffi.cast("int64 *", x) for x in timesarr] - count = _ffi.new("int *") - result = _lib.tpoint_AsMVTGeom( - temp_converted, - bounds_converted, - extent_converted, - buffer_converted, - clip_geom, - gsarr_converted, - timesarr_converted, - count, - ) +def tpoint_AsMVTGeom(temp: 'const Temporal *', bounds: 'const STBox *', extent: 'int32_t', buffer: 'int32_t', clip_geom: bool, gsarr: 'GSERIALIZED **', timesarr: 'int64 **') -> "Tuple['bool', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + bounds_converted = _ffi.cast('const STBox *', bounds) + extent_converted = _ffi.cast('int32_t', extent) + buffer_converted = _ffi.cast('int32_t', buffer) + gsarr_converted = [_ffi.cast('GSERIALIZED *', x) for x in gsarr] + timesarr_converted = [_ffi.cast('int64 *', x) for x in timesarr] + count = _ffi.new('int *') + result = _lib.tpoint_AsMVTGeom(temp_converted, bounds_converted, extent_converted, buffer_converted, clip_geom, gsarr_converted, timesarr_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tpoint_expand_space(temp: "const Temporal *", d: float) -> "STBox *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_expand_space(temp: 'const Temporal *', d: float) -> 'STBox *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_expand_space(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tpoint_make_simple(temp: "const Temporal *") -> "Tuple['Temporal **', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - count = _ffi.new("int *") +def tpoint_make_simple(temp: 'const Temporal *') -> "Tuple['Temporal **', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') result = _lib.tpoint_make_simple(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tpoint_round(temp: "const Temporal *", maxdd: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_round(temp: 'const Temporal *', maxdd: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_round(temp_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def tpointarr_round(temp: "const Temporal **", count: int, maxdd: int) -> "Temporal **": - temp_converted = [_ffi.cast("const Temporal *", x) for x in temp] +def tpointarr_round(temp: 'const Temporal **', count: int, maxdd: int) -> 'Temporal **': + temp_converted = [_ffi.cast('const Temporal *', x) for x in temp] result = _lib.tpointarr_round(temp_converted, count, maxdd) _check_error() return result if result != _ffi.NULL else None -def tpoint_set_srid(temp: "const Temporal *", srid: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - srid_converted = _ffi.cast("int32", srid) +def tpoint_set_srid(temp: 'const Temporal *', srid: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + srid_converted = _ffi.cast('int32', srid) result = _lib.tpoint_set_srid(temp_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_tfloat_to_geomeas( - tpoint: "const Temporal *", measure: "const Temporal *", segmentize: bool -) -> "GSERIALIZED **": - tpoint_converted = _ffi.cast("const Temporal *", tpoint) - measure_converted = _ffi.cast("const Temporal *", measure) - out_result = _ffi.new("GSERIALIZED **") - result = _lib.tpoint_tfloat_to_geomeas( - tpoint_converted, measure_converted, segmentize, out_result - ) +def tpoint_tfloat_to_geomeas(tpoint: 'const Temporal *', measure: 'const Temporal *', segmentize: bool) -> 'GSERIALIZED **': + tpoint_converted = _ffi.cast('const Temporal *', tpoint) + measure_converted = _ffi.cast('const Temporal *', measure) + out_result = _ffi.new('GSERIALIZED **') + result = _lib.tpoint_tfloat_to_geomeas(tpoint_converted, measure_converted, segmentize, out_result) _check_error() if result: return out_result if out_result != _ffi.NULL else None return None -def econtains_geo_tpoint(gs: "const GSERIALIZED *", temp: "const Temporal *") -> "int": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def econtains_geo_tpoint(gs: 'const GSERIALIZED *', temp: 'const Temporal *') -> 'int': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.econtains_geo_tpoint(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def edisjoint_tpoint_geo(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def edisjoint_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.edisjoint_tpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def edisjoint_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "int": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def edisjoint_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'int': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.edisjoint_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def edwithin_tpoint_geo( - temp: "const Temporal *", gs: "const GSERIALIZED *", dist: float -) -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def edwithin_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *', dist: float) -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.edwithin_tpoint_geo(temp_converted, gs_converted, dist) _check_error() return result if result != _ffi.NULL else None -def edwithin_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *", dist: float -) -> "int": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def edwithin_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *', dist: float) -> 'int': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.edwithin_tpoint_tpoint(temp1_converted, temp2_converted, dist) _check_error() return result if result != _ffi.NULL else None -def eintersects_tpoint_geo( - temp: "const Temporal *", gs: "const GSERIALIZED *" -) -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def eintersects_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.eintersects_tpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def eintersects_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "int": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def eintersects_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'int': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.eintersects_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def etouches_tpoint_geo(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "int": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def etouches_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'int': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.etouches_tpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tcontains_geo_tpoint( - gs: "const GSERIALIZED *", temp: "const Temporal *", restr: bool, atvalue: bool -) -> "Temporal *": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - temp_converted = _ffi.cast("const Temporal *", temp) +def tcontains_geo_tpoint(gs: 'const GSERIALIZED *', temp: 'const Temporal *', restr: bool, atvalue: bool) -> 'Temporal *': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tcontains_geo_tpoint(gs_converted, temp_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdisjoint_tpoint_geo( - temp: "const Temporal *", gs: "const GSERIALIZED *", restr: bool, atvalue: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tdisjoint_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *', restr: bool, atvalue: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tdisjoint_tpoint_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdwithin_tpoint_geo( - temp: "const Temporal *", - gs: "const GSERIALIZED *", - dist: float, - restr: bool, - atvalue: bool, -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - result = _lib.tdwithin_tpoint_geo( - temp_converted, gs_converted, dist, restr, atvalue - ) +def tdwithin_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *', dist: float, restr: bool, atvalue: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + result = _lib.tdwithin_tpoint_geo(temp_converted, gs_converted, dist, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tdwithin_tpoint_tpoint( - temp1: "const Temporal *", - temp2: "const Temporal *", - dist: float, - restr: bool, - atvalue: bool, -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - result = _lib.tdwithin_tpoint_tpoint( - temp1_converted, temp2_converted, dist, restr, atvalue - ) +def tdwithin_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *', dist: float, restr: bool, atvalue: bool) -> 'Temporal *': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) + result = _lib.tdwithin_tpoint_tpoint(temp1_converted, temp2_converted, dist, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tintersects_tpoint_geo( - temp: "const Temporal *", gs: "const GSERIALIZED *", restr: bool, atvalue: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def tintersects_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *', restr: bool, atvalue: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.tintersects_tpoint_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def ttouches_tpoint_geo( - temp: "const Temporal *", gs: "const GSERIALIZED *", restr: bool, atvalue: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) +def ttouches_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *', restr: bool, atvalue: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) result = _lib.ttouches_tpoint_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def tbool_tand_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_tand_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_tand_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_tor_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_tor_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_tor_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_extent_transfn(s: "Span *", temp: "const Temporal *") -> "Span *": - s_converted = _ffi.cast("Span *", s) - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_extent_transfn(s: 'Span *', temp: 'const Temporal *') -> 'Span *': + s_converted = _ffi.cast('Span *', s) + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_extent_transfn(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_tagg_finalfn(state: "SkipList *") -> "Temporal *": - state_converted = _ffi.cast("SkipList *", state) +def temporal_tagg_finalfn(state: 'SkipList *') -> 'Temporal *': + state_converted = _ffi.cast('SkipList *', state) result = _lib.temporal_tagg_finalfn(state_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_tcount_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_tcount_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_tcount_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_tmax_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_tmax_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_tmax_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_tmin_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_tmin_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_tmin_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_tsum_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_tsum_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_tsum_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_tmax_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_tmax_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_tmax_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_tmin_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_tmin_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_tmin_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_tsum_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_tsum_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_tsum_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_extent_transfn( - box: "Optional['TBox *']", temp: "const Temporal *" -) -> "TBox *": - box_converted = _ffi.cast("TBox *", box) if box is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_extent_transfn(box: "Optional['TBox *']", temp: 'const Temporal *') -> 'TBox *': + box_converted = _ffi.cast('TBox *', box) if box is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_extent_transfn(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_integral(temp: "const Temporal *") -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_integral(temp: 'const Temporal *') -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_integral(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_tavg_finalfn(state: "SkipList *") -> "Temporal *": - state_converted = _ffi.cast("SkipList *", state) +def tnumber_tavg_finalfn(state: 'SkipList *') -> 'Temporal *': + state_converted = _ffi.cast('SkipList *', state) result = _lib.tnumber_tavg_finalfn(state_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_tavg_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_tavg_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_tavg_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_twavg(temp: "const Temporal *") -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_twavg(temp: 'const Temporal *') -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_twavg(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_extent_transfn( - box: "Optional['STBox *']", temp: "const Temporal *" -) -> "STBox *": - box_converted = _ffi.cast("STBox *", box) if box is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_extent_transfn(box: "Optional['STBox *']", temp: 'const Temporal *') -> 'STBox *': + box_converted = _ffi.cast('STBox *', box) if box is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_extent_transfn(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_tcentroid_finalfn(state: "SkipList *") -> "Temporal *": - state_converted = _ffi.cast("SkipList *", state) +def tpoint_tcentroid_finalfn(state: 'SkipList *') -> 'Temporal *': + state_converted = _ffi.cast('SkipList *', state) result = _lib.tpoint_tcentroid_finalfn(state_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_tcentroid_transfn(state: "SkipList *", temp: "Temporal *") -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("Temporal *", temp) +def tpoint_tcentroid_transfn(state: 'SkipList *', temp: 'Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) + temp_converted = _ffi.cast('Temporal *', temp) result = _lib.tpoint_tcentroid_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_twcentroid(temp: "const Temporal *") -> "GSERIALIZED *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_twcentroid(temp: 'const Temporal *') -> 'GSERIALIZED *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_twcentroid(temp_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_tmax_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_tmax_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ttext_tmax_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_tmin_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_tmin_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ttext_tmin_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_simplify_min_dist(temp: "const Temporal *", dist: float) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_simplify_min_dist(temp: 'const Temporal *', dist: float) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_simplify_min_dist(temp_converted, dist) _check_error() return result if result != _ffi.NULL else None -def temporal_simplify_min_tdelta( - temp: "const Temporal *", mint: "const Interval *" -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - mint_converted = _ffi.cast("const Interval *", mint) +def temporal_simplify_min_tdelta(temp: 'const Temporal *', mint: 'const Interval *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + mint_converted = _ffi.cast('const Interval *', mint) result = _lib.temporal_simplify_min_tdelta(temp_converted, mint_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_simplify_dp( - temp: "const Temporal *", eps_dist: float, synchronized: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_simplify_dp(temp: 'const Temporal *', eps_dist: float, synchronized: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_simplify_dp(temp_converted, eps_dist, synchronized) _check_error() return result if result != _ffi.NULL else None -def temporal_simplify_max_dist( - temp: "const Temporal *", eps_dist: float, synchronized: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_simplify_max_dist(temp: 'const Temporal *', eps_dist: float, synchronized: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_simplify_max_dist(temp_converted, eps_dist, synchronized) _check_error() return result if result != _ffi.NULL else None -def temporal_tprecision( - temp: "const Temporal *", duration: "const Interval *", origin: int -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) - origin_converted = _ffi.cast("TimestampTz", origin) - result = _lib.temporal_tprecision( - temp_converted, duration_converted, origin_converted - ) +def temporal_tprecision(temp: 'const Temporal *', duration: 'const Interval *', origin: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) + origin_converted = _ffi.cast('TimestampTz', origin) + result = _lib.temporal_tprecision(temp_converted, duration_converted, origin_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_tsample( - temp: "const Temporal *", duration: "const Interval *", origin: int -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - duration_converted = _ffi.cast("const Interval *", duration) - origin_converted = _ffi.cast("TimestampTz", origin) +def temporal_tsample(temp: 'const Temporal *', duration: 'const Interval *', origin: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + duration_converted = _ffi.cast('const Interval *', duration) + origin_converted = _ffi.cast('TimestampTz', origin) result = _lib.temporal_tsample(temp_converted, duration_converted, origin_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_dyntimewarp_distance( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "double": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_dyntimewarp_distance(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'double': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.temporal_dyntimewarp_distance(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_dyntimewarp_path( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Tuple['Match *', 'int']": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - count = _ffi.new("int *") +def temporal_dyntimewarp_path(temp1: 'const Temporal *', temp2: 'const Temporal *') -> "Tuple['Match *', 'int']": + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) + count = _ffi.new('int *') result = _lib.temporal_dyntimewarp_path(temp1_converted, temp2_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_frechet_distance( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "double": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_frechet_distance(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'double': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.temporal_frechet_distance(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_frechet_path( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Tuple['Match *', 'int']": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - count = _ffi.new("int *") +def temporal_frechet_path(temp1: 'const Temporal *', temp2: 'const Temporal *') -> "Tuple['Match *', 'int']": + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) + count = _ffi.new('int *') result = _lib.temporal_frechet_path(temp1_converted, temp2_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_hausdorff_distance( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "double": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) +def temporal_hausdorff_distance(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'double': + temp1_converted = _ffi.cast('const Temporal *', temp1) + temp2_converted = _ffi.cast('const Temporal *', temp2) result = _lib.temporal_hausdorff_distance(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def float_bucket(value: float, size: float, origin: float) -> "double": +def float_bucket(value: float, size: float, origin: float) -> 'double': result = _lib.float_bucket(value, size, origin) _check_error() return result if result != _ffi.NULL else None -def floatspan_bucket_list( - bounds: "const Span *", size: float, origin: float -) -> "Tuple['Span *', 'int']": - bounds_converted = _ffi.cast("const Span *", bounds) - count = _ffi.new("int *") +def floatspan_bucket_list(bounds: 'const Span *', size: float, origin: float) -> "Tuple['Span *', 'int']": + bounds_converted = _ffi.cast('const Span *', bounds) + count = _ffi.new('int *') result = _lib.floatspan_bucket_list(bounds_converted, size, origin, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def int_bucket(value: int, size: int, origin: int) -> "int": +def int_bucket(value: int, size: int, origin: int) -> 'int': result = _lib.int_bucket(value, size, origin) _check_error() return result if result != _ffi.NULL else None -def intspan_bucket_list( - bounds: "const Span *", size: int, origin: int -) -> "Tuple['Span *', 'int']": - bounds_converted = _ffi.cast("const Span *", bounds) - count = _ffi.new("int *") +def intspan_bucket_list(bounds: 'const Span *', size: int, origin: int) -> "Tuple['Span *', 'int']": + bounds_converted = _ffi.cast('const Span *', bounds) + count = _ffi.new('int *') result = _lib.intspan_bucket_list(bounds_converted, size, origin, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tstzspan_bucket_list( - bounds: "const Span *", duration: "const Interval *", origin: int -) -> "Tuple['Span *', 'int']": - bounds_converted = _ffi.cast("const Span *", bounds) - duration_converted = _ffi.cast("const Interval *", duration) - origin_converted = _ffi.cast("TimestampTz", origin) - count = _ffi.new("int *") - result = _lib.tstzspan_bucket_list( - bounds_converted, duration_converted, origin_converted, count - ) +def tstzspan_bucket_list(bounds: 'const Span *', duration: 'const Interval *', origin: int) -> "Tuple['Span *', 'int']": + bounds_converted = _ffi.cast('const Span *', bounds) + duration_converted = _ffi.cast('const Interval *', duration) + origin_converted = _ffi.cast('TimestampTz', origin) + count = _ffi.new('int *') + result = _lib.tstzspan_bucket_list(bounds_converted, duration_converted, origin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def stbox_tile( - point: "GSERIALIZED *", - t: int, - xsize: float, - ysize: float, - zsize: float, - duration: "Interval *", - sorigin: "GSERIALIZED *", - torigin: int, - hast: bool, -) -> "STBox *": - point_converted = _ffi.cast("GSERIALIZED *", point) - t_converted = _ffi.cast("TimestampTz", t) - duration_converted = _ffi.cast("Interval *", duration) - sorigin_converted = _ffi.cast("GSERIALIZED *", sorigin) - torigin_converted = _ffi.cast("TimestampTz", torigin) - result = _lib.stbox_tile( - point_converted, - t_converted, - xsize, - ysize, - zsize, - duration_converted, - sorigin_converted, - torigin_converted, - hast, - ) +def stbox_tile(point: 'GSERIALIZED *', t: int, xsize: float, ysize: float, zsize: float, duration: 'Interval *', sorigin: 'GSERIALIZED *', torigin: int, hast: bool) -> 'STBox *': + point_converted = _ffi.cast('GSERIALIZED *', point) + t_converted = _ffi.cast('TimestampTz', t) + duration_converted = _ffi.cast('Interval *', duration) + sorigin_converted = _ffi.cast('GSERIALIZED *', sorigin) + torigin_converted = _ffi.cast('TimestampTz', torigin) + result = _lib.stbox_tile(point_converted, t_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted, hast) _check_error() return result if result != _ffi.NULL else None -def stbox_tile_list( - bounds: "const STBox *", - xsize: float, - ysize: float, - zsize: float, - duration: "Optional['const Interval *']", - sorigin: "GSERIALIZED *", - torigin: int, -) -> "Tuple['STBox *', 'int']": - bounds_converted = _ffi.cast("const STBox *", bounds) - duration_converted = ( - _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL - ) - sorigin_converted = _ffi.cast("GSERIALIZED *", sorigin) - torigin_converted = _ffi.cast("TimestampTz", torigin) - count = _ffi.new("int *") - result = _lib.stbox_tile_list( - bounds_converted, - xsize, - ysize, - zsize, - duration_converted, - sorigin_converted, - torigin_converted, - count, - ) +def stbox_tile_list(bounds: 'const STBox *', xsize: float, ysize: float, zsize: float, duration: "Optional['const Interval *']", sorigin: 'GSERIALIZED *', torigin: int) -> "Tuple['STBox *', 'int']": + bounds_converted = _ffi.cast('const STBox *', bounds) + duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL + sorigin_converted = _ffi.cast('GSERIALIZED *', sorigin) + torigin_converted = _ffi.cast('TimestampTz', torigin) + count = _ffi.new('int *') + result = _lib.stbox_tile_list(bounds_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tintbox_tile_list( - box: "const TBox *", - xsize: int, - duration: "const Interval *", - xorigin: "Optional[int]", - torigin: "Optional[int]", -) -> "Tuple['TBox *', 'int']": - box_converted = _ffi.cast("const TBox *", box) - duration_converted = _ffi.cast("const Interval *", duration) +def tintbox_tile_list(box: 'const TBox *', xsize: int, duration: 'const Interval *', xorigin: 'Optional[int]', torigin: "Optional[int]") -> "Tuple['TBox *', 'int']": + box_converted = _ffi.cast('const TBox *', box) + duration_converted = _ffi.cast('const Interval *', duration) xorigin_converted = xorigin if xorigin is not None else _ffi.NULL - torigin_converted = ( - _ffi.cast("TimestampTz", torigin) if torigin is not None else _ffi.NULL - ) - count = _ffi.new("int *") - result = _lib.tintbox_tile_list( - box_converted, - xsize, - duration_converted, - xorigin_converted, - torigin_converted, - count, - ) + torigin_converted = _ffi.cast('TimestampTz', torigin) if torigin is not None else _ffi.NULL + count = _ffi.new('int *') + result = _lib.tintbox_tile_list(box_converted, xsize, duration_converted, xorigin_converted, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tfloatbox_tile_list( - box: "const TBox *", - xsize: float, - duration: "const Interval *", - xorigin: "Optional[float]", - torigin: "Optional[int]", -) -> "Tuple['TBox *', 'int']": - box_converted = _ffi.cast("const TBox *", box) - duration_converted = _ffi.cast("const Interval *", duration) +def tfloatbox_tile_list(box: 'const TBox *', xsize: float, duration: 'const Interval *', xorigin: 'Optional[float]', torigin: "Optional[int]") -> "Tuple['TBox *', 'int']": + box_converted = _ffi.cast('const TBox *', box) + duration_converted = _ffi.cast('const Interval *', duration) xorigin_converted = xorigin if xorigin is not None else _ffi.NULL - torigin_converted = ( - _ffi.cast("TimestampTz", torigin) if torigin is not None else _ffi.NULL - ) - count = _ffi.new("int *") - result = _lib.tfloatbox_tile_list( - box_converted, - xsize, - duration_converted, - xorigin_converted, - torigin_converted, - count, - ) + torigin_converted = _ffi.cast('TimestampTz', torigin) if torigin is not None else _ffi.NULL + count = _ffi.new('int *') + result = _lib.tfloatbox_tile_list(box_converted, xsize, duration_converted, xorigin_converted, torigin_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_time_split( - temp: "Temporal *", duration: "Interval *", torigin: int -) -> "Tuple['Temporal **', 'TimestampTz *', 'int']": - temp_converted = _ffi.cast("Temporal *", temp) - duration_converted = _ffi.cast("Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - time_buckets = _ffi.new("TimestampTz **") - count = _ffi.new("int *") - result = _lib.temporal_time_split( - temp_converted, duration_converted, torigin_converted, time_buckets, count - ) +def temporal_time_split(temp: 'Temporal *', duration: 'Interval *', torigin: int) -> "Tuple['Temporal **', 'TimestampTz *', 'int']": + temp_converted = _ffi.cast('Temporal *', temp) + duration_converted = _ffi.cast('Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + time_buckets = _ffi.new('TimestampTz **') + count = _ffi.new('int *') + result = _lib.temporal_time_split(temp_converted, duration_converted, torigin_converted, time_buckets, count) _check_error() return result if result != _ffi.NULL else None, time_buckets[0], count[0] -def tfloat_value_split( - temp: "Temporal *", size: float, origin: float -) -> "Tuple['Temporal **', 'double *', 'int']": - temp_converted = _ffi.cast("Temporal *", temp) - value_buckets = _ffi.new("double **") - count = _ffi.new("int *") +def tfloat_value_split(temp: 'Temporal *', size: float, origin: float) -> "Tuple['Temporal **', 'double *', 'int']": + temp_converted = _ffi.cast('Temporal *', temp) + value_buckets = _ffi.new('double **') + count = _ffi.new('int *') result = _lib.tfloat_value_split(temp_converted, size, origin, value_buckets, count) _check_error() return result if result != _ffi.NULL else None, value_buckets[0], count[0] -def tfloat_value_time_split( - temp: "Temporal *", - size: float, - duration: "Interval *", - vorigin: float, - torigin: int, -) -> "Tuple['Temporal **', 'double *', 'TimestampTz *', 'int']": - temp_converted = _ffi.cast("Temporal *", temp) - duration_converted = _ffi.cast("Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - value_buckets = _ffi.new("double **") - time_buckets = _ffi.new("TimestampTz **") - count = _ffi.new("int *") - result = _lib.tfloat_value_time_split( - temp_converted, - size, - duration_converted, - vorigin, - torigin_converted, - value_buckets, - time_buckets, - count, - ) +def tfloat_value_time_split(temp: 'Temporal *', size: float, duration: 'Interval *', vorigin: float, torigin: int) -> "Tuple['Temporal **', 'double *', 'TimestampTz *', 'int']": + temp_converted = _ffi.cast('Temporal *', temp) + duration_converted = _ffi.cast('Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + value_buckets = _ffi.new('double **') + time_buckets = _ffi.new('TimestampTz **') + count = _ffi.new('int *') + result = _lib.tfloat_value_time_split(temp_converted, size, duration_converted, vorigin, torigin_converted, value_buckets, time_buckets, count) _check_error() - return ( - result if result != _ffi.NULL else None, - value_buckets[0], - time_buckets[0], - count[0], - ) + return result if result != _ffi.NULL else None, value_buckets[0], time_buckets[0], count[0] -def timestamptz_bucket( - timestamp: int, duration: "const Interval *", origin: int -) -> "TimestampTz": - timestamp_converted = _ffi.cast("TimestampTz", timestamp) - duration_converted = _ffi.cast("const Interval *", duration) - origin_converted = _ffi.cast("TimestampTz", origin) - result = _lib.timestamptz_bucket( - timestamp_converted, duration_converted, origin_converted - ) +def timestamptz_bucket(timestamp: int, duration: 'const Interval *', origin: int) -> 'TimestampTz': + timestamp_converted = _ffi.cast('TimestampTz', timestamp) + duration_converted = _ffi.cast('const Interval *', duration) + origin_converted = _ffi.cast('TimestampTz', origin) + result = _lib.timestamptz_bucket(timestamp_converted, duration_converted, origin_converted) _check_error() return result if result != _ffi.NULL else None -def tint_value_split( - temp: "Temporal *", size: int, origin: int -) -> "Tuple['Temporal **', 'int *', 'int']": - temp_converted = _ffi.cast("Temporal *", temp) - value_buckets = _ffi.new("int **") - count = _ffi.new("int *") +def tint_value_split(temp: 'Temporal *', size: int, origin: int) -> "Tuple['Temporal **', 'int *', 'int']": + temp_converted = _ffi.cast('Temporal *', temp) + value_buckets = _ffi.new('int **') + count = _ffi.new('int *') result = _lib.tint_value_split(temp_converted, size, origin, value_buckets, count) _check_error() return result if result != _ffi.NULL else None, value_buckets[0], count[0] -def tint_value_time_split( - temp: "Temporal *", size: int, duration: "Interval *", vorigin: int, torigin: int -) -> "Tuple['Temporal **', 'int *', 'TimestampTz *', 'int']": - temp_converted = _ffi.cast("Temporal *", temp) - duration_converted = _ffi.cast("Interval *", duration) - torigin_converted = _ffi.cast("TimestampTz", torigin) - value_buckets = _ffi.new("int **") - time_buckets = _ffi.new("TimestampTz **") - count = _ffi.new("int *") - result = _lib.tint_value_time_split( - temp_converted, - size, - duration_converted, - vorigin, - torigin_converted, - value_buckets, - time_buckets, - count, - ) +def tint_value_time_split(temp: 'Temporal *', size: int, duration: 'Interval *', vorigin: int, torigin: int) -> "Tuple['Temporal **', 'int *', 'TimestampTz *', 'int']": + temp_converted = _ffi.cast('Temporal *', temp) + duration_converted = _ffi.cast('Interval *', duration) + torigin_converted = _ffi.cast('TimestampTz', torigin) + value_buckets = _ffi.new('int **') + time_buckets = _ffi.new('TimestampTz **') + count = _ffi.new('int *') + result = _lib.tint_value_time_split(temp_converted, size, duration_converted, vorigin, torigin_converted, value_buckets, time_buckets, count) _check_error() - return ( - result if result != _ffi.NULL else None, - value_buckets[0], - time_buckets[0], - count[0], - ) + return result if result != _ffi.NULL else None, value_buckets[0], time_buckets[0], count[0] -def tpoint_space_split( - temp: "Temporal *", - xsize: "float", - ysize: "float", - zsize: "float", - sorigin: "GSERIALIZED *", - bitmatrix: bool, -) -> "Tuple['Temporal **', 'GSERIALIZED ***', 'int']": - temp_converted = _ffi.cast("Temporal *", temp) - xsize_converted = _ffi.cast("float", xsize) - ysize_converted = _ffi.cast("float", ysize) - zsize_converted = _ffi.cast("float", zsize) - sorigin_converted = _ffi.cast("GSERIALIZED *", sorigin) - space_buckets = _ffi.new("GSERIALIZED ***") - count = _ffi.new("int *") - result = _lib.tpoint_space_split( - temp_converted, - xsize_converted, - ysize_converted, - zsize_converted, - sorigin_converted, - bitmatrix, - space_buckets, - count, - ) +def tpoint_space_split(temp: 'Temporal *', xsize: 'float', ysize: 'float', zsize: 'float', sorigin: 'GSERIALIZED *', bitmatrix: bool) -> "Tuple['Temporal **', 'GSERIALIZED ***', 'int']": + temp_converted = _ffi.cast('Temporal *', temp) + xsize_converted = _ffi.cast('float', xsize) + ysize_converted = _ffi.cast('float', ysize) + zsize_converted = _ffi.cast('float', zsize) + sorigin_converted = _ffi.cast('GSERIALIZED *', sorigin) + space_buckets = _ffi.new('GSERIALIZED ***') + count = _ffi.new('int *') + result = _lib.tpoint_space_split(temp_converted, xsize_converted, ysize_converted, zsize_converted, sorigin_converted, bitmatrix, space_buckets, count) _check_error() return result if result != _ffi.NULL else None, space_buckets[0], count[0] -def tpoint_space_time_split( - temp: "Temporal *", - xsize: "float", - ysize: "float", - zsize: "float", - duration: "Interval *", - sorigin: "GSERIALIZED *", - torigin: int, - bitmatrix: bool, -) -> "Tuple['Temporal **', 'GSERIALIZED ***', 'TimestampTz *', 'int']": - temp_converted = _ffi.cast("Temporal *", temp) - xsize_converted = _ffi.cast("float", xsize) - ysize_converted = _ffi.cast("float", ysize) - zsize_converted = _ffi.cast("float", zsize) - duration_converted = _ffi.cast("Interval *", duration) - sorigin_converted = _ffi.cast("GSERIALIZED *", sorigin) - torigin_converted = _ffi.cast("TimestampTz", torigin) - space_buckets = _ffi.new("GSERIALIZED ***") - time_buckets = _ffi.new("TimestampTz **") - count = _ffi.new("int *") - result = _lib.tpoint_space_time_split( - temp_converted, - xsize_converted, - ysize_converted, - zsize_converted, - duration_converted, - sorigin_converted, - torigin_converted, - bitmatrix, - space_buckets, - time_buckets, - count, - ) +def tpoint_space_time_split(temp: 'Temporal *', xsize: 'float', ysize: 'float', zsize: 'float', duration: 'Interval *', sorigin: 'GSERIALIZED *', torigin: int, bitmatrix: bool) -> "Tuple['Temporal **', 'GSERIALIZED ***', 'TimestampTz *', 'int']": + temp_converted = _ffi.cast('Temporal *', temp) + xsize_converted = _ffi.cast('float', xsize) + ysize_converted = _ffi.cast('float', ysize) + zsize_converted = _ffi.cast('float', zsize) + duration_converted = _ffi.cast('Interval *', duration) + sorigin_converted = _ffi.cast('GSERIALIZED *', sorigin) + torigin_converted = _ffi.cast('TimestampTz', torigin) + space_buckets = _ffi.new('GSERIALIZED ***') + time_buckets = _ffi.new('TimestampTz **') + count = _ffi.new('int *') + result = _lib.tpoint_space_time_split(temp_converted, xsize_converted, ysize_converted, zsize_converted, duration_converted, sorigin_converted, torigin_converted, bitmatrix, space_buckets, time_buckets, count) _check_error() - return ( - result if result != _ffi.NULL else None, - space_buckets[0], - time_buckets[0], - count[0], - ) + return result if result != _ffi.NULL else None, space_buckets[0], time_buckets[0], count[0] -def temptype_subtype(subtype: "tempSubtype") -> "bool": - subtype_converted = _ffi.cast("tempSubtype", subtype) +def temptype_subtype(subtype: 'tempSubtype') -> 'bool': + subtype_converted = _ffi.cast('tempSubtype', subtype) result = _lib.temptype_subtype(subtype_converted) _check_error() return result if result != _ffi.NULL else None -def temptype_subtype_all(subtype: "tempSubtype") -> "bool": - subtype_converted = _ffi.cast("tempSubtype", subtype) +def temptype_subtype_all(subtype: 'tempSubtype') -> 'bool': + subtype_converted = _ffi.cast('tempSubtype', subtype) result = _lib.temptype_subtype_all(subtype_converted) _check_error() return result if result != _ffi.NULL else None -def tempsubtype_name(subtype: "tempSubtype") -> str: - subtype_converted = _ffi.cast("tempSubtype", subtype) +def tempsubtype_name(subtype: 'tempSubtype') -> str: + subtype_converted = _ffi.cast('tempSubtype', subtype) result = _lib.tempsubtype_name(subtype_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tempsubtype_from_string(string: str, subtype: "int16 *") -> "bool": - string_converted = string.encode("utf-8") - subtype_converted = _ffi.cast("int16 *", subtype) +def tempsubtype_from_string(string: str, subtype: 'int16 *') -> 'bool': + string_converted = string.encode('utf-8') + subtype_converted = _ffi.cast('int16 *', subtype) result = _lib.tempsubtype_from_string(string_converted, subtype_converted) _check_error() return result if result != _ffi.NULL else None -def meosoper_name(oper: "meosOper") -> str: - oper_converted = _ffi.cast("meosOper", oper) +def meosoper_name(oper: 'meosOper') -> str: + oper_converted = _ffi.cast('meosOper', oper) result = _lib.meosoper_name(oper_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def meosoper_from_string(name: str) -> "meosOper": - name_converted = name.encode("utf-8") +def meosoper_from_string(name: str) -> 'meosOper': + name_converted = name.encode('utf-8') result = _lib.meosoper_from_string(name_converted) _check_error() return result if result != _ffi.NULL else None -def interptype_name(interp: "interpType") -> str: - interp_converted = _ffi.cast("interpType", interp) +def interptype_name(interp: 'interpType') -> str: + interp_converted = _ffi.cast('interpType', interp) result = _lib.interptype_name(interp_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def interptype_from_string(interp_str: str) -> "interpType": - interp_str_converted = interp_str.encode("utf-8") +def interptype_from_string(interp_str: str) -> 'interpType': + interp_str_converted = interp_str.encode('utf-8') result = _lib.interptype_from_string(interp_str_converted) _check_error() return result if result != _ffi.NULL else None -def meostype_name(type: "meosType") -> str: - type_converted = _ffi.cast("meosType", type) +def meostype_name(type: 'meosType') -> str: + type_converted = _ffi.cast('meosType', type) result = _lib.meostype_name(type_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def temptype_basetype(type: "meosType") -> "meosType": - type_converted = _ffi.cast("meosType", type) +def temptype_basetype(type: 'meosType') -> 'meosType': + type_converted = _ffi.cast('meosType', type) result = _lib.temptype_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def settype_basetype(type: "meosType") -> "meosType": - type_converted = _ffi.cast("meosType", type) +def settype_basetype(type: 'meosType') -> 'meosType': + type_converted = _ffi.cast('meosType', type) result = _lib.settype_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def spantype_basetype(type: "meosType") -> "meosType": - type_converted = _ffi.cast("meosType", type) +def spantype_basetype(type: 'meosType') -> 'meosType': + type_converted = _ffi.cast('meosType', type) result = _lib.spantype_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def spantype_spansettype(type: "meosType") -> "meosType": - type_converted = _ffi.cast("meosType", type) +def spantype_spansettype(type: 'meosType') -> 'meosType': + type_converted = _ffi.cast('meosType', type) result = _lib.spantype_spansettype(type_converted) _check_error() return result if result != _ffi.NULL else None -def spansettype_spantype(type: "meosType") -> "meosType": - type_converted = _ffi.cast("meosType", type) +def spansettype_spantype(type: 'meosType') -> 'meosType': + type_converted = _ffi.cast('meosType', type) result = _lib.spansettype_spantype(type_converted) _check_error() return result if result != _ffi.NULL else None -def basetype_spantype(type: "meosType") -> "meosType": - type_converted = _ffi.cast("meosType", type) +def basetype_spantype(type: 'meosType') -> 'meosType': + type_converted = _ffi.cast('meosType', type) result = _lib.basetype_spantype(type_converted) _check_error() return result if result != _ffi.NULL else None -def basetype_settype(type: "meosType") -> "meosType": - type_converted = _ffi.cast("meosType", type) +def basetype_settype(type: 'meosType') -> 'meosType': + type_converted = _ffi.cast('meosType', type) result = _lib.basetype_settype(type_converted) _check_error() return result if result != _ffi.NULL else None -def meostype_internal(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def meostype_internal(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.meostype_internal(type_converted) _check_error() return result if result != _ffi.NULL else None -def meos_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def meos_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.meos_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def alpha_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def alpha_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.alpha_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def tnumber_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.tnumber_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def alphanum_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def alphanum_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.alphanum_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def geo_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def geo_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.geo_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def spatial_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def spatial_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.spatial_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def time_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def time_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.time_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def set_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def set_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.set_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def set_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def set_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.set_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def numset_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def numset_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.numset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_numset_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def ensure_numset_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_numset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def timeset_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def timeset_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.timeset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_timeset_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def ensure_timeset_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_timeset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def set_spantype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def set_spantype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.set_spantype(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_set_spantype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def ensure_set_spantype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_set_spantype(type_converted) _check_error() return result if result != _ffi.NULL else None -def alphanumset_type(settype: "meosType") -> "bool": - settype_converted = _ffi.cast("meosType", settype) +def alphanumset_type(settype: 'meosType') -> 'bool': + settype_converted = _ffi.cast('meosType', settype) result = _lib.alphanumset_type(settype_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def geoset_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.geoset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_geoset_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def ensure_geoset_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_geoset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def spatialset_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def spatialset_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.spatialset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_spatialset_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def ensure_spatialset_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_spatialset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def span_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def span_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.span_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def span_canon_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def span_canon_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.span_canon_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def span_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def span_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.span_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def span_bbox_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def span_bbox_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.span_bbox_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def numspan_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.numspan_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def numspan_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.numspan_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_numspan_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def ensure_numspan_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_numspan_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def timespan_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def timespan_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.timespan_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def timespan_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def timespan_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.timespan_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_timespan_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def ensure_timespan_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_timespan_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def spanset_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.spanset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def numspanset_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def numspanset_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.numspanset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def timespanset_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def timespanset_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.timespanset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_timespanset_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def ensure_timespanset_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_timespanset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def temporal_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.temporal_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def temporal_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.temporal_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def temptype_continuous(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def temptype_continuous(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.temptype_continuous(type_converted) _check_error() return result if result != _ffi.NULL else None -def basetype_byvalue(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def basetype_byvalue(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.basetype_byvalue(type_converted) _check_error() return result if result != _ffi.NULL else None -def basetype_varlength(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def basetype_varlength(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.basetype_varlength(type_converted) _check_error() return result if result != _ffi.NULL else None -def basetype_length(type: "meosType") -> "int16": - type_converted = _ffi.cast("meosType", type) +def basetype_length(type: 'meosType') -> 'int16': + type_converted = _ffi.cast('meosType', type) result = _lib.basetype_length(type_converted) _check_error() return result if result != _ffi.NULL else None -def talphanum_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def talphanum_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.talphanum_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def talpha_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def talpha_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.talpha_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def tnumber_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.tnumber_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tnumber_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def ensure_tnumber_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_tnumber_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def tnumber_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.tnumber_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tnumber_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def ensure_tnumber_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_tnumber_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_settype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def tnumber_settype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.tnumber_settype(type_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_spantype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def tnumber_spantype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.tnumber_spantype(type_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_spansettype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def tnumber_spansettype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.tnumber_spansettype(type_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def tspatial_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.tspatial_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tspatial_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def ensure_tspatial_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_tspatial_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_basetype(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def tspatial_basetype(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.tspatial_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def tgeo_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def tgeo_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.tgeo_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tgeo_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def ensure_tgeo_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_tgeo_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tnumber_tgeo_type(type: "meosType") -> "bool": - type_converted = _ffi.cast("meosType", type) +def ensure_tnumber_tgeo_type(type: 'meosType') -> 'bool': + type_converted = _ffi.cast('meosType', type) result = _lib.ensure_tnumber_tgeo_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def datum_hash(d: "Datum", basetype: "meosType") -> "uint32": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def datum_hash(d: 'Datum', basetype: 'meosType') -> 'uint32': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.datum_hash(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def datum_hash_extended(d: "Datum", basetype: "meosType", seed: int) -> "uint64": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - seed_converted = _ffi.cast("uint64", seed) +def datum_hash_extended(d: 'Datum', basetype: 'meosType', seed: int) -> 'uint64': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + seed_converted = _ffi.cast('uint64', seed) result = _lib.datum_hash_extended(d_converted, basetype_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def set_in(string: str, basetype: "meosType") -> "Set *": - string_converted = string.encode("utf-8") - basetype_converted = _ffi.cast("meosType", basetype) +def set_in(string: str, basetype: 'meosType') -> 'Set *': + string_converted = string.encode('utf-8') + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.set_in(string_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def set_out(s: "const Set *", maxdd: int) -> str: - s_converted = _ffi.cast("const Set *", s) +def set_out(s: 'const Set *', maxdd: int) -> str: + s_converted = _ffi.cast('const Set *', s) result = _lib.set_out(s_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def span_in(string: str, spantype: "meosType") -> "Span *": - string_converted = string.encode("utf-8") - spantype_converted = _ffi.cast("meosType", spantype) +def span_in(string: str, spantype: 'meosType') -> 'Span *': + string_converted = string.encode('utf-8') + spantype_converted = _ffi.cast('meosType', spantype) result = _lib.span_in(string_converted, spantype_converted) _check_error() return result if result != _ffi.NULL else None -def span_out(s: "const Span *", maxdd: int) -> str: - s_converted = _ffi.cast("const Span *", s) +def span_out(s: 'const Span *', maxdd: int) -> str: + s_converted = _ffi.cast('const Span *', s) result = _lib.span_out(s_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def spanset_in(string: str, spantype: "meosType") -> "SpanSet *": - string_converted = string.encode("utf-8") - spantype_converted = _ffi.cast("meosType", spantype) +def spanset_in(string: str, spantype: 'meosType') -> 'SpanSet *': + string_converted = string.encode('utf-8') + spantype_converted = _ffi.cast('meosType', spantype) result = _lib.spanset_in(string_converted, spantype_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_out(ss: "const SpanSet *", maxdd: int) -> str: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_out(ss: 'const SpanSet *', maxdd: int) -> str: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_out(ss_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def set_compact(s: "const Set *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def set_compact(s: 'const Set *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.set_compact(s_converted) _check_error() return result if result != _ffi.NULL else None -def set_cp(s: "const Set *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def set_cp(s: 'const Set *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.set_cp(s_converted) _check_error() return result if result != _ffi.NULL else None -def set_make( - values: "const Datum *", count: int, basetype: "meosType", ordered: bool -) -> "Set *": - values_converted = _ffi.cast("const Datum *", values) - basetype_converted = _ffi.cast("meosType", basetype) +def set_make(values: 'const Datum *', count: int, basetype: 'meosType', ordered: bool) -> 'Set *': + values_converted = _ffi.cast('const Datum *', values) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.set_make(values_converted, count, basetype_converted, ordered) _check_error() return result if result != _ffi.NULL else None -def set_make_exp( - values: "const Datum *", - count: int, - maxcount: int, - basetype: "meosType", - ordered: bool, -) -> "Set *": - values_converted = _ffi.cast("const Datum *", values) - basetype_converted = _ffi.cast("meosType", basetype) - result = _lib.set_make_exp( - values_converted, count, maxcount, basetype_converted, ordered - ) +def set_make_exp(values: 'const Datum *', count: int, maxcount: int, basetype: 'meosType', ordered: bool) -> 'Set *': + values_converted = _ffi.cast('const Datum *', values) + basetype_converted = _ffi.cast('meosType', basetype) + result = _lib.set_make_exp(values_converted, count, maxcount, basetype_converted, ordered) _check_error() return result if result != _ffi.NULL else None -def set_make_free( - values: "Datum *", count: int, basetype: "meosType", ordered: bool -) -> "Set *": - values_converted = _ffi.cast("Datum *", values) - basetype_converted = _ffi.cast("meosType", basetype) +def set_make_free(values: 'Datum *', count: int, basetype: 'meosType', ordered: bool) -> 'Set *': + values_converted = _ffi.cast('Datum *', values) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.set_make_free(values_converted, count, basetype_converted, ordered) _check_error() return result if result != _ffi.NULL else None -def set_out(s: "const Set *", maxdd: int) -> str: - s_converted = _ffi.cast("const Set *", s) +def set_out(s: 'const Set *', maxdd: int) -> str: + s_converted = _ffi.cast('const Set *', s) result = _lib.set_out(s_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def span_cp(s: "const Span *") -> "Span *": - s_converted = _ffi.cast("const Span *", s) +def span_cp(s: 'const Span *') -> 'Span *': + s_converted = _ffi.cast('const Span *', s) result = _lib.span_cp(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_make( - lower: "Datum", - upper: "Datum", - lower_inc: bool, - upper_inc: bool, - basetype: "meosType", -) -> "Span *": - lower_converted = _ffi.cast("Datum", lower) - upper_converted = _ffi.cast("Datum", upper) - basetype_converted = _ffi.cast("meosType", basetype) - result = _lib.span_make( - lower_converted, upper_converted, lower_inc, upper_inc, basetype_converted - ) +def span_make(lower: 'Datum', upper: 'Datum', lower_inc: bool, upper_inc: bool, basetype: 'meosType') -> 'Span *': + lower_converted = _ffi.cast('Datum', lower) + upper_converted = _ffi.cast('Datum', upper) + basetype_converted = _ffi.cast('meosType', basetype) + result = _lib.span_make(lower_converted, upper_converted, lower_inc, upper_inc, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def span_out(s: "const Span *", maxdd: int) -> str: - s_converted = _ffi.cast("const Span *", s) +def span_out(s: 'const Span *', maxdd: int) -> str: + s_converted = _ffi.cast('const Span *', s) result = _lib.span_out(s_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") - return result if result != _ffi.NULL else None - - -def span_set( - lower: "Datum", - upper: "Datum", - lower_inc: bool, - upper_inc: bool, - basetype: "meosType", - spantype: "meosType", - s: "Span *", -) -> None: - lower_converted = _ffi.cast("Datum", lower) - upper_converted = _ffi.cast("Datum", upper) - basetype_converted = _ffi.cast("meosType", basetype) - spantype_converted = _ffi.cast("meosType", spantype) - s_converted = _ffi.cast("Span *", s) - _lib.span_set( - lower_converted, - upper_converted, - lower_inc, - upper_inc, - basetype_converted, - spantype_converted, - s_converted, - ) + result = _ffi.string(result).decode('utf-8') + return result if result != _ffi.NULL else None + + +def span_set(lower: 'Datum', upper: 'Datum', lower_inc: bool, upper_inc: bool, basetype: 'meosType', spantype: 'meosType', s: 'Span *') -> None: + lower_converted = _ffi.cast('Datum', lower) + upper_converted = _ffi.cast('Datum', upper) + basetype_converted = _ffi.cast('meosType', basetype) + spantype_converted = _ffi.cast('meosType', spantype) + s_converted = _ffi.cast('Span *', s) + _lib.span_set(lower_converted, upper_converted, lower_inc, upper_inc, basetype_converted, spantype_converted, s_converted) _check_error() -def spanset_cp(ss: "const SpanSet *") -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_cp(ss: 'const SpanSet *') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_cp(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_compact(ss: "SpanSet *") -> "SpanSet *": - ss_converted = _ffi.cast("SpanSet *", ss) +def spanset_compact(ss: 'SpanSet *') -> 'SpanSet *': + ss_converted = _ffi.cast('SpanSet *', ss) result = _lib.spanset_compact(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_make_exp( - spans: "Span *", count: int, maxcount: int, normalize: bool, ordered: bool -) -> "SpanSet *": - spans_converted = _ffi.cast("Span *", spans) +def spanset_make_exp(spans: 'Span *', count: int, maxcount: int, normalize: bool, ordered: bool) -> 'SpanSet *': + spans_converted = _ffi.cast('Span *', spans) result = _lib.spanset_make_exp(spans_converted, count, maxcount, normalize, ordered) _check_error() return result if result != _ffi.NULL else None -def spanset_make_free(spans: "Span *", count: int, normalize: bool) -> "SpanSet *": - spans_converted = _ffi.cast("Span *", spans) +def spanset_make_free(spans: 'Span *', count: int, normalize: bool) -> 'SpanSet *': + spans_converted = _ffi.cast('Span *', spans) result = _lib.spanset_make_free(spans_converted, count, normalize) _check_error() return result if result != _ffi.NULL else None -def spanset_out(ss: "const SpanSet *", maxdd: int) -> str: - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_out(ss: 'const SpanSet *', maxdd: int) -> str: + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_out(ss_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def span_spanset(s: "const Span *") -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) +def span_spanset(s: 'const Span *') -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) result = _lib.span_spanset(s_converted) _check_error() return result if result != _ffi.NULL else None -def value_to_set(d: "Datum", basetype: "meosType") -> "Set *": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def value_to_set(d: 'Datum', basetype: 'meosType') -> 'Set *': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.value_to_set(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def value_to_span(d: "Datum", basetype: "meosType") -> "Span *": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def value_to_span(d: 'Datum', basetype: 'meosType') -> 'Span *': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.value_to_span(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def value_to_spanset(d: "Datum", basetype: "meosType") -> "SpanSet *": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def value_to_spanset(d: 'Datum', basetype: 'meosType') -> 'SpanSet *': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.value_to_spanset(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def set_end_value(s: "const Set *") -> "Datum": - s_converted = _ffi.cast("const Set *", s) +def set_end_value(s: 'const Set *') -> 'Datum': + s_converted = _ffi.cast('const Set *', s) result = _lib.set_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def set_mem_size(s: "const Set *") -> "int": - s_converted = _ffi.cast("const Set *", s) +def set_mem_size(s: 'const Set *') -> 'int': + s_converted = _ffi.cast('const Set *', s) result = _lib.set_mem_size(s_converted) _check_error() return result if result != _ffi.NULL else None -def set_set_span(s: "const Set *", sp: "Span *") -> None: - s_converted = _ffi.cast("const Set *", s) - sp_converted = _ffi.cast("Span *", sp) +def set_set_span(s: 'const Set *', sp: 'Span *') -> None: + s_converted = _ffi.cast('const Set *', s) + sp_converted = _ffi.cast('Span *', sp) _lib.set_set_span(s_converted, sp_converted) _check_error() -def set_span(s: "const Set *") -> "Span *": - s_converted = _ffi.cast("const Set *", s) +def set_span(s: 'const Set *') -> 'Span *': + s_converted = _ffi.cast('const Set *', s) result = _lib.set_span(s_converted) _check_error() return result if result != _ffi.NULL else None -def set_start_value(s: "const Set *") -> "Datum": - s_converted = _ffi.cast("const Set *", s) +def set_start_value(s: 'const Set *') -> 'Datum': + s_converted = _ffi.cast('const Set *', s) result = _lib.set_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def set_value_n(s: "const Set *", n: int) -> "Datum *": - s_converted = _ffi.cast("const Set *", s) - out_result = _ffi.new("Datum *") +def set_value_n(s: 'const Set *', n: int) -> 'Datum *': + s_converted = _ffi.cast('const Set *', s) + out_result = _ffi.new('Datum *') result = _lib.set_value_n(s_converted, n, out_result) _check_error() if result: @@ -11766,715 +11005,672 @@ def set_value_n(s: "const Set *", n: int) -> "Datum *": return None -def set_values(s: "const Set *") -> "Datum *": - s_converted = _ffi.cast("const Set *", s) +def set_values(s: 'const Set *') -> 'Datum *': + s_converted = _ffi.cast('const Set *', s) result = _lib.set_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_lower(ss: "const SpanSet *") -> "Datum": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_lower(ss: 'const SpanSet *') -> 'Datum': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_lower(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_mem_size(ss: "const SpanSet *") -> "int": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_mem_size(ss: 'const SpanSet *') -> 'int': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_mem_size(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_upper(ss: "const SpanSet *") -> "Datum": - ss_converted = _ffi.cast("const SpanSet *", ss) +def spanset_upper(ss: 'const SpanSet *') -> 'Datum': + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.spanset_upper(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spatialset_set_stbox(set: "const Set *", box: "STBox *") -> None: - set_converted = _ffi.cast("const Set *", set) - box_converted = _ffi.cast("STBox *", box) +def spatialset_set_stbox(set: 'const Set *', box: 'STBox *') -> None: + set_converted = _ffi.cast('const Set *', set) + box_converted = _ffi.cast('STBox *', box) _lib.spatialset_set_stbox(set_converted, box_converted) _check_error() -def value_set_span(d: "Datum", basetype: "meosType", s: "Span *") -> None: - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("Span *", s) +def value_set_span(d: 'Datum', basetype: 'meosType', s: 'Span *') -> None: + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('Span *', s) _lib.value_set_span(d_converted, basetype_converted, s_converted) _check_error() -def datespan_set_tstzspan(s1: "const Span *", s2: "Span *") -> None: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("Span *", s2) +def datespan_set_tstzspan(s1: 'const Span *', s2: 'Span *') -> None: + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('Span *', s2) _lib.datespan_set_tstzspan(s1_converted, s2_converted) _check_error() -def floatspan_rnd(span: "const Span *", size: "Datum") -> "Span *": - span_converted = _ffi.cast("const Span *", span) - size_converted = _ffi.cast("Datum", size) - out_result = _ffi.new("Span *") +def floatspan_rnd(span: 'const Span *', size: 'Datum') -> 'Span *': + span_converted = _ffi.cast('const Span *', span) + size_converted = _ffi.cast('Datum', size) + out_result = _ffi.new('Span *') _lib.floatspan_rnd(span_converted, size_converted, out_result) _check_error() - return out_result if out_result != _ffi.NULL else None + return out_result if out_result!= _ffi.NULL else None + -def floatspan_set_intspan(s1: "const Span *", s2: "Span *") -> None: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("Span *", s2) +def floatspan_set_intspan(s1: 'const Span *', s2: 'Span *') -> None: + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('Span *', s2) _lib.floatspan_set_intspan(s1_converted, s2_converted) _check_error() -def floatspan_set_numspan( - s1: "const Span *", s2: "Span *", basetype: "meosType" -) -> None: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("Span *", s2) - basetype_converted = _ffi.cast("meosType", basetype) +def floatspan_set_numspan(s1: 'const Span *', s2: 'Span *', basetype: 'meosType') -> None: + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('Span *', s2) + basetype_converted = _ffi.cast('meosType', basetype) _lib.floatspan_set_numspan(s1_converted, s2_converted, basetype_converted) _check_error() -def intspan_set_floatspan(s1: "const Span *", s2: "Span *") -> None: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("Span *", s2) +def intspan_set_floatspan(s1: 'const Span *', s2: 'Span *') -> None: + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('Span *', s2) _lib.intspan_set_floatspan(s1_converted, s2_converted) _check_error() -def numset_shift_scale( - s: "const Set *", shift: "Datum", width: "Datum", hasshift: bool, haswidth: bool -) -> "Set *": - s_converted = _ffi.cast("const Set *", s) - shift_converted = _ffi.cast("Datum", shift) - width_converted = _ffi.cast("Datum", width) - result = _lib.numset_shift_scale( - s_converted, shift_converted, width_converted, hasshift, haswidth - ) +def numset_shift_scale(s: 'const Set *', shift: 'Datum', width: 'Datum', hasshift: bool, haswidth: bool) -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + shift_converted = _ffi.cast('Datum', shift) + width_converted = _ffi.cast('Datum', width) + result = _lib.numset_shift_scale(s_converted, shift_converted, width_converted, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def numspan_set_floatspan(s1: "const Span *", s2: "Span *") -> None: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("Span *", s2) +def numspan_set_floatspan(s1: 'const Span *', s2: 'Span *') -> None: + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('Span *', s2) _lib.numspan_set_floatspan(s1_converted, s2_converted) _check_error() -def numspan_shift_scale( - s: "const Span *", shift: "Datum", width: "Datum", hasshift: bool, haswidth: bool -) -> "Span *": - s_converted = _ffi.cast("const Span *", s) - shift_converted = _ffi.cast("Datum", shift) - width_converted = _ffi.cast("Datum", width) - result = _lib.numspan_shift_scale( - s_converted, shift_converted, width_converted, hasshift, haswidth - ) +def numspan_shift_scale(s: 'const Span *', shift: 'Datum', width: 'Datum', hasshift: bool, haswidth: bool) -> 'Span *': + s_converted = _ffi.cast('const Span *', s) + shift_converted = _ffi.cast('Datum', shift) + width_converted = _ffi.cast('Datum', width) + result = _lib.numspan_shift_scale(s_converted, shift_converted, width_converted, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def numspanset_shift_scale( - ss: "const SpanSet *", - shift: "Datum", - width: "Datum", - hasshift: bool, - haswidth: bool, -) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - shift_converted = _ffi.cast("Datum", shift) - width_converted = _ffi.cast("Datum", width) - result = _lib.numspanset_shift_scale( - ss_converted, shift_converted, width_converted, hasshift, haswidth - ) +def numspanset_shift_scale(ss: 'const SpanSet *', shift: 'Datum', width: 'Datum', hasshift: bool, haswidth: bool) -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + shift_converted = _ffi.cast('Datum', shift) + width_converted = _ffi.cast('Datum', width) + result = _lib.numspanset_shift_scale(ss_converted, shift_converted, width_converted, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def set_compact(s: "const Set *") -> "Set *": - s_converted = _ffi.cast("const Set *", s) +def set_compact(s: 'const Set *') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) result = _lib.set_compact(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_expand(s1: "const Span *", s2: "Span *") -> None: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("Span *", s2) +def span_expand(s1: 'const Span *', s2: 'Span *') -> None: + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('Span *', s2) _lib.span_expand(s1_converted, s2_converted) _check_error() -def spanset_compact(ss: "SpanSet *") -> "SpanSet *": - ss_converted = _ffi.cast("SpanSet *", ss) +def spanset_compact(ss: 'SpanSet *') -> 'SpanSet *': + ss_converted = _ffi.cast('SpanSet *', ss) result = _lib.spanset_compact(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_set_datespan(s1: "const Span *", s2: "Span *") -> None: - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("Span *", s2) +def tstzspan_set_datespan(s1: 'const Span *', s2: 'Span *') -> None: + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('Span *', s2) _lib.tstzspan_set_datespan(s1_converted, s2_converted) _check_error() -def set_cmp1(s1: "const Set *", s2: "const Set *") -> "int": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_cmp1(s1: 'const Set *', s2: 'const Set *') -> 'int': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.set_cmp1(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def set_eq1(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def set_eq1(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.set_eq1(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def span_cmp1(s1: "const Span *", s2: "const Span *") -> "int": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_cmp1(s1: 'const Span *', s2: 'const Span *') -> 'int': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.span_cmp1(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def span_eq1(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def span_eq1(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.span_eq1(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_cmp1(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "int": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_cmp1(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'int': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.spanset_cmp1(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_eq1(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": - ss1_converted = _ffi.cast("const SpanSet *", ss1) - ss2_converted = _ffi.cast("const SpanSet *", ss2) +def spanset_eq1(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': + ss1_converted = _ffi.cast('const SpanSet *', ss1) + ss2_converted = _ffi.cast('const SpanSet *', ss2) result = _lib.spanset_eq1(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def spanbase_extent_transfn(s: "Span *", d: "Datum", basetype: "meosType") -> "Span *": - s_converted = _ffi.cast("Span *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def spanbase_extent_transfn(s: 'Span *', d: 'Datum', basetype: 'meosType') -> 'Span *': + s_converted = _ffi.cast('Span *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.spanbase_extent_transfn(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def value_union_transfn(state: "Set *", d: "Datum", basetype: "meosType") -> "Set *": - state_converted = _ffi.cast("Set *", state) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def value_union_transfn(state: 'Set *', d: 'Datum', basetype: 'meosType') -> 'Set *': + state_converted = _ffi.cast('Set *', state) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.value_union_transfn(state_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def adj_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def adj_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.adj_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_value(s: "const Span *", d: "Datum", basetype: "meosType") -> "bool": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def adjacent_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.adjacent_span_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_value( - ss: "const SpanSet *", d: "Datum", basetype: "meosType" -) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def adjacent_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.adjacent_spanset_value(ss_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def cont_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def cont_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.cont_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_value(s: "const Span *", d: "Datum", basetype: "meosType") -> "bool": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def contains_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.contains_span_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_value( - ss: "const SpanSet *", d: "Datum", basetype: "meosType" -) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def contains_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.contains_spanset_value(ss_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_value(s: "const Set *", d: "Datum", basetype: "meosType") -> "bool": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def contains_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'bool': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.contains_set_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def contains_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.contains_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_value_span(d: "Datum", basetype: "meosType", s: "const Span *") -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Span *", s) +def contained_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Span *', s) result = _lib.contained_value_span(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_value_set(d: "Datum", basetype: "meosType", s: "const Set *") -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Set *", s) +def contained_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Set *', s) result = _lib.contained_value_set(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def contained_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.contained_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_value_spanset( - d: "Datum", basetype: "meosType", ss: "const SpanSet *" -) -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - ss_converted = _ffi.cast("const SpanSet *", ss) +def contained_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.contained_value_spanset(d_converted, basetype_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def over_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def over_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.over_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def over_adj_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def over_adj_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.over_adj_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_value_span(d: "Datum", basetype: "meosType", s: "const Span *") -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Span *", s) +def overlaps_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Span *', s) result = _lib.overlaps_value_span(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_value_spanset( - d: "Datum", basetype: "meosType", ss: "const SpanSet *" -) -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overlaps_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overlaps_value_spanset(d_converted, basetype_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_span_value(s: "const Span *", d: "Datum", basetype: "meosType") -> "bool": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def overlaps_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.overlaps_span_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_spanset_value( - ss: "const SpanSet *", d: "Datum", basetype: "meosType" -) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def overlaps_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.overlaps_spanset_value(ss_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def overlaps_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.overlaps_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def left_notadj_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def left_notadj_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.left_notadj_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def left_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def left_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.left_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def left_set_value(s: "const Set *", d: "Datum", basetype: "meosType") -> "bool": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def left_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'bool': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.left_set_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def left_span_value(s: "const Span *", d: "Datum", basetype: "meosType") -> "bool": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def left_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.left_span_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def left_spanset_value( - ss: "const SpanSet *", d: "Datum", basetype: "meosType" -) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def left_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.left_spanset_value(ss_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def left_value_set(d: "Datum", basetype: "meosType", s: "const Set *") -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Set *", s) +def left_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Set *', s) result = _lib.left_value_set(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_value_span(d: "Datum", basetype: "meosType", s: "const Span *") -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Span *", s) +def left_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Span *', s) result = _lib.left_value_span(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_value_spanset( - d: "Datum", basetype: "meosType", ss: "const SpanSet *" -) -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - ss_converted = _ffi.cast("const SpanSet *", ss) +def left_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.left_value_spanset(d_converted, basetype_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def lf_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def lf_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.lf_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def ri_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def ri_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.ri_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def right_value_set(d: "Datum", basetype: "meosType", s: "const Set *") -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Set *", s) +def right_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Set *', s) result = _lib.right_value_set(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_set_value(s: "const Set *", d: "Datum", basetype: "meosType") -> "bool": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def right_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'bool': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.right_set_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def right_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def right_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.right_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def right_value_span(d: "Datum", basetype: "meosType", s: "const Span *") -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Span *", s) +def right_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Span *', s) result = _lib.right_value_span(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_value_spanset( - d: "Datum", basetype: "meosType", ss: "const SpanSet *" -) -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - ss_converted = _ffi.cast("const SpanSet *", ss) +def right_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.right_value_spanset(d_converted, basetype_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def right_span_value(s: "const Span *", d: "Datum", basetype: "meosType") -> "bool": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def right_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.right_span_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def right_spanset_value( - ss: "const SpanSet *", d: "Datum", basetype: "meosType" -) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def right_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.right_spanset_value(ss_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_value_set(d: "Datum", basetype: "meosType", s: "const Set *") -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Set *", s) +def overleft_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Set *', s) result = _lib.overleft_value_set(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_set_value(s: "const Set *", d: "Datum", basetype: "meosType") -> "bool": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def overleft_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'bool': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.overleft_set_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def overleft_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.overleft_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_value_span(d: "Datum", basetype: "meosType", s: "const Span *") -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Span *", s) +def overleft_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Span *', s) result = _lib.overleft_value_span(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_value_spanset( - d: "Datum", basetype: "meosType", ss: "const SpanSet *" -) -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overleft_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overleft_value_spanset(d_converted, basetype_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_span_value(s: "const Span *", d: "Datum", basetype: "meosType") -> "bool": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def overleft_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.overleft_span_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_spanset_value( - ss: "const SpanSet *", d: "Datum", basetype: "meosType" -) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def overleft_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.overleft_spanset_value(ss_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def overright_value_set(d: "Datum", basetype: "meosType", s: "const Set *") -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Set *", s) +def overright_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Set *', s) result = _lib.overright_value_set(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_set_value(s: "const Set *", d: "Datum", basetype: "meosType") -> "bool": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def overright_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'bool': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.overright_set_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def overright_set_set(s1: "const Set *", s2: "const Set *") -> "bool": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def overright_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.overright_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_value_span(d: "Datum", basetype: "meosType", s: "const Span *") -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Span *", s) +def overright_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Span *', s) result = _lib.overright_value_span(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_value_spanset( - d: "Datum", basetype: "meosType", ss: "const SpanSet *" -) -> "bool": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - ss_converted = _ffi.cast("const SpanSet *", ss) +def overright_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'bool': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.overright_value_spanset(d_converted, basetype_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overright_span_value(s: "const Span *", d: "Datum", basetype: "meosType") -> "bool": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def overright_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.overright_span_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def overright_spanset_value( - ss: "const SpanSet *", d: "Datum", basetype: "meosType" -) -> "bool": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def overright_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.overright_spanset_value(ss_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def ovlf_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def ovlf_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.ovlf_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def ovri_span_span(s1: "const Span *", s2: "const Span *") -> "bool": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def ovri_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.ovri_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def inter_span_span(s1: "const Span *", s2: "const Span *") -> "Span *": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) - out_result = _ffi.new("Span *") +def inter_span_span(s1: 'const Span *', s2: 'const Span *') -> 'Span *': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) + out_result = _ffi.new('Span *') result = _lib.inter_span_span(s1_converted, s2_converted, out_result) _check_error() if result: @@ -12482,481 +11678,412 @@ def inter_span_span(s1: "const Span *", s2: "const Span *") -> "Span *": return None -def intersection_set_value( - s: "const Set *", d: "Datum", basetype: "meosType" -) -> "Set *": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def intersection_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.intersection_set_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_span_value( - s: "const Span *", d: "Datum", basetype: "meosType" -) -> "Span *": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def intersection_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'Span *': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.intersection_span_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_value( - ss: "const SpanSet *", d: "Datum", basetype: "meosType" -) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - result = _lib.intersection_spanset_value( - ss_converted, d_converted, basetype_converted - ) +def intersection_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + result = _lib.intersection_spanset_value(ss_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_value(s: "const Set *", d: "Datum", basetype: "meosType") -> "Set *": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def minus_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.minus_set_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_value( - s: "const Span *", d: "Datum", basetype: "meosType" -) -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def minus_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.minus_span_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_value( - ss: "const SpanSet *", d: "Datum", basetype: "meosType" -) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def minus_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.minus_spanset_value(ss_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def minus_value_set(d: "Datum", basetype: "meosType", s: "const Set *") -> "Set *": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Set *", s) +def minus_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'Set *': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Set *', s) result = _lib.minus_value_set(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_value_span( - d: "Datum", basetype: "meosType", s: "const Span *" -) -> "SpanSet *": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Span *", s) +def minus_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'SpanSet *': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Span *', s) result = _lib.minus_value_span(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_value_spanset( - d: "Datum", basetype: "meosType", ss: "const SpanSet *" -) -> "SpanSet *": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - ss_converted = _ffi.cast("const SpanSet *", ss) +def minus_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'SpanSet *': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.minus_value_spanset(d_converted, basetype_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_value( - s: "const Set *", d: "const Datum", basetype: "meosType" -) -> "Set *": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("const Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def union_set_value(s: 'const Set *', d: 'const Datum', basetype: 'meosType') -> 'Set *': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('const Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.union_set_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_value( - s: "const Span *", v: "Datum", basetype: "meosType" -) -> "SpanSet *": - s_converted = _ffi.cast("const Span *", s) - v_converted = _ffi.cast("Datum", v) - basetype_converted = _ffi.cast("meosType", basetype) +def union_span_value(s: 'const Span *', v: 'Datum', basetype: 'meosType') -> 'SpanSet *': + s_converted = _ffi.cast('const Span *', s) + v_converted = _ffi.cast('Datum', v) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.union_span_value(s_converted, v_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_value( - ss: "const SpanSet *", d: "Datum", basetype: "meosType" -) -> "SpanSet *": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def union_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'SpanSet *': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.union_spanset_value(ss_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def dist_set_set(s1: "const Set *", s2: "const Set *") -> "double": - s1_converted = _ffi.cast("const Set *", s1) - s2_converted = _ffi.cast("const Set *", s2) +def dist_set_set(s1: 'const Set *', s2: 'const Set *') -> 'double': + s1_converted = _ffi.cast('const Set *', s1) + s2_converted = _ffi.cast('const Set *', s2) result = _lib.dist_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def dist_span_span(s1: "const Span *", s2: "const Span *") -> "double": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) +def dist_span_span(s1: 'const Span *', s2: 'const Span *') -> 'double': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) result = _lib.dist_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def distance_value_value(l: "Datum", r: "Datum", basetype: "meosType") -> "double": - l_converted = _ffi.cast("Datum", l) - r_converted = _ffi.cast("Datum", r) - basetype_converted = _ffi.cast("meosType", basetype) +def distance_value_value(l: 'Datum', r: 'Datum', basetype: 'meosType') -> 'double': + l_converted = _ffi.cast('Datum', l) + r_converted = _ffi.cast('Datum', r) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.distance_value_value(l_converted, r_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def distance_span_value( - s: "const Span *", d: "Datum", basetype: "meosType" -) -> "double": - s_converted = _ffi.cast("const Span *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def distance_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'double': + s_converted = _ffi.cast('const Span *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.distance_span_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_value( - ss: "const SpanSet *", d: "Datum", basetype: "meosType" -) -> "double": - ss_converted = _ffi.cast("const SpanSet *", ss) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def distance_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'double': + ss_converted = _ffi.cast('const SpanSet *', ss) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.distance_spanset_value(ss_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def distance_value_set(d: "Datum", basetype: "meosType", s: "const Set *") -> "double": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Set *", s) +def distance_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'double': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Set *', s) result = _lib.distance_value_set(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def distance_set_value(s: "const Set *", d: "Datum", basetype: "meosType") -> "double": - s_converted = _ffi.cast("const Set *", s) - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def distance_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'double': + s_converted = _ffi.cast('const Set *', s) + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.distance_set_value(s_converted, d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def datum_hash(d: "Datum", basetype: "meosType") -> "uint32": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) +def datum_hash(d: 'Datum', basetype: 'meosType') -> 'uint32': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.datum_hash(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def datum_hash_extended(d: "Datum", basetype: "meosType", seed: int) -> "uint64": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - seed_converted = _ffi.cast("uint64", seed) +def datum_hash_extended(d: 'Datum', basetype: 'meosType', seed: int) -> 'uint64': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + seed_converted = _ffi.cast('uint64', seed) result = _lib.datum_hash_extended(d_converted, basetype_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def number_tstzspan_to_tbox( - d: "Datum", basetype: "meosType", s: "const Span *" -) -> "TBox *": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - s_converted = _ffi.cast("const Span *", s) +def number_tstzspan_to_tbox(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'TBox *': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + s_converted = _ffi.cast('const Span *', s) result = _lib.number_tstzspan_to_tbox(d_converted, basetype_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def number_timestamptz_to_tbox(d: "Datum", basetype: "meosType", t: int) -> "TBox *": - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - t_converted = _ffi.cast("TimestampTz", t) - result = _lib.number_timestamptz_to_tbox( - d_converted, basetype_converted, t_converted - ) +def number_timestamptz_to_tbox(d: 'Datum', basetype: 'meosType', t: int) -> 'TBox *': + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + t_converted = _ffi.cast('TimestampTz', t) + result = _lib.number_timestamptz_to_tbox(d_converted, basetype_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_cp(box: "const STBox *") -> "STBox *": - box_converted = _ffi.cast("const STBox *", box) +def stbox_cp(box: 'const STBox *') -> 'STBox *': + box_converted = _ffi.cast('const STBox *', box) result = _lib.stbox_cp(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_set( - hasx: bool, - hasz: bool, - geodetic: bool, - srid: int, - xmin: float, - xmax: float, - ymin: float, - ymax: float, - zmin: float, - zmax: float, - s: "const Span *", - box: "STBox *", -) -> None: - srid_converted = _ffi.cast("int32", srid) - s_converted = _ffi.cast("const Span *", s) - box_converted = _ffi.cast("STBox *", box) - _lib.stbox_set( - hasx, - hasz, - geodetic, - srid_converted, - xmin, - xmax, - ymin, - ymax, - zmin, - zmax, - s_converted, - box_converted, - ) +def stbox_set(hasx: bool, hasz: bool, geodetic: bool, srid: int, xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float, s: 'const Span *', box: 'STBox *') -> None: + srid_converted = _ffi.cast('int32', srid) + s_converted = _ffi.cast('const Span *', s) + box_converted = _ffi.cast('STBox *', box) + _lib.stbox_set(hasx, hasz, geodetic, srid_converted, xmin, xmax, ymin, ymax, zmin, zmax, s_converted, box_converted) _check_error() -def tbox_cp(box: "const TBox *") -> "TBox *": - box_converted = _ffi.cast("const TBox *", box) +def tbox_cp(box: 'const TBox *') -> 'TBox *': + box_converted = _ffi.cast('const TBox *', box) result = _lib.tbox_cp(box_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_set(s: "const Span *", p: "const Span *", box: "TBox *") -> None: - s_converted = _ffi.cast("const Span *", s) - p_converted = _ffi.cast("const Span *", p) - box_converted = _ffi.cast("TBox *", box) +def tbox_set(s: 'const Span *', p: 'const Span *', box: 'TBox *') -> None: + s_converted = _ffi.cast('const Span *', s) + p_converted = _ffi.cast('const Span *', p) + box_converted = _ffi.cast('TBox *', box) _lib.tbox_set(s_converted, p_converted, box_converted) _check_error() -def float_set_tbox(d: float, box: "TBox *") -> None: - box_converted = _ffi.cast("TBox *", box) +def float_set_tbox(d: float, box: 'TBox *') -> None: + box_converted = _ffi.cast('TBox *', box) _lib.float_set_tbox(d, box_converted) _check_error() -def geo_set_stbox(gs: "const GSERIALIZED *", box: "STBox *") -> "bool": - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - box_converted = _ffi.cast("STBox *", box) +def geo_set_stbox(gs: 'const GSERIALIZED *', box: 'STBox *') -> 'bool': + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + box_converted = _ffi.cast('STBox *', box) result = _lib.geo_set_stbox(gs_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def geoarr_set_stbox(values: "const Datum *", count: int, box: "STBox *") -> None: - values_converted = _ffi.cast("const Datum *", values) - box_converted = _ffi.cast("STBox *", box) +def geoarr_set_stbox(values: 'const Datum *', count: int, box: 'STBox *') -> None: + values_converted = _ffi.cast('const Datum *', values) + box_converted = _ffi.cast('STBox *', box) _lib.geoarr_set_stbox(values_converted, count, box_converted) _check_error() -def int_set_tbox(i: int, box: "TBox *") -> None: - box_converted = _ffi.cast("TBox *", box) +def int_set_tbox(i: int, box: 'TBox *') -> None: + box_converted = _ffi.cast('TBox *', box) _lib.int_set_tbox(i, box_converted) _check_error() -def number_set_tbox(d: "Datum", basetype: "meosType", box: "TBox *") -> None: - d_converted = _ffi.cast("Datum", d) - basetype_converted = _ffi.cast("meosType", basetype) - box_converted = _ffi.cast("TBox *", box) +def number_set_tbox(d: 'Datum', basetype: 'meosType', box: 'TBox *') -> None: + d_converted = _ffi.cast('Datum', d) + basetype_converted = _ffi.cast('meosType', basetype) + box_converted = _ffi.cast('TBox *', box) _lib.number_set_tbox(d_converted, basetype_converted, box_converted) _check_error() -def number_to_tbox(value: "Datum", basetype: "meosType") -> "TBox *": - value_converted = _ffi.cast("Datum", value) - basetype_converted = _ffi.cast("meosType", basetype) +def number_to_tbox(value: 'Datum', basetype: 'meosType') -> 'TBox *': + value_converted = _ffi.cast('Datum', value) + basetype_converted = _ffi.cast('meosType', basetype) result = _lib.number_to_tbox(value_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def numset_set_tbox(s: "const Set *", box: "TBox *") -> None: - s_converted = _ffi.cast("const Set *", s) - box_converted = _ffi.cast("TBox *", box) +def numset_set_tbox(s: 'const Set *', box: 'TBox *') -> None: + s_converted = _ffi.cast('const Set *', s) + box_converted = _ffi.cast('TBox *', box) _lib.numset_set_tbox(s_converted, box_converted) _check_error() -def numspan_set_tbox(span: "const Span *", box: "TBox *") -> None: - span_converted = _ffi.cast("const Span *", span) - box_converted = _ffi.cast("TBox *", box) +def numspan_set_tbox(span: 'const Span *', box: 'TBox *') -> None: + span_converted = _ffi.cast('const Span *', span) + box_converted = _ffi.cast('TBox *', box) _lib.numspan_set_tbox(span_converted, box_converted) _check_error() -def numspanset_set_tbox(ss: "const SpanSet *", box: "TBox *") -> None: - ss_converted = _ffi.cast("const SpanSet *", ss) - box_converted = _ffi.cast("TBox *", box) +def numspanset_set_tbox(ss: 'const SpanSet *', box: 'TBox *') -> None: + ss_converted = _ffi.cast('const SpanSet *', ss) + box_converted = _ffi.cast('TBox *', box) _lib.numspanset_set_tbox(ss_converted, box_converted) _check_error() -def tstzspan_set_stbox(s: "const Span *", box: "STBox *") -> None: - s_converted = _ffi.cast("const Span *", s) - box_converted = _ffi.cast("STBox *", box) +def tstzspan_set_stbox(s: 'const Span *', box: 'STBox *') -> None: + s_converted = _ffi.cast('const Span *', s) + box_converted = _ffi.cast('STBox *', box) _lib.tstzspan_set_stbox(s_converted, box_converted) _check_error() -def tstzspan_set_tbox(s: "const Span *", box: "TBox *") -> None: - s_converted = _ffi.cast("const Span *", s) - box_converted = _ffi.cast("TBox *", box) +def tstzspan_set_tbox(s: 'const Span *', box: 'TBox *') -> None: + s_converted = _ffi.cast('const Span *', s) + box_converted = _ffi.cast('TBox *', box) _lib.tstzspan_set_tbox(s_converted, box_converted) _check_error() -def tstzspanset_set_stbox(ss: "const SpanSet *", box: "STBox *") -> None: - ss_converted = _ffi.cast("const SpanSet *", ss) - box_converted = _ffi.cast("STBox *", box) +def tstzspanset_set_stbox(ss: 'const SpanSet *', box: 'STBox *') -> None: + ss_converted = _ffi.cast('const SpanSet *', ss) + box_converted = _ffi.cast('STBox *', box) _lib.tstzspanset_set_stbox(ss_converted, box_converted) _check_error() -def tstzspanset_set_tbox(ss: "const SpanSet *", box: "TBox *") -> None: - ss_converted = _ffi.cast("const SpanSet *", ss) - box_converted = _ffi.cast("TBox *", box) +def tstzspanset_set_tbox(ss: 'const SpanSet *', box: 'TBox *') -> None: + ss_converted = _ffi.cast('const SpanSet *', ss) + box_converted = _ffi.cast('TBox *', box) _lib.tstzspanset_set_tbox(ss_converted, box_converted) _check_error() -def stbox_set_box3d(box: "const STBox *", box3d: "BOX3D *") -> None: - box_converted = _ffi.cast("const STBox *", box) - box3d_converted = _ffi.cast("BOX3D *", box3d) +def stbox_set_box3d(box: 'const STBox *', box3d: 'BOX3D *') -> None: + box_converted = _ffi.cast('const STBox *', box) + box3d_converted = _ffi.cast('BOX3D *', box3d) _lib.stbox_set_box3d(box_converted, box3d_converted) _check_error() -def stbox_set_gbox(box: "const STBox *", gbox: "GBOX *") -> None: - box_converted = _ffi.cast("const STBox *", box) - gbox_converted = _ffi.cast("GBOX *", gbox) +def stbox_set_gbox(box: 'const STBox *', gbox: 'GBOX *') -> None: + box_converted = _ffi.cast('const STBox *', box) + gbox_converted = _ffi.cast('GBOX *', gbox) _lib.stbox_set_gbox(box_converted, gbox_converted) _check_error() -def timestamptz_set_stbox(t: int, box: "STBox *") -> None: - t_converted = _ffi.cast("TimestampTz", t) - box_converted = _ffi.cast("STBox *", box) +def timestamptz_set_stbox(t: int, box: 'STBox *') -> None: + t_converted = _ffi.cast('TimestampTz', t) + box_converted = _ffi.cast('STBox *', box) _lib.timestamptz_set_stbox(t_converted, box_converted) _check_error() -def timestamptz_set_tbox(t: int, box: "TBox *") -> None: - t_converted = _ffi.cast("TimestampTz", t) - box_converted = _ffi.cast("TBox *", box) +def timestamptz_set_tbox(t: int, box: 'TBox *') -> None: + t_converted = _ffi.cast('TimestampTz', t) + box_converted = _ffi.cast('TBox *', box) _lib.timestamptz_set_tbox(t_converted, box_converted) _check_error() -def tstzset_set_stbox(s: "const Set *", box: "STBox *") -> None: - s_converted = _ffi.cast("const Set *", s) - box_converted = _ffi.cast("STBox *", box) +def tstzset_set_stbox(s: 'const Set *', box: 'STBox *') -> None: + s_converted = _ffi.cast('const Set *', s) + box_converted = _ffi.cast('STBox *', box) _lib.tstzset_set_stbox(s_converted, box_converted) _check_error() -def tstzset_set_tbox(s: "const Set *", box: "TBox *") -> None: - s_converted = _ffi.cast("const Set *", s) - box_converted = _ffi.cast("TBox *", box) +def tstzset_set_tbox(s: 'const Set *', box: 'TBox *') -> None: + s_converted = _ffi.cast('const Set *', s) + box_converted = _ffi.cast('TBox *', box) _lib.tstzset_set_tbox(s_converted, box_converted) _check_error() -def tbox_shift_scale_value( - box: "const TBox *", - shift: "Datum", - width: "Datum", - basetype: "meosType", - hasshift: bool, - haswidth: bool, -) -> "TBox *": - box_converted = _ffi.cast("const TBox *", box) - shift_converted = _ffi.cast("Datum", shift) - width_converted = _ffi.cast("Datum", width) - basetype_converted = _ffi.cast("meosType", basetype) - result = _lib.tbox_shift_scale_value( - box_converted, - shift_converted, - width_converted, - basetype_converted, - hasshift, - haswidth, - ) +def tbox_shift_scale_value(box: 'const TBox *', shift: 'Datum', width: 'Datum', basetype: 'meosType', hasshift: bool, haswidth: bool) -> 'TBox *': + box_converted = _ffi.cast('const TBox *', box) + shift_converted = _ffi.cast('Datum', shift) + width_converted = _ffi.cast('Datum', width) + basetype_converted = _ffi.cast('meosType', basetype) + result = _lib.tbox_shift_scale_value(box_converted, shift_converted, width_converted, basetype_converted, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def stbox_expand(box1: "const STBox *", box2: "STBox *") -> None: - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("STBox *", box2) +def stbox_expand(box1: 'const STBox *', box2: 'STBox *') -> None: + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('STBox *', box2) _lib.stbox_expand(box1_converted, box2_converted) _check_error() -def tbox_expand(box1: "const TBox *", box2: "TBox *") -> None: - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("TBox *", box2) +def tbox_expand(box1: 'const TBox *', box2: 'TBox *') -> None: + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('TBox *', box2) _lib.tbox_expand(box1_converted, box2_converted) _check_error() -def bbox_union_span_span(s1: "const Span *", s2: "const Span *") -> "Span *": - s1_converted = _ffi.cast("const Span *", s1) - s2_converted = _ffi.cast("const Span *", s2) - out_result = _ffi.new("Span *") +def bbox_union_span_span(s1: 'const Span *', s2: 'const Span *') -> 'Span *': + s1_converted = _ffi.cast('const Span *', s1) + s2_converted = _ffi.cast('const Span *', s2) + out_result = _ffi.new('Span *') _lib.bbox_union_span_span(s1_converted, s2_converted, out_result) _check_error() - return out_result if out_result != _ffi.NULL else None + return out_result if out_result!= _ffi.NULL else None + -def inter_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "STBox *": - box1_converted = _ffi.cast("const STBox *", box1) - box2_converted = _ffi.cast("const STBox *", box2) - out_result = _ffi.new("STBox *") +def inter_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'STBox *': + box1_converted = _ffi.cast('const STBox *', box1) + box2_converted = _ffi.cast('const STBox *', box2) + out_result = _ffi.new('STBox *') result = _lib.inter_stbox_stbox(box1_converted, box2_converted, out_result) _check_error() if result: @@ -12964,10 +12091,10 @@ def inter_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "STBox *" return None -def inter_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "TBox *": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) - out_result = _ffi.new("TBox *") +def inter_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'TBox *': + box1_converted = _ffi.cast('const TBox *', box1) + box2_converted = _ffi.cast('const TBox *', box2) + out_result = _ffi.new('TBox *') result = _lib.inter_tbox_tbox(box1_converted, box2_converted, out_result) _check_error() if result: @@ -12975,1059 +12102,914 @@ def inter_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "TBox *": return None -def geoarr_as_text( - geoarr: "const Datum *", count: int, maxdd: int, extended: bool -) -> "char **": - geoarr_converted = _ffi.cast("const Datum *", geoarr) +def geoarr_as_text(geoarr: 'const Datum *', count: int, maxdd: int, extended: bool) -> 'char **': + geoarr_converted = _ffi.cast('const Datum *', geoarr) result = _lib.geoarr_as_text(geoarr_converted, count, maxdd, extended) _check_error() return result if result != _ffi.NULL else None -def tboolinst_as_mfjson(inst: "const TInstant *", with_bbox: bool) -> str: - inst_converted = _ffi.cast("const TInstant *", inst) +def tboolinst_as_mfjson(inst: 'const TInstant *', with_bbox: bool) -> str: + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tboolinst_as_mfjson(inst_converted, with_bbox) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tboolinst_from_mfjson(mfjson: "json_object *") -> "TInstant *": - mfjson_converted = _ffi.cast("json_object *", mfjson) +def tboolinst_from_mfjson(mfjson: 'json_object *') -> 'TInstant *': + mfjson_converted = _ffi.cast('json_object *', mfjson) result = _lib.tboolinst_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tboolinst_in(string: str) -> "TInstant *": - string_converted = string.encode("utf-8") +def tboolinst_in(string: str) -> 'TInstant *': + string_converted = string.encode('utf-8') result = _lib.tboolinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseq_as_mfjson(seq: "const TSequence *", with_bbox: bool) -> str: - seq_converted = _ffi.cast("const TSequence *", seq) +def tboolseq_as_mfjson(seq: 'const TSequence *', with_bbox: bool) -> str: + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tboolseq_as_mfjson(seq_converted, with_bbox) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tboolseq_from_mfjson(mfjson: "json_object *") -> "TSequence *": - mfjson_converted = _ffi.cast("json_object *", mfjson) +def tboolseq_from_mfjson(mfjson: 'json_object *') -> 'TSequence *': + mfjson_converted = _ffi.cast('json_object *', mfjson) result = _lib.tboolseq_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseq_in(string: str, interp: "interpType") -> "TSequence *": - string_converted = string.encode("utf-8") - interp_converted = _ffi.cast("interpType", interp) +def tboolseq_in(string: str, interp: 'interpType') -> 'TSequence *': + string_converted = string.encode('utf-8') + interp_converted = _ffi.cast('interpType', interp) result = _lib.tboolseq_in(string_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseqset_as_mfjson(ss: "const TSequenceSet *", with_bbox: bool) -> str: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tboolseqset_as_mfjson(ss: 'const TSequenceSet *', with_bbox: bool) -> str: + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tboolseqset_as_mfjson(ss_converted, with_bbox) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tboolseqset_from_mfjson(mfjson: "json_object *") -> "TSequenceSet *": - mfjson_converted = _ffi.cast("json_object *", mfjson) +def tboolseqset_from_mfjson(mfjson: 'json_object *') -> 'TSequenceSet *': + mfjson_converted = _ffi.cast('json_object *', mfjson) result = _lib.tboolseqset_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseqset_in(string: str) -> "TSequenceSet *": - string_converted = string.encode("utf-8") +def tboolseqset_in(string: str) -> 'TSequenceSet *': + string_converted = string.encode('utf-8') result = _lib.tboolseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_in(string: str, temptype: "meosType") -> "Temporal *": - string_converted = string.encode("utf-8") - temptype_converted = _ffi.cast("meosType", temptype) +def temporal_in(string: str, temptype: 'meosType') -> 'Temporal *': + string_converted = string.encode('utf-8') + temptype_converted = _ffi.cast('meosType', temptype) result = _lib.temporal_in(string_converted, temptype_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_out(temp: "const Temporal *", maxdd: int) -> str: - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_out(temp: 'const Temporal *', maxdd: int) -> str: + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_out(temp_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def temporal_values(temp: "const Temporal *") -> "Tuple['Datum *', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - count = _ffi.new("int *") +def temporal_values(temp: 'const Temporal *') -> "Tuple['Datum *', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + count = _ffi.new('int *') result = _lib.temporal_values(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporalarr_out(temparr: "const Temporal **", count: int, maxdd: int) -> "char **": - temparr_converted = [_ffi.cast("const Temporal *", x) for x in temparr] +def temporalarr_out(temparr: 'const Temporal **', count: int, maxdd: int) -> 'char **': + temparr_converted = [_ffi.cast('const Temporal *', x) for x in temparr] result = _lib.temporalarr_out(temparr_converted, count, maxdd) _check_error() return result if result != _ffi.NULL else None -def tfloatinst_as_mfjson( - inst: "const TInstant *", with_bbox: bool, precision: int -) -> str: - inst_converted = _ffi.cast("const TInstant *", inst) +def tfloatinst_as_mfjson(inst: 'const TInstant *', with_bbox: bool, precision: int) -> str: + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tfloatinst_as_mfjson(inst_converted, with_bbox, precision) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tfloatinst_from_mfjson(mfjson: "json_object *") -> "TInstant *": - mfjson_converted = _ffi.cast("json_object *", mfjson) +def tfloatinst_from_mfjson(mfjson: 'json_object *') -> 'TInstant *': + mfjson_converted = _ffi.cast('json_object *', mfjson) result = _lib.tfloatinst_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatinst_in(string: str) -> "TInstant *": - string_converted = string.encode("utf-8") +def tfloatinst_in(string: str) -> 'TInstant *': + string_converted = string.encode('utf-8') result = _lib.tfloatinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseq_as_mfjson( - seq: "const TSequence *", with_bbox: bool, precision: int -) -> str: - seq_converted = _ffi.cast("const TSequence *", seq) +def tfloatseq_as_mfjson(seq: 'const TSequence *', with_bbox: bool, precision: int) -> str: + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tfloatseq_as_mfjson(seq_converted, with_bbox, precision) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tfloatseq_from_mfjson( - mfjson: "json_object *", interp: "interpType" -) -> "TSequence *": - mfjson_converted = _ffi.cast("json_object *", mfjson) - interp_converted = _ffi.cast("interpType", interp) +def tfloatseq_from_mfjson(mfjson: 'json_object *', interp: 'interpType') -> 'TSequence *': + mfjson_converted = _ffi.cast('json_object *', mfjson) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tfloatseq_from_mfjson(mfjson_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseq_in(string: str, interp: "interpType") -> "TSequence *": - string_converted = string.encode("utf-8") - interp_converted = _ffi.cast("interpType", interp) +def tfloatseq_in(string: str, interp: 'interpType') -> 'TSequence *': + string_converted = string.encode('utf-8') + interp_converted = _ffi.cast('interpType', interp) result = _lib.tfloatseq_in(string_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseqset_as_mfjson( - ss: "const TSequenceSet *", with_bbox: bool, precision: int -) -> str: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tfloatseqset_as_mfjson(ss: 'const TSequenceSet *', with_bbox: bool, precision: int) -> str: + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tfloatseqset_as_mfjson(ss_converted, with_bbox, precision) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tfloatseqset_from_mfjson( - mfjson: "json_object *", interp: "interpType" -) -> "TSequenceSet *": - mfjson_converted = _ffi.cast("json_object *", mfjson) - interp_converted = _ffi.cast("interpType", interp) +def tfloatseqset_from_mfjson(mfjson: 'json_object *', interp: 'interpType') -> 'TSequenceSet *': + mfjson_converted = _ffi.cast('json_object *', mfjson) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tfloatseqset_from_mfjson(mfjson_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseqset_in(string: str) -> "TSequenceSet *": - string_converted = string.encode("utf-8") +def tfloatseqset_in(string: str) -> 'TSequenceSet *': + string_converted = string.encode('utf-8') result = _lib.tfloatseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpointinst_from_mfjson(mfjson: "json_object *", srid: int) -> "TInstant *": - mfjson_converted = _ffi.cast("json_object *", mfjson) +def tgeogpointinst_from_mfjson(mfjson: 'json_object *', srid: int) -> 'TInstant *': + mfjson_converted = _ffi.cast('json_object *', mfjson) result = _lib.tgeogpointinst_from_mfjson(mfjson_converted, srid) _check_error() return result if result != _ffi.NULL else None -def tgeogpointinst_in(string: str) -> "TInstant *": - string_converted = string.encode("utf-8") +def tgeogpointinst_in(string: str) -> 'TInstant *': + string_converted = string.encode('utf-8') result = _lib.tgeogpointinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpointseq_from_mfjson( - mfjson: "json_object *", srid: int, interp: "interpType" -) -> "TSequence *": - mfjson_converted = _ffi.cast("json_object *", mfjson) - interp_converted = _ffi.cast("interpType", interp) +def tgeogpointseq_from_mfjson(mfjson: 'json_object *', srid: int, interp: 'interpType') -> 'TSequence *': + mfjson_converted = _ffi.cast('json_object *', mfjson) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tgeogpointseq_from_mfjson(mfjson_converted, srid, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpointseq_in(string: str, interp: "interpType") -> "TSequence *": - string_converted = string.encode("utf-8") - interp_converted = _ffi.cast("interpType", interp) +def tgeogpointseq_in(string: str, interp: 'interpType') -> 'TSequence *': + string_converted = string.encode('utf-8') + interp_converted = _ffi.cast('interpType', interp) result = _lib.tgeogpointseq_in(string_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpointseqset_from_mfjson( - mfjson: "json_object *", srid: int, interp: "interpType" -) -> "TSequenceSet *": - mfjson_converted = _ffi.cast("json_object *", mfjson) - interp_converted = _ffi.cast("interpType", interp) +def tgeogpointseqset_from_mfjson(mfjson: 'json_object *', srid: int, interp: 'interpType') -> 'TSequenceSet *': + mfjson_converted = _ffi.cast('json_object *', mfjson) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tgeogpointseqset_from_mfjson(mfjson_converted, srid, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpointseqset_in(string: str) -> "TSequenceSet *": - string_converted = string.encode("utf-8") +def tgeogpointseqset_in(string: str) -> 'TSequenceSet *': + string_converted = string.encode('utf-8') result = _lib.tgeogpointseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompointinst_from_mfjson(mfjson: "json_object *", srid: int) -> "TInstant *": - mfjson_converted = _ffi.cast("json_object *", mfjson) +def tgeompointinst_from_mfjson(mfjson: 'json_object *', srid: int) -> 'TInstant *': + mfjson_converted = _ffi.cast('json_object *', mfjson) result = _lib.tgeompointinst_from_mfjson(mfjson_converted, srid) _check_error() return result if result != _ffi.NULL else None -def tgeompointinst_in(string: str) -> "TInstant *": - string_converted = string.encode("utf-8") +def tgeompointinst_in(string: str) -> 'TInstant *': + string_converted = string.encode('utf-8') result = _lib.tgeompointinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompointseq_from_mfjson( - mfjson: "json_object *", srid: int, interp: "interpType" -) -> "TSequence *": - mfjson_converted = _ffi.cast("json_object *", mfjson) - interp_converted = _ffi.cast("interpType", interp) +def tgeompointseq_from_mfjson(mfjson: 'json_object *', srid: int, interp: 'interpType') -> 'TSequence *': + mfjson_converted = _ffi.cast('json_object *', mfjson) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tgeompointseq_from_mfjson(mfjson_converted, srid, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompointseq_in(string: str, interp: "interpType") -> "TSequence *": - string_converted = string.encode("utf-8") - interp_converted = _ffi.cast("interpType", interp) +def tgeompointseq_in(string: str, interp: 'interpType') -> 'TSequence *': + string_converted = string.encode('utf-8') + interp_converted = _ffi.cast('interpType', interp) result = _lib.tgeompointseq_in(string_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompointseqset_from_mfjson( - mfjson: "json_object *", srid: int, interp: "interpType" -) -> "TSequenceSet *": - mfjson_converted = _ffi.cast("json_object *", mfjson) - interp_converted = _ffi.cast("interpType", interp) +def tgeompointseqset_from_mfjson(mfjson: 'json_object *', srid: int, interp: 'interpType') -> 'TSequenceSet *': + mfjson_converted = _ffi.cast('json_object *', mfjson) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tgeompointseqset_from_mfjson(mfjson_converted, srid, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompointseqset_in(string: str) -> "TSequenceSet *": - string_converted = string.encode("utf-8") +def tgeompointseqset_in(string: str) -> 'TSequenceSet *': + string_converted = string.encode('utf-8') result = _lib.tgeompointseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_as_mfjson( - inst: "const TInstant *", with_bbox: bool, precision: int, srs: str -) -> str: - inst_converted = _ffi.cast("const TInstant *", inst) - srs_converted = srs.encode("utf-8") - result = _lib.tinstant_as_mfjson( - inst_converted, with_bbox, precision, srs_converted - ) +def tinstant_as_mfjson(inst: 'const TInstant *', with_bbox: bool, precision: int, srs: str) -> str: + inst_converted = _ffi.cast('const TInstant *', inst) + srs_converted = srs.encode('utf-8') + result = _lib.tinstant_as_mfjson(inst_converted, with_bbox, precision, srs_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tinstant_from_mfjson( - mfjson: "json_object *", isgeo: bool, srid: int, temptype: "meosType" -) -> "TInstant *": - mfjson_converted = _ffi.cast("json_object *", mfjson) - temptype_converted = _ffi.cast("meosType", temptype) - result = _lib.tinstant_from_mfjson( - mfjson_converted, isgeo, srid, temptype_converted - ) +def tinstant_from_mfjson(mfjson: 'json_object *', isgeo: bool, srid: int, temptype: 'meosType') -> 'TInstant *': + mfjson_converted = _ffi.cast('json_object *', mfjson) + temptype_converted = _ffi.cast('meosType', temptype) + result = _lib.tinstant_from_mfjson(mfjson_converted, isgeo, srid, temptype_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_in(string: str, temptype: "meosType") -> "TInstant *": - string_converted = string.encode("utf-8") - temptype_converted = _ffi.cast("meosType", temptype) +def tinstant_in(string: str, temptype: 'meosType') -> 'TInstant *': + string_converted = string.encode('utf-8') + temptype_converted = _ffi.cast('meosType', temptype) result = _lib.tinstant_in(string_converted, temptype_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_out(inst: "const TInstant *", maxdd: int) -> str: - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_out(inst: 'const TInstant *', maxdd: int) -> str: + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tinstant_out(inst_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tintinst_as_mfjson(inst: "const TInstant *", with_bbox: bool) -> str: - inst_converted = _ffi.cast("const TInstant *", inst) +def tintinst_as_mfjson(inst: 'const TInstant *', with_bbox: bool) -> str: + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tintinst_as_mfjson(inst_converted, with_bbox) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tintinst_from_mfjson(mfjson: "json_object *") -> "TInstant *": - mfjson_converted = _ffi.cast("json_object *", mfjson) +def tintinst_from_mfjson(mfjson: 'json_object *') -> 'TInstant *': + mfjson_converted = _ffi.cast('json_object *', mfjson) result = _lib.tintinst_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tintinst_in(string: str) -> "TInstant *": - string_converted = string.encode("utf-8") +def tintinst_in(string: str) -> 'TInstant *': + string_converted = string.encode('utf-8') result = _lib.tintinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tintseq_as_mfjson(seq: "const TSequence *", with_bbox: bool) -> str: - seq_converted = _ffi.cast("const TSequence *", seq) +def tintseq_as_mfjson(seq: 'const TSequence *', with_bbox: bool) -> str: + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tintseq_as_mfjson(seq_converted, with_bbox) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tintseq_from_mfjson(mfjson: "json_object *") -> "TSequence *": - mfjson_converted = _ffi.cast("json_object *", mfjson) +def tintseq_from_mfjson(mfjson: 'json_object *') -> 'TSequence *': + mfjson_converted = _ffi.cast('json_object *', mfjson) result = _lib.tintseq_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tintseq_in(string: str, interp: "interpType") -> "TSequence *": - string_converted = string.encode("utf-8") - interp_converted = _ffi.cast("interpType", interp) +def tintseq_in(string: str, interp: 'interpType') -> 'TSequence *': + string_converted = string.encode('utf-8') + interp_converted = _ffi.cast('interpType', interp) result = _lib.tintseq_in(string_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tintseqset_as_mfjson(ss: "const TSequenceSet *", with_bbox: bool) -> str: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tintseqset_as_mfjson(ss: 'const TSequenceSet *', with_bbox: bool) -> str: + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tintseqset_as_mfjson(ss_converted, with_bbox) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tintseqset_from_mfjson(mfjson: "json_object *") -> "TSequenceSet *": - mfjson_converted = _ffi.cast("json_object *", mfjson) +def tintseqset_from_mfjson(mfjson: 'json_object *') -> 'TSequenceSet *': + mfjson_converted = _ffi.cast('json_object *', mfjson) result = _lib.tintseqset_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tintseqset_in(string: str) -> "TSequenceSet *": - string_converted = string.encode("utf-8") +def tintseqset_in(string: str) -> 'TSequenceSet *': + string_converted = string.encode('utf-8') result = _lib.tintseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tpointarr_as_text( - temparr: "const Temporal **", count: int, maxdd: int, extended: bool -) -> "char **": - temparr_converted = [_ffi.cast("const Temporal *", x) for x in temparr] +def tpointarr_as_text(temparr: 'const Temporal **', count: int, maxdd: int, extended: bool) -> 'char **': + temparr_converted = [_ffi.cast('const Temporal *', x) for x in temparr] result = _lib.tpointarr_as_text(temparr_converted, count, maxdd, extended) _check_error() return result if result != _ffi.NULL else None -def tpointinst_as_mfjson( - inst: "const TInstant *", with_bbox: bool, precision: int, srs: str -) -> str: - inst_converted = _ffi.cast("const TInstant *", inst) - srs_converted = srs.encode("utf-8") - result = _lib.tpointinst_as_mfjson( - inst_converted, with_bbox, precision, srs_converted - ) +def tpointinst_as_mfjson(inst: 'const TInstant *', with_bbox: bool, precision: int, srs: str) -> str: + inst_converted = _ffi.cast('const TInstant *', inst) + srs_converted = srs.encode('utf-8') + result = _lib.tpointinst_as_mfjson(inst_converted, with_bbox, precision, srs_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tpointseq_as_mfjson( - seq: "const TSequence *", with_bbox: bool, precision: int, srs: str -) -> str: - seq_converted = _ffi.cast("const TSequence *", seq) - srs_converted = srs.encode("utf-8") - result = _lib.tpointseq_as_mfjson( - seq_converted, with_bbox, precision, srs_converted - ) +def tpointseq_as_mfjson(seq: 'const TSequence *', with_bbox: bool, precision: int, srs: str) -> str: + seq_converted = _ffi.cast('const TSequence *', seq) + srs_converted = srs.encode('utf-8') + result = _lib.tpointseq_as_mfjson(seq_converted, with_bbox, precision, srs_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tpointseqset_as_mfjson( - ss: "const TSequenceSet *", with_bbox: bool, precision: int, srs: str -) -> str: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - srs_converted = srs.encode("utf-8") - result = _lib.tpointseqset_as_mfjson( - ss_converted, with_bbox, precision, srs_converted - ) +def tpointseqset_as_mfjson(ss: 'const TSequenceSet *', with_bbox: bool, precision: int, srs: str) -> str: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + srs_converted = srs.encode('utf-8') + result = _lib.tpointseqset_as_mfjson(ss_converted, with_bbox, precision, srs_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tsequence_as_mfjson( - seq: "const TSequence *", with_bbox: bool, precision: int, srs: str -) -> str: - seq_converted = _ffi.cast("const TSequence *", seq) - srs_converted = srs.encode("utf-8") - result = _lib.tsequence_as_mfjson( - seq_converted, with_bbox, precision, srs_converted - ) +def tsequence_as_mfjson(seq: 'const TSequence *', with_bbox: bool, precision: int, srs: str) -> str: + seq_converted = _ffi.cast('const TSequence *', seq) + srs_converted = srs.encode('utf-8') + result = _lib.tsequence_as_mfjson(seq_converted, with_bbox, precision, srs_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tsequence_from_mfjson( - mfjson: "json_object *", - isgeo: bool, - srid: int, - temptype: "meosType", - interp: "interpType", -) -> "TSequence *": - mfjson_converted = _ffi.cast("json_object *", mfjson) - temptype_converted = _ffi.cast("meosType", temptype) - interp_converted = _ffi.cast("interpType", interp) - result = _lib.tsequence_from_mfjson( - mfjson_converted, isgeo, srid, temptype_converted, interp_converted - ) +def tsequence_from_mfjson(mfjson: 'json_object *', isgeo: bool, srid: int, temptype: 'meosType', interp: 'interpType') -> 'TSequence *': + mfjson_converted = _ffi.cast('json_object *', mfjson) + temptype_converted = _ffi.cast('meosType', temptype) + interp_converted = _ffi.cast('interpType', interp) + result = _lib.tsequence_from_mfjson(mfjson_converted, isgeo, srid, temptype_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_in( - string: str, temptype: "meosType", interp: "interpType" -) -> "TSequence *": - string_converted = string.encode("utf-8") - temptype_converted = _ffi.cast("meosType", temptype) - interp_converted = _ffi.cast("interpType", interp) +def tsequence_in(string: str, temptype: 'meosType', interp: 'interpType') -> 'TSequence *': + string_converted = string.encode('utf-8') + temptype_converted = _ffi.cast('meosType', temptype) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tsequence_in(string_converted, temptype_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_out(seq: "const TSequence *", maxdd: int) -> str: - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_out(seq: 'const TSequence *', maxdd: int) -> str: + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_out(seq_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tsequenceset_as_mfjson( - ss: "const TSequenceSet *", with_bbox: bool, precision: int, srs: str -) -> str: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - srs_converted = srs.encode("utf-8") - result = _lib.tsequenceset_as_mfjson( - ss_converted, with_bbox, precision, srs_converted - ) +def tsequenceset_as_mfjson(ss: 'const TSequenceSet *', with_bbox: bool, precision: int, srs: str) -> str: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + srs_converted = srs.encode('utf-8') + result = _lib.tsequenceset_as_mfjson(ss_converted, with_bbox, precision, srs_converted) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tsequenceset_from_mfjson( - mfjson: "json_object *", - isgeo: bool, - srid: int, - temptype: "meosType", - interp: "interpType", -) -> "TSequenceSet *": - mfjson_converted = _ffi.cast("json_object *", mfjson) - temptype_converted = _ffi.cast("meosType", temptype) - interp_converted = _ffi.cast("interpType", interp) - result = _lib.tsequenceset_from_mfjson( - mfjson_converted, isgeo, srid, temptype_converted, interp_converted - ) +def tsequenceset_from_mfjson(mfjson: 'json_object *', isgeo: bool, srid: int, temptype: 'meosType', interp: 'interpType') -> 'TSequenceSet *': + mfjson_converted = _ffi.cast('json_object *', mfjson) + temptype_converted = _ffi.cast('meosType', temptype) + interp_converted = _ffi.cast('interpType', interp) + result = _lib.tsequenceset_from_mfjson(mfjson_converted, isgeo, srid, temptype_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_in( - string: str, temptype: "meosType", interp: "interpType" -) -> "TSequenceSet *": - string_converted = string.encode("utf-8") - temptype_converted = _ffi.cast("meosType", temptype) - interp_converted = _ffi.cast("interpType", interp) - result = _lib.tsequenceset_in( - string_converted, temptype_converted, interp_converted - ) +def tsequenceset_in(string: str, temptype: 'meosType', interp: 'interpType') -> 'TSequenceSet *': + string_converted = string.encode('utf-8') + temptype_converted = _ffi.cast('meosType', temptype) + interp_converted = _ffi.cast('interpType', interp) + result = _lib.tsequenceset_in(string_converted, temptype_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_out(ss: "const TSequenceSet *", maxdd: int) -> str: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_out(ss: 'const TSequenceSet *', maxdd: int) -> str: + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_out(ss_converted, maxdd) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def ttextinst_as_mfjson(inst: "const TInstant *", with_bbox: bool) -> str: - inst_converted = _ffi.cast("const TInstant *", inst) +def ttextinst_as_mfjson(inst: 'const TInstant *', with_bbox: bool) -> str: + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.ttextinst_as_mfjson(inst_converted, with_bbox) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def ttextinst_from_mfjson(mfjson: "json_object *") -> "TInstant *": - mfjson_converted = _ffi.cast("json_object *", mfjson) +def ttextinst_from_mfjson(mfjson: 'json_object *') -> 'TInstant *': + mfjson_converted = _ffi.cast('json_object *', mfjson) result = _lib.ttextinst_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def ttextinst_in(string: str) -> "TInstant *": - string_converted = string.encode("utf-8") +def ttextinst_in(string: str) -> 'TInstant *': + string_converted = string.encode('utf-8') result = _lib.ttextinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def ttextseq_as_mfjson(seq: "const TSequence *", with_bbox: bool) -> str: - seq_converted = _ffi.cast("const TSequence *", seq) +def ttextseq_as_mfjson(seq: 'const TSequence *', with_bbox: bool) -> str: + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.ttextseq_as_mfjson(seq_converted, with_bbox) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def ttextseq_from_mfjson(mfjson: "json_object *") -> "TSequence *": - mfjson_converted = _ffi.cast("json_object *", mfjson) +def ttextseq_from_mfjson(mfjson: 'json_object *') -> 'TSequence *': + mfjson_converted = _ffi.cast('json_object *', mfjson) result = _lib.ttextseq_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def ttextseq_in(string: str, interp: "interpType") -> "TSequence *": - string_converted = string.encode("utf-8") - interp_converted = _ffi.cast("interpType", interp) +def ttextseq_in(string: str, interp: 'interpType') -> 'TSequence *': + string_converted = string.encode('utf-8') + interp_converted = _ffi.cast('interpType', interp) result = _lib.ttextseq_in(string_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def ttextseqset_as_mfjson(ss: "const TSequenceSet *", with_bbox: bool) -> str: - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def ttextseqset_as_mfjson(ss: 'const TSequenceSet *', with_bbox: bool) -> str: + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.ttextseqset_as_mfjson(ss_converted, with_bbox) _check_error() - result = _ffi.string(result).decode("utf-8") + result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def ttextseqset_from_mfjson(mfjson: "json_object *") -> "TSequenceSet *": - mfjson_converted = _ffi.cast("json_object *", mfjson) +def ttextseqset_from_mfjson(mfjson: 'json_object *') -> 'TSequenceSet *': + mfjson_converted = _ffi.cast('json_object *', mfjson) result = _lib.ttextseqset_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def ttextseqset_in(string: str) -> "TSequenceSet *": - string_converted = string.encode("utf-8") +def ttextseqset_in(string: str) -> 'TSequenceSet *': + string_converted = string.encode('utf-8') result = _lib.ttextseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_cp(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_cp(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_cp(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_from_base_temp( - value: "Datum", temptype: "meosType", temp: "const Temporal *" -) -> "Temporal *": - value_converted = _ffi.cast("Datum", value) - temptype_converted = _ffi.cast("meosType", temptype) - temp_converted = _ffi.cast("const Temporal *", temp) - result = _lib.temporal_from_base_temp( - value_converted, temptype_converted, temp_converted - ) +def temporal_from_base_temp(value: 'Datum', temptype: 'meosType', temp: 'const Temporal *') -> 'Temporal *': + value_converted = _ffi.cast('Datum', value) + temptype_converted = _ffi.cast('meosType', temptype) + temp_converted = _ffi.cast('const Temporal *', temp) + result = _lib.temporal_from_base_temp(value_converted, temptype_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_copy(inst: "const TInstant *") -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_copy(inst: 'const TInstant *') -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tinstant_copy(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_make(value: "Datum", temptype: "meosType", t: int) -> "TInstant *": - value_converted = _ffi.cast("Datum", value) - temptype_converted = _ffi.cast("meosType", temptype) - t_converted = _ffi.cast("TimestampTz", t) +def tinstant_make(value: 'Datum', temptype: 'meosType', t: int) -> 'TInstant *': + value_converted = _ffi.cast('Datum', value) + temptype_converted = _ffi.cast('meosType', temptype) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tinstant_make(value_converted, temptype_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_make_coords( - xcoords: "const double *", - ycoords: "const double *", - zcoords: "const double *", - times: int, - count: int, - srid: int, - geodetic: bool, - lower_inc: bool, - upper_inc: bool, - interp: "interpType", - normalize: bool, -) -> "TSequence *": - xcoords_converted = _ffi.cast("const double *", xcoords) - ycoords_converted = _ffi.cast("const double *", ycoords) - zcoords_converted = _ffi.cast("const double *", zcoords) - times_converted = _ffi.cast("const TimestampTz *", times) - srid_converted = _ffi.cast("int32", srid) - interp_converted = _ffi.cast("interpType", interp) - result = _lib.tpointseq_make_coords( - xcoords_converted, - ycoords_converted, - zcoords_converted, - times_converted, - count, - srid_converted, - geodetic, - lower_inc, - upper_inc, - interp_converted, - normalize, - ) +def tpointseq_make_coords(xcoords: 'const double *', ycoords: 'const double *', zcoords: 'const double *', times: int, count: int, srid: int, geodetic: bool, lower_inc: bool, upper_inc: bool, interp: 'interpType', normalize: bool) -> 'TSequence *': + xcoords_converted = _ffi.cast('const double *', xcoords) + ycoords_converted = _ffi.cast('const double *', ycoords) + zcoords_converted = _ffi.cast('const double *', zcoords) + times_converted = _ffi.cast('const TimestampTz *', times) + srid_converted = _ffi.cast('int32', srid) + interp_converted = _ffi.cast('interpType', interp) + result = _lib.tpointseq_make_coords(xcoords_converted, ycoords_converted, zcoords_converted, times_converted, count, srid_converted, geodetic, lower_inc, upper_inc, interp_converted, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequence_from_base_tstzset( - value: "Datum", temptype: "meosType", ss: "const Set *" -) -> "TSequence *": - value_converted = _ffi.cast("Datum", value) - temptype_converted = _ffi.cast("meosType", temptype) - ss_converted = _ffi.cast("const Set *", ss) - result = _lib.tsequence_from_base_tstzset( - value_converted, temptype_converted, ss_converted - ) +def tsequence_from_base_tstzset(value: 'Datum', temptype: 'meosType', ss: 'const Set *') -> 'TSequence *': + value_converted = _ffi.cast('Datum', value) + temptype_converted = _ffi.cast('meosType', temptype) + ss_converted = _ffi.cast('const Set *', ss) + result = _lib.tsequence_from_base_tstzset(value_converted, temptype_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_make_exp( - instants: "const TInstant **", - count: int, - maxcount: int, - lower_inc: bool, - upper_inc: bool, - interp: "interpType", - normalize: bool, -) -> "TSequence *": - instants_converted = [_ffi.cast("const TInstant *", x) for x in instants] - interp_converted = _ffi.cast("interpType", interp) - result = _lib.tsequence_make_exp( - instants_converted, - count, - maxcount, - lower_inc, - upper_inc, - interp_converted, - normalize, - ) +def tsequence_make_exp(instants: 'const TInstant **', count: int, maxcount: int, lower_inc: bool, upper_inc: bool, interp: 'interpType', normalize: bool) -> 'TSequence *': + instants_converted = [_ffi.cast('const TInstant *', x) for x in instants] + interp_converted = _ffi.cast('interpType', interp) + result = _lib.tsequence_make_exp(instants_converted, count, maxcount, lower_inc, upper_inc, interp_converted, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequence_compact(seq: "const TSequence *") -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_compact(seq: 'const TSequence *') -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_compact(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_restart(seq: "TSequence *", last: int) -> None: - seq_converted = _ffi.cast("TSequence *", seq) +def tsequence_restart(seq: 'TSequence *', last: int) -> None: + seq_converted = _ffi.cast('TSequence *', seq) _lib.tsequence_restart(seq_converted, last) _check_error() -def tsequence_subseq( - seq: "const TSequence *", from_: int, to: int, lower_inc: bool, upper_inc: bool -) -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_subseq(seq: 'const TSequence *', from_: int, to: int, lower_inc: bool, upper_inc: bool) -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_subseq(seq_converted, from_, to, lower_inc, upper_inc) _check_error() return result if result != _ffi.NULL else None -def tsequence_copy(seq: "const TSequence *") -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_copy(seq: 'const TSequence *') -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_copy(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_from_base_tstzspan( - value: "Datum", temptype: "meosType", s: "const Span *", interp: "interpType" -) -> "TSequence *": - value_converted = _ffi.cast("Datum", value) - temptype_converted = _ffi.cast("meosType", temptype) - s_converted = _ffi.cast("const Span *", s) - interp_converted = _ffi.cast("interpType", interp) - result = _lib.tsequence_from_base_tstzspan( - value_converted, temptype_converted, s_converted, interp_converted - ) +def tsequence_from_base_tstzspan(value: 'Datum', temptype: 'meosType', s: 'const Span *', interp: 'interpType') -> 'TSequence *': + value_converted = _ffi.cast('Datum', value) + temptype_converted = _ffi.cast('meosType', temptype) + s_converted = _ffi.cast('const Span *', s) + interp_converted = _ffi.cast('interpType', interp) + result = _lib.tsequence_from_base_tstzspan(value_converted, temptype_converted, s_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_make_free( - instants: "TInstant **", - count: int, - lower_inc: bool, - upper_inc: bool, - interp: "interpType", - normalize: bool, -) -> "TSequence *": - instants_converted = [_ffi.cast("TInstant *", x) for x in instants] - interp_converted = _ffi.cast("interpType", interp) - result = _lib.tsequence_make_free( - instants_converted, count, lower_inc, upper_inc, interp_converted, normalize - ) +def tsequence_make_free(instants: 'TInstant **', count: int, lower_inc: bool, upper_inc: bool, interp: 'interpType', normalize: bool) -> 'TSequence *': + instants_converted = [_ffi.cast('TInstant *', x) for x in instants] + interp_converted = _ffi.cast('interpType', interp) + result = _lib.tsequence_make_free(instants_converted, count, lower_inc, upper_inc, interp_converted, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_make_exp( - sequences: "const TSequence **", count: int, maxcount: int, normalize: bool -) -> "TSequenceSet *": - sequences_converted = [_ffi.cast("const TSequence *", x) for x in sequences] +def tsequenceset_make_exp(sequences: 'const TSequence **', count: int, maxcount: int, normalize: bool) -> 'TSequenceSet *': + sequences_converted = [_ffi.cast('const TSequence *', x) for x in sequences] result = _lib.tsequenceset_make_exp(sequences_converted, count, maxcount, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_compact(ss: "const TSequenceSet *") -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_compact(ss: 'const TSequenceSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_compact(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_make_free( - sequences: "TSequence **", count: int, normalize: bool -) -> "TSequenceSet *": - sequences_converted = [_ffi.cast("TSequence *", x) for x in sequences] +def tsequenceset_make_free(sequences: 'TSequence **', count: int, normalize: bool) -> 'TSequenceSet *': + sequences_converted = [_ffi.cast('TSequence *', x) for x in sequences] result = _lib.tsequenceset_make_free(sequences_converted, count, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restart(ss: "TSequenceSet *", last: int) -> None: - ss_converted = _ffi.cast("TSequenceSet *", ss) +def tsequenceset_restart(ss: 'TSequenceSet *', last: int) -> None: + ss_converted = _ffi.cast('TSequenceSet *', ss) _lib.tsequenceset_restart(ss_converted, last) _check_error() -def tsequenceset_copy(ss: "const TSequenceSet *") -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_copy(ss: 'const TSequenceSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_copy(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tseqsetarr_to_tseqset( - seqsets: "TSequenceSet **", count: int, totalseqs: int -) -> "TSequenceSet *": - seqsets_converted = [_ffi.cast("TSequenceSet *", x) for x in seqsets] +def tseqsetarr_to_tseqset(seqsets: 'TSequenceSet **', count: int, totalseqs: int) -> 'TSequenceSet *': + seqsets_converted = [_ffi.cast('TSequenceSet *', x) for x in seqsets] result = _lib.tseqsetarr_to_tseqset(seqsets_converted, count, totalseqs) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_from_base_tstzspanset( - value: "Datum", temptype: "meosType", ss: "const SpanSet *", interp: "interpType" -) -> "TSequenceSet *": - value_converted = _ffi.cast("Datum", value) - temptype_converted = _ffi.cast("meosType", temptype) - ss_converted = _ffi.cast("const SpanSet *", ss) - interp_converted = _ffi.cast("interpType", interp) - result = _lib.tsequenceset_from_base_tstzspanset( - value_converted, temptype_converted, ss_converted, interp_converted - ) +def tsequenceset_from_base_tstzspanset(value: 'Datum', temptype: 'meosType', ss: 'const SpanSet *', interp: 'interpType') -> 'TSequenceSet *': + value_converted = _ffi.cast('Datum', value) + temptype_converted = _ffi.cast('meosType', temptype) + ss_converted = _ffi.cast('const SpanSet *', ss) + interp_converted = _ffi.cast('interpType', interp) + result = _lib.tsequenceset_from_base_tstzspanset(value_converted, temptype_converted, ss_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_set_tstzspan(temp: "const Temporal *", s: "Span *") -> None: - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("Span *", s) +def temporal_set_tstzspan(temp: 'const Temporal *', s: 'Span *') -> None: + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('Span *', s) _lib.temporal_set_tstzspan(temp_converted, s_converted) _check_error() -def tinstant_set_tstzspan(inst: "const TInstant *", s: "Span *") -> None: - inst_converted = _ffi.cast("const TInstant *", inst) - s_converted = _ffi.cast("Span *", s) +def tinstant_set_tstzspan(inst: 'const TInstant *', s: 'Span *') -> None: + inst_converted = _ffi.cast('const TInstant *', inst) + s_converted = _ffi.cast('Span *', s) _lib.tinstant_set_tstzspan(inst_converted, s_converted) _check_error() -def tnumber_span(temp: "const Temporal *") -> "Span *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_span(temp: 'const Temporal *') -> 'Span *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_span(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_set_tstzspan(seq: "const TSequence *", s: "Span *") -> None: - seq_converted = _ffi.cast("const TSequence *", seq) - s_converted = _ffi.cast("Span *", s) +def tsequence_set_tstzspan(seq: 'const TSequence *', s: 'Span *') -> None: + seq_converted = _ffi.cast('const TSequence *', seq) + s_converted = _ffi.cast('Span *', s) _lib.tsequence_set_tstzspan(seq_converted, s_converted) _check_error() -def tsequenceset_set_tstzspan(ss: "const TSequenceSet *", s: "Span *") -> None: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - s_converted = _ffi.cast("Span *", s) +def tsequenceset_set_tstzspan(ss: 'const TSequenceSet *', s: 'Span *') -> None: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + s_converted = _ffi.cast('Span *', s) _lib.tsequenceset_set_tstzspan(ss_converted, s_converted) _check_error() -def temporal_end_value(temp: "const Temporal *") -> "Datum": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_end_value(temp: 'const Temporal *') -> 'Datum': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_end_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_max_value(temp: "const Temporal *") -> "Datum": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_max_value(temp: 'const Temporal *') -> 'Datum': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_max_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_mem_size(temp: "const Temporal *") -> "size_t": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_mem_size(temp: 'const Temporal *') -> 'size_t': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_mem_size(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_min_value(temp: "const Temporal *") -> "Datum": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_min_value(temp: 'const Temporal *') -> 'Datum': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_min_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_set_bbox(temp: "const Temporal *", box: "void *") -> None: - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("void *", box) +def temporal_set_bbox(temp: 'const Temporal *', box: 'void *') -> None: + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('void *', box) _lib.temporal_set_bbox(temp_converted, box_converted) _check_error() -def tfloatseq_derivative(seq: "const TSequence *") -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tfloatseq_derivative(seq: 'const TSequence *') -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tfloatseq_derivative(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseqset_derivative(ss: "const TSequenceSet *") -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tfloatseqset_derivative(ss: 'const TSequenceSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tfloatseqset_derivative(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_set_span(temp: "const Temporal *", span: "Span *") -> None: - temp_converted = _ffi.cast("const Temporal *", temp) - span_converted = _ffi.cast("Span *", span) +def tnumber_set_span(temp: 'const Temporal *', span: 'Span *') -> None: + temp_converted = _ffi.cast('const Temporal *', temp) + span_converted = _ffi.cast('Span *', span) _lib.tnumber_set_span(temp_converted, span_converted) _check_error() -def temporal_start_value(temp: "const Temporal *") -> "Datum": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_start_value(temp: 'const Temporal *') -> 'Datum': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_start_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberinst_abs(inst: "const TInstant *") -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) +def tnumberinst_abs(inst: 'const TInstant *') -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tnumberinst_abs(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_abs(seq: "const TSequence *") -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_abs(seq: 'const TSequence *') -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tnumberseq_abs(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_abs(ss: "const TSequenceSet *") -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_abs(ss: 'const TSequenceSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tnumberseqset_abs(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_angular_difference(seq: "const TSequence *") -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_angular_difference(seq: 'const TSequence *') -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tnumberseq_angular_difference(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_angular_difference(ss: "const TSequenceSet *") -> "TSequence *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_angular_difference(ss: 'const TSequenceSet *') -> 'TSequence *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tnumberseqset_angular_difference(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_delta_value(seq: "const TSequence *") -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_delta_value(seq: 'const TSequence *') -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tnumberseq_delta_value(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_delta_value(ss: "const TSequenceSet *") -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_delta_value(ss: 'const TSequenceSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tnumberseqset_delta_value(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberinst_valuespans(inst: "const TInstant *") -> "SpanSet *": - inst_converted = _ffi.cast("const TInstant *", inst) +def tnumberinst_valuespans(inst: 'const TInstant *') -> 'SpanSet *': + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tnumberinst_valuespans(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_valuespans(seq: "const TSequence *") -> "SpanSet *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_valuespans(seq: 'const TSequence *') -> 'SpanSet *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tnumberseq_valuespans(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_valuespans(ss: "const TSequenceSet *") -> "SpanSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_valuespans(ss: 'const TSequenceSet *') -> 'SpanSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tnumberseqset_valuespans(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_hash(inst: "const TInstant *") -> "uint32": - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_hash(inst: 'const TInstant *') -> 'uint32': + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tinstant_hash(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_instants(inst: "const TInstant *") -> "Tuple['const TInstant **', 'int']": - inst_converted = _ffi.cast("const TInstant *", inst) - count = _ffi.new("int *") +def tinstant_instants(inst: 'const TInstant *') -> "Tuple['const TInstant **', 'int']": + inst_converted = _ffi.cast('const TInstant *', inst) + count = _ffi.new('int *') result = _lib.tinstant_instants(inst_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tinstant_set_bbox(inst: "const TInstant *", box: "void *") -> None: - inst_converted = _ffi.cast("const TInstant *", inst) - box_converted = _ffi.cast("void *", box) +def tinstant_set_bbox(inst: 'const TInstant *', box: 'void *') -> None: + inst_converted = _ffi.cast('const TInstant *', inst) + box_converted = _ffi.cast('void *', box) _lib.tinstant_set_bbox(inst_converted, box_converted) _check_error() -def tinstant_time(inst: "const TInstant *") -> "SpanSet *": - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_time(inst: 'const TInstant *') -> 'SpanSet *': + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tinstant_time(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_timestamps(inst: "const TInstant *") -> "Tuple['TimestampTz *', 'int']": - inst_converted = _ffi.cast("const TInstant *", inst) - count = _ffi.new("int *") +def tinstant_timestamps(inst: 'const TInstant *') -> "Tuple['TimestampTz *', 'int']": + inst_converted = _ffi.cast('const TInstant *', inst) + count = _ffi.new('int *') result = _lib.tinstant_timestamps(inst_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tinstant_value(inst: "const TInstant *") -> "Datum": - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_value(inst: 'const TInstant *') -> 'Datum': + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tinstant_value(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_value_at_timestamptz(inst: "const TInstant *", t: int) -> "Datum *": - inst_converted = _ffi.cast("const TInstant *", inst) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("Datum *") +def tinstant_value_at_timestamptz(inst: 'const TInstant *', t: int) -> 'Datum *': + inst_converted = _ffi.cast('const TInstant *', inst) + t_converted = _ffi.cast('TimestampTz', t) + out_result = _ffi.new('Datum *') result = _lib.tinstant_value_at_timestamptz(inst_converted, t_converted, out_result) _check_error() if result: @@ -14035,289 +13017,285 @@ def tinstant_value_at_timestamptz(inst: "const TInstant *", t: int) -> "Datum *" return None -def tinstant_value_copy(inst: "const TInstant *") -> "Datum": - inst_converted = _ffi.cast("const TInstant *", inst) +def tinstant_value_copy(inst: 'const TInstant *') -> 'Datum': + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tinstant_value_copy(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_values(inst: "const TInstant *") -> "Tuple['Datum *', 'int']": - inst_converted = _ffi.cast("const TInstant *", inst) - count = _ffi.new("int *") +def tinstant_values(inst: 'const TInstant *') -> "Tuple['Datum *', 'int']": + inst_converted = _ffi.cast('const TInstant *', inst) + count = _ffi.new('int *') result = _lib.tinstant_values(inst_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tsequence_duration(seq: "const TSequence *") -> "Interval *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_duration(seq: 'const TSequence *') -> 'Interval *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_duration(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_end_timestamptz(seq: "const TSequence *") -> "TimestampTz": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_end_timestamptz(seq: 'const TSequence *') -> 'TimestampTz': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_end_timestamptz(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_hash(seq: "const TSequence *") -> "uint32": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_hash(seq: 'const TSequence *') -> 'uint32': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_hash(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_instants(seq: "const TSequence *") -> "const TInstant **": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_instants(seq: 'const TSequence *') -> 'const TInstant **': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_instants(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_max_instant(seq: "const TSequence *") -> "const TInstant *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_max_instant(seq: 'const TSequence *') -> 'const TInstant *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_max_instant(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_max_value(seq: "const TSequence *") -> "Datum": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_max_value(seq: 'const TSequence *') -> 'Datum': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_max_value(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_min_instant(seq: "const TSequence *") -> "const TInstant *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_min_instant(seq: 'const TSequence *') -> 'const TInstant *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_min_instant(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_min_value(seq: "const TSequence *") -> "Datum": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_min_value(seq: 'const TSequence *') -> 'Datum': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_min_value(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_segments(seq: "const TSequence *") -> "Tuple['TSequence **', 'int']": - seq_converted = _ffi.cast("const TSequence *", seq) - count = _ffi.new("int *") +def tsequence_segments(seq: 'const TSequence *') -> "Tuple['TSequence **', 'int']": + seq_converted = _ffi.cast('const TSequence *', seq) + count = _ffi.new('int *') result = _lib.tsequence_segments(seq_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tsequence_sequences(seq: "const TSequence *") -> "Tuple['TSequence **', 'int']": - seq_converted = _ffi.cast("const TSequence *", seq) - count = _ffi.new("int *") +def tsequence_sequences(seq: 'const TSequence *') -> "Tuple['TSequence **', 'int']": + seq_converted = _ffi.cast('const TSequence *', seq) + count = _ffi.new('int *') result = _lib.tsequence_sequences(seq_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tsequence_set_bbox(seq: "const TSequence *", box: "void *") -> None: - seq_converted = _ffi.cast("const TSequence *", seq) - box_converted = _ffi.cast("void *", box) +def tsequence_set_bbox(seq: 'const TSequence *', box: 'void *') -> None: + seq_converted = _ffi.cast('const TSequence *', seq) + box_converted = _ffi.cast('void *', box) _lib.tsequence_set_bbox(seq_converted, box_converted) _check_error() -def tsequence_expand_bbox(seq: "TSequence *", inst: "const TInstant *") -> None: - seq_converted = _ffi.cast("TSequence *", seq) - inst_converted = _ffi.cast("const TInstant *", inst) +def tsequence_expand_bbox(seq: 'TSequence *', inst: 'const TInstant *') -> None: + seq_converted = _ffi.cast('TSequence *', seq) + inst_converted = _ffi.cast('const TInstant *', inst) _lib.tsequence_expand_bbox(seq_converted, inst_converted) _check_error() -def tsequenceset_expand_bbox(ss: "TSequenceSet *", seq: "const TSequence *") -> None: - ss_converted = _ffi.cast("TSequenceSet *", ss) - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequenceset_expand_bbox(ss: 'TSequenceSet *', seq: 'const TSequence *') -> None: + ss_converted = _ffi.cast('TSequenceSet *', ss) + seq_converted = _ffi.cast('const TSequence *', seq) _lib.tsequenceset_expand_bbox(ss_converted, seq_converted) _check_error() -def tsequence_start_timestamptz(seq: "const TSequence *") -> "TimestampTz": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_start_timestamptz(seq: 'const TSequence *') -> 'TimestampTz': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_start_timestamptz(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_time(seq: "const TSequence *") -> "SpanSet *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_time(seq: 'const TSequence *') -> 'SpanSet *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_time(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_timestamps(seq: "const TSequence *") -> "Tuple['TimestampTz *', 'int']": - seq_converted = _ffi.cast("const TSequence *", seq) - count = _ffi.new("int *") +def tsequence_timestamps(seq: 'const TSequence *') -> "Tuple['TimestampTz *', 'int']": + seq_converted = _ffi.cast('const TSequence *', seq) + count = _ffi.new('int *') result = _lib.tsequence_timestamps(seq_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tsequence_value_at_timestamptz( - seq: "const TSequence *", t: int, strict: bool -) -> "Datum *": - seq_converted = _ffi.cast("const TSequence *", seq) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("Datum *") - result = _lib.tsequence_value_at_timestamptz( - seq_converted, t_converted, strict, out_result - ) +def tsequence_value_at_timestamptz(seq: 'const TSequence *', t: int, strict: bool) -> 'Datum *': + seq_converted = _ffi.cast('const TSequence *', seq) + t_converted = _ffi.cast('TimestampTz', t) + out_result = _ffi.new('Datum *') + result = _lib.tsequence_value_at_timestamptz(seq_converted, t_converted, strict, out_result) _check_error() if result: return out_result if out_result != _ffi.NULL else None return None -def tsequence_values(seq: "const TSequence *") -> "Tuple['Datum *', 'int']": - seq_converted = _ffi.cast("const TSequence *", seq) - count = _ffi.new("int *") +def tsequence_values(seq: 'const TSequence *') -> "Tuple['Datum *', 'int']": + seq_converted = _ffi.cast('const TSequence *', seq) + count = _ffi.new('int *') result = _lib.tsequence_values(seq_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tsequenceset_duration(ss: "const TSequenceSet *", boundspan: bool) -> "Interval *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_duration(ss: 'const TSequenceSet *', boundspan: bool) -> 'Interval *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_duration(ss_converted, boundspan) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_end_timestamptz(ss: "const TSequenceSet *") -> "TimestampTz": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_end_timestamptz(ss: 'const TSequenceSet *') -> 'TimestampTz': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_end_timestamptz(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_hash(ss: "const TSequenceSet *") -> "uint32": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_hash(ss: 'const TSequenceSet *') -> 'uint32': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_hash(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_inst_n(ss: "const TSequenceSet *", n: int) -> "const TInstant *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_inst_n(ss: 'const TSequenceSet *', n: int) -> 'const TInstant *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_inst_n(ss_converted, n) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_instants(ss: "const TSequenceSet *") -> "const TInstant **": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_instants(ss: 'const TSequenceSet *') -> 'const TInstant **': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_instants(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_max_instant(ss: "const TSequenceSet *") -> "const TInstant *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_max_instant(ss: 'const TSequenceSet *') -> 'const TInstant *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_max_instant(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_max_value(ss: "const TSequenceSet *") -> "Datum": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_max_value(ss: 'const TSequenceSet *') -> 'Datum': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_max_value(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_min_instant(ss: "const TSequenceSet *") -> "const TInstant *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_min_instant(ss: 'const TSequenceSet *') -> 'const TInstant *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_min_instant(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_min_value(ss: "const TSequenceSet *") -> "Datum": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_min_value(ss: 'const TSequenceSet *') -> 'Datum': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_min_value(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_num_instants(ss: "const TSequenceSet *") -> "int": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_num_instants(ss: 'const TSequenceSet *') -> 'int': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_num_instants(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_num_timestamps(ss: "const TSequenceSet *") -> "int": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_num_timestamps(ss: 'const TSequenceSet *') -> 'int': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_num_timestamps(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_segments(ss: "const TSequenceSet *") -> "Tuple['TSequence **', 'int']": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - count = _ffi.new("int *") +def tsequenceset_segments(ss: 'const TSequenceSet *') -> "Tuple['TSequence **', 'int']": + ss_converted = _ffi.cast('const TSequenceSet *', ss) + count = _ffi.new('int *') result = _lib.tsequenceset_segments(ss_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tsequenceset_sequences(ss: "const TSequenceSet *") -> "TSequence **": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_sequences(ss: 'const TSequenceSet *') -> 'TSequence **': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_sequences(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_sequences_p(ss: "const TSequenceSet *") -> "const TSequence **": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_sequences_p(ss: 'const TSequenceSet *') -> 'const TSequence **': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_sequences_p(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_set_bbox(ss: "const TSequenceSet *", box: "void *") -> None: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - box_converted = _ffi.cast("void *", box) +def tsequenceset_set_bbox(ss: 'const TSequenceSet *', box: 'void *') -> None: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + box_converted = _ffi.cast('void *', box) _lib.tsequenceset_set_bbox(ss_converted, box_converted) _check_error() -def tsequenceset_start_timestamptz(ss: "const TSequenceSet *") -> "TimestampTz": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_start_timestamptz(ss: 'const TSequenceSet *') -> 'TimestampTz': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_start_timestamptz(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_time(ss: "const TSequenceSet *") -> "SpanSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_time(ss: 'const TSequenceSet *') -> 'SpanSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_time(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_timespan(ss: "const TSequenceSet *") -> "Interval *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_timespan(ss: 'const TSequenceSet *') -> 'Interval *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_timespan(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_timestamptz_n(ss: "const TSequenceSet *", n: int) -> int: - ss_converted = _ffi.cast("const TSequenceSet *", ss) - out_result = _ffi.new("TimestampTz *") +def tsequenceset_timestamptz_n(ss: 'const TSequenceSet *', n: int) -> int: + ss_converted = _ffi.cast('const TSequenceSet *', ss) + out_result = _ffi.new('TimestampTz *') result = _lib.tsequenceset_timestamptz_n(ss_converted, n, out_result) _check_error() if result: @@ -14325,1768 +13303,1486 @@ def tsequenceset_timestamptz_n(ss: "const TSequenceSet *", n: int) -> int: return None -def tsequenceset_timestamps( - ss: "const TSequenceSet *", -) -> "Tuple['TimestampTz *', 'int']": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - count = _ffi.new("int *") +def tsequenceset_timestamps(ss: 'const TSequenceSet *') -> "Tuple['TimestampTz *', 'int']": + ss_converted = _ffi.cast('const TSequenceSet *', ss) + count = _ffi.new('int *') result = _lib.tsequenceset_timestamps(ss_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tsequenceset_value_at_timestamptz( - ss: "const TSequenceSet *", t: int, strict: bool -) -> "Datum *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("Datum *") - result = _lib.tsequenceset_value_at_timestamptz( - ss_converted, t_converted, strict, out_result - ) +def tsequenceset_value_at_timestamptz(ss: 'const TSequenceSet *', t: int, strict: bool) -> 'Datum *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) + out_result = _ffi.new('Datum *') + result = _lib.tsequenceset_value_at_timestamptz(ss_converted, t_converted, strict, out_result) _check_error() if result: return out_result if out_result != _ffi.NULL else None return None -def tsequenceset_values(ss: "const TSequenceSet *") -> "Tuple['Datum *', 'int']": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - count = _ffi.new("int *") +def tsequenceset_values(ss: 'const TSequenceSet *') -> "Tuple['Datum *', 'int']": + ss_converted = _ffi.cast('const TSequenceSet *', ss) + count = _ffi.new('int *') result = _lib.tsequenceset_values(ss_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tinstant_merge( - inst1: "const TInstant *", inst2: "const TInstant *" -) -> "Temporal *": - inst1_converted = _ffi.cast("const TInstant *", inst1) - inst2_converted = _ffi.cast("const TInstant *", inst2) +def tinstant_merge(inst1: 'const TInstant *', inst2: 'const TInstant *') -> 'Temporal *': + inst1_converted = _ffi.cast('const TInstant *', inst1) + inst2_converted = _ffi.cast('const TInstant *', inst2) result = _lib.tinstant_merge(inst1_converted, inst2_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_merge_array(instants: "const TInstant **", count: int) -> "Temporal *": - instants_converted = [_ffi.cast("const TInstant *", x) for x in instants] +def tinstant_merge_array(instants: 'const TInstant **', count: int) -> 'Temporal *': + instants_converted = [_ffi.cast('const TInstant *', x) for x in instants] result = _lib.tinstant_merge_array(instants_converted, count) _check_error() return result if result != _ffi.NULL else None -def tinstant_shift_time( - inst: "const TInstant *", interval: "const Interval *" -) -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) - interval_converted = _ffi.cast("const Interval *", interval) +def tinstant_shift_time(inst: 'const TInstant *', interval: 'const Interval *') -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) + interval_converted = _ffi.cast('const Interval *', interval) result = _lib.tinstant_shift_time(inst_converted, interval_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_to_tsequence( - inst: "const TInstant *", interp: "interpType" -) -> "TSequence *": - inst_converted = _ffi.cast("const TInstant *", inst) - interp_converted = _ffi.cast("interpType", interp) +def tinstant_to_tsequence(inst: 'const TInstant *', interp: 'interpType') -> 'TSequence *': + inst_converted = _ffi.cast('const TInstant *', inst) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tinstant_to_tsequence(inst_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_to_tsequenceset( - inst: "const TInstant *", interp: "interpType" -) -> "TSequenceSet *": - inst_converted = _ffi.cast("const TInstant *", inst) - interp_converted = _ffi.cast("interpType", interp) +def tinstant_to_tsequenceset(inst: 'const TInstant *', interp: 'interpType') -> 'TSequenceSet *': + inst_converted = _ffi.cast('const TInstant *', inst) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tinstant_to_tsequenceset(inst_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_shift_scale_value( - temp: "const Temporal *", - shift: "Datum", - width: "Datum", - hasshift: bool, - haswidth: bool, -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - shift_converted = _ffi.cast("Datum", shift) - width_converted = _ffi.cast("Datum", width) - result = _lib.tnumber_shift_scale_value( - temp_converted, shift_converted, width_converted, hasshift, haswidth - ) +def tnumber_shift_scale_value(temp: 'const Temporal *', shift: 'Datum', width: 'Datum', hasshift: bool, haswidth: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + shift_converted = _ffi.cast('Datum', shift) + width_converted = _ffi.cast('Datum', width) + result = _lib.tnumber_shift_scale_value(temp_converted, shift_converted, width_converted, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def tnuminst_shift_value(inst: "const TInstant *", shift: "Datum") -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) - shift_converted = _ffi.cast("Datum", shift) +def tnuminst_shift_value(inst: 'const TInstant *', shift: 'Datum') -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) + shift_converted = _ffi.cast('Datum', shift) result = _lib.tnuminst_shift_value(inst_converted, shift_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_shift_scale_value( - seq: "const TSequence *", - shift: "Datum", - width: "Datum", - hasshift: bool, - haswidth: bool, -) -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) - shift_converted = _ffi.cast("Datum", shift) - width_converted = _ffi.cast("Datum", width) - result = _lib.tnumberseq_shift_scale_value( - seq_converted, shift_converted, width_converted, hasshift, haswidth - ) +def tnumberseq_shift_scale_value(seq: 'const TSequence *', shift: 'Datum', width: 'Datum', hasshift: bool, haswidth: bool) -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) + shift_converted = _ffi.cast('Datum', shift) + width_converted = _ffi.cast('Datum', width) + result = _lib.tnumberseq_shift_scale_value(seq_converted, shift_converted, width_converted, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def tsequence_append_tinstant( - seq: "TSequence *", - inst: "const TInstant *", - maxdist: float, - maxt: "const Interval *", - expand: bool, -) -> "Temporal *": - seq_converted = _ffi.cast("TSequence *", seq) - inst_converted = _ffi.cast("const TInstant *", inst) - maxt_converted = _ffi.cast("const Interval *", maxt) - result = _lib.tsequence_append_tinstant( - seq_converted, inst_converted, maxdist, maxt_converted, expand - ) +def tsequence_append_tinstant(seq: 'TSequence *', inst: 'const TInstant *', maxdist: float, maxt: 'const Interval *', expand: bool) -> 'Temporal *': + seq_converted = _ffi.cast('TSequence *', seq) + inst_converted = _ffi.cast('const TInstant *', inst) + maxt_converted = _ffi.cast('const Interval *', maxt) + result = _lib.tsequence_append_tinstant(seq_converted, inst_converted, maxdist, maxt_converted, expand) _check_error() return result if result != _ffi.NULL else None -def tsequence_append_tsequence( - seq1: "TSequence *", seq2: "const TSequence *", expand: bool -) -> "Temporal *": - seq1_converted = _ffi.cast("TSequence *", seq1) - seq2_converted = _ffi.cast("const TSequence *", seq2) +def tsequence_append_tsequence(seq1: 'TSequence *', seq2: 'const TSequence *', expand: bool) -> 'Temporal *': + seq1_converted = _ffi.cast('TSequence *', seq1) + seq2_converted = _ffi.cast('const TSequence *', seq2) result = _lib.tsequence_append_tsequence(seq1_converted, seq2_converted, expand) _check_error() return result if result != _ffi.NULL else None -def tsequence_merge( - seq1: "const TSequence *", seq2: "const TSequence *" -) -> "Temporal *": - seq1_converted = _ffi.cast("const TSequence *", seq1) - seq2_converted = _ffi.cast("const TSequence *", seq2) +def tsequence_merge(seq1: 'const TSequence *', seq2: 'const TSequence *') -> 'Temporal *': + seq1_converted = _ffi.cast('const TSequence *', seq1) + seq2_converted = _ffi.cast('const TSequence *', seq2) result = _lib.tsequence_merge(seq1_converted, seq2_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_merge_array(sequences: "const TSequence **", count: int) -> "Temporal *": - sequences_converted = [_ffi.cast("const TSequence *", x) for x in sequences] +def tsequence_merge_array(sequences: 'const TSequence **', count: int) -> 'Temporal *': + sequences_converted = [_ffi.cast('const TSequence *', x) for x in sequences] result = _lib.tsequence_merge_array(sequences_converted, count) _check_error() return result if result != _ffi.NULL else None -def tsequence_set_interp( - seq: "const TSequence *", interp: "interpType" -) -> "Temporal *": - seq_converted = _ffi.cast("const TSequence *", seq) - interp_converted = _ffi.cast("interpType", interp) +def tsequence_set_interp(seq: 'const TSequence *', interp: 'interpType') -> 'Temporal *': + seq_converted = _ffi.cast('const TSequence *', seq) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tsequence_set_interp(seq_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_shift_scale_time( - seq: "const TSequence *", shift: "const Interval *", duration: "const Interval *" -) -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) - shift_converted = _ffi.cast("const Interval *", shift) - duration_converted = _ffi.cast("const Interval *", duration) - result = _lib.tsequence_shift_scale_time( - seq_converted, shift_converted, duration_converted - ) +def tsequence_shift_scale_time(seq: 'const TSequence *', shift: 'const Interval *', duration: 'const Interval *') -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) + shift_converted = _ffi.cast('const Interval *', shift) + duration_converted = _ffi.cast('const Interval *', duration) + result = _lib.tsequence_shift_scale_time(seq_converted, shift_converted, duration_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_to_tinstant(seq: "const TSequence *") -> "TInstant *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_to_tinstant(seq: 'const TSequence *') -> 'TInstant *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_to_tinstant(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_to_tdiscseq(seq: "const TSequence *") -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_to_tdiscseq(seq: 'const TSequence *') -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_to_tdiscseq(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_to_tcontseq( - seq: "const TSequence *", interp: "interpType" -) -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) - interp_converted = _ffi.cast("interpType", interp) +def tsequence_to_tcontseq(seq: 'const TSequence *', interp: 'interpType') -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tsequence_to_tcontseq(seq_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_to_tsequenceset(seq: "const TSequence *") -> "TSequenceSet *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_to_tsequenceset(seq: 'const TSequence *') -> 'TSequenceSet *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_to_tsequenceset(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_to_tsequenceset_interp( - seq: "const TSequence *", interp: "interpType" -) -> "TSequenceSet *": - seq_converted = _ffi.cast("const TSequence *", seq) - interp_converted = _ffi.cast("interpType", interp) +def tsequence_to_tsequenceset_interp(seq: 'const TSequence *', interp: 'interpType') -> 'TSequenceSet *': + seq_converted = _ffi.cast('const TSequence *', seq) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tsequence_to_tsequenceset_interp(seq_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_append_tinstant( - ss: "TSequenceSet *", - inst: "const TInstant *", - maxdist: float, - maxt: "const Interval *", - expand: bool, -) -> "TSequenceSet *": - ss_converted = _ffi.cast("TSequenceSet *", ss) - inst_converted = _ffi.cast("const TInstant *", inst) - maxt_converted = _ffi.cast("const Interval *", maxt) - result = _lib.tsequenceset_append_tinstant( - ss_converted, inst_converted, maxdist, maxt_converted, expand - ) +def tsequenceset_append_tinstant(ss: 'TSequenceSet *', inst: 'const TInstant *', maxdist: float, maxt: 'const Interval *', expand: bool) -> 'TSequenceSet *': + ss_converted = _ffi.cast('TSequenceSet *', ss) + inst_converted = _ffi.cast('const TInstant *', inst) + maxt_converted = _ffi.cast('const Interval *', maxt) + result = _lib.tsequenceset_append_tinstant(ss_converted, inst_converted, maxdist, maxt_converted, expand) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_append_tsequence( - ss: "TSequenceSet *", seq: "const TSequence *", expand: bool -) -> "TSequenceSet *": - ss_converted = _ffi.cast("TSequenceSet *", ss) - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequenceset_append_tsequence(ss: 'TSequenceSet *', seq: 'const TSequence *', expand: bool) -> 'TSequenceSet *': + ss_converted = _ffi.cast('TSequenceSet *', ss) + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequenceset_append_tsequence(ss_converted, seq_converted, expand) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_merge( - ss1: "const TSequenceSet *", ss2: "const TSequenceSet *" -) -> "TSequenceSet *": - ss1_converted = _ffi.cast("const TSequenceSet *", ss1) - ss2_converted = _ffi.cast("const TSequenceSet *", ss2) +def tsequenceset_merge(ss1: 'const TSequenceSet *', ss2: 'const TSequenceSet *') -> 'TSequenceSet *': + ss1_converted = _ffi.cast('const TSequenceSet *', ss1) + ss2_converted = _ffi.cast('const TSequenceSet *', ss2) result = _lib.tsequenceset_merge(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_merge_array( - seqsets: "const TSequenceSet **", count: int -) -> "TSequenceSet *": - seqsets_converted = [_ffi.cast("const TSequenceSet *", x) for x in seqsets] +def tsequenceset_merge_array(seqsets: 'const TSequenceSet **', count: int) -> 'TSequenceSet *': + seqsets_converted = [_ffi.cast('const TSequenceSet *', x) for x in seqsets] result = _lib.tsequenceset_merge_array(seqsets_converted, count) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_set_interp( - ss: "const TSequenceSet *", interp: "interpType" -) -> "Temporal *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - interp_converted = _ffi.cast("interpType", interp) +def tsequenceset_set_interp(ss: 'const TSequenceSet *', interp: 'interpType') -> 'Temporal *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + interp_converted = _ffi.cast('interpType', interp) result = _lib.tsequenceset_set_interp(ss_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_shift_scale_value( - ss: "const TSequenceSet *", - start: "Datum", - width: "Datum", - hasshift: bool, - haswidth: bool, -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - start_converted = _ffi.cast("Datum", start) - width_converted = _ffi.cast("Datum", width) - result = _lib.tnumberseqset_shift_scale_value( - ss_converted, start_converted, width_converted, hasshift, haswidth - ) +def tnumberseqset_shift_scale_value(ss: 'const TSequenceSet *', start: 'Datum', width: 'Datum', hasshift: bool, haswidth: bool) -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + start_converted = _ffi.cast('Datum', start) + width_converted = _ffi.cast('Datum', width) + result = _lib.tnumberseqset_shift_scale_value(ss_converted, start_converted, width_converted, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_shift_scale_time( - ss: "const TSequenceSet *", start: "const Interval *", duration: "const Interval *" -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - start_converted = _ffi.cast("const Interval *", start) - duration_converted = _ffi.cast("const Interval *", duration) - result = _lib.tsequenceset_shift_scale_time( - ss_converted, start_converted, duration_converted - ) +def tsequenceset_shift_scale_time(ss: 'const TSequenceSet *', start: 'const Interval *', duration: 'const Interval *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + start_converted = _ffi.cast('const Interval *', start) + duration_converted = _ffi.cast('const Interval *', duration) + result = _lib.tsequenceset_shift_scale_time(ss_converted, start_converted, duration_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_to_tinstant(ss: "const TSequenceSet *") -> "TInstant *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_to_tinstant(ss: 'const TSequenceSet *') -> 'TInstant *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_to_tinstant(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_to_discrete(ss: "const TSequenceSet *") -> "TSequence *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_to_discrete(ss: 'const TSequenceSet *') -> 'TSequence *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_to_discrete(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_to_step(ss: "const TSequenceSet *") -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_to_step(ss: 'const TSequenceSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_to_step(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_to_linear(ss: "const TSequenceSet *") -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_to_linear(ss: 'const TSequenceSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_to_linear(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_to_tsequence(ss: "const TSequenceSet *") -> "TSequence *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_to_tsequence(ss: 'const TSequenceSet *') -> 'TSequence *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_to_tsequence(ss_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_bbox_restrict_set(temp: "const Temporal *", set: "const Set *") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - set_converted = _ffi.cast("const Set *", set) +def temporal_bbox_restrict_set(temp: 'const Temporal *', set: 'const Set *') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + set_converted = _ffi.cast('const Set *', set) result = _lib.temporal_bbox_restrict_set(temp_converted, set_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_minmax( - temp: "const Temporal *", min: bool, atfunc: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_restrict_minmax(temp: 'const Temporal *', min: bool, atfunc: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_restrict_minmax(temp_converted, min, atfunc) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_tstzspan( - temp: "const Temporal *", s: "const Span *", atfunc: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Span *", s) +def temporal_restrict_tstzspan(temp: 'const Temporal *', s: 'const Span *', atfunc: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Span *', s) result = _lib.temporal_restrict_tstzspan(temp_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_tstzspanset( - temp: "const Temporal *", ss: "const SpanSet *", atfunc: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def temporal_restrict_tstzspanset(temp: 'const Temporal *', ss: 'const SpanSet *', atfunc: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.temporal_restrict_tstzspanset(temp_converted, ss_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_timestamptz( - temp: "const Temporal *", t: int, atfunc: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) +def temporal_restrict_timestamptz(temp: 'const Temporal *', t: int, atfunc: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.temporal_restrict_timestamptz(temp_converted, t_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_tstzset( - temp: "const Temporal *", s: "const Set *", atfunc: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - s_converted = _ffi.cast("const Set *", s) +def temporal_restrict_tstzset(temp: 'const Temporal *', s: 'const Set *', atfunc: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + s_converted = _ffi.cast('const Set *', s) result = _lib.temporal_restrict_tstzset(temp_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_value( - temp: "const Temporal *", value: "Datum", atfunc: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def temporal_restrict_value(temp: 'const Temporal *', value: 'Datum', atfunc: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + value_converted = _ffi.cast('Datum', value) result = _lib.temporal_restrict_value(temp_converted, value_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_values( - temp: "const Temporal *", set: "const Set *", atfunc: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - set_converted = _ffi.cast("const Set *", set) +def temporal_restrict_values(temp: 'const Temporal *', set: 'const Set *', atfunc: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + set_converted = _ffi.cast('const Set *', set) result = _lib.temporal_restrict_values(temp_converted, set_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def temporal_value_at_timestamptz( - temp: "const Temporal *", t: int, strict: bool -) -> "Datum *": - temp_converted = _ffi.cast("const Temporal *", temp) - t_converted = _ffi.cast("TimestampTz", t) - out_result = _ffi.new("Datum *") - result = _lib.temporal_value_at_timestamptz( - temp_converted, t_converted, strict, out_result - ) +def temporal_value_at_timestamptz(temp: 'const Temporal *', t: int, strict: bool) -> 'Datum *': + temp_converted = _ffi.cast('const Temporal *', temp) + t_converted = _ffi.cast('TimestampTz', t) + out_result = _ffi.new('Datum *') + result = _lib.temporal_value_at_timestamptz(temp_converted, t_converted, strict, out_result) _check_error() if result: return out_result if out_result != _ffi.NULL else None return None -def tinstant_restrict_tstzspan( - inst: "const TInstant *", period: "const Span *", atfunc: bool -) -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) - period_converted = _ffi.cast("const Span *", period) +def tinstant_restrict_tstzspan(inst: 'const TInstant *', period: 'const Span *', atfunc: bool) -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) + period_converted = _ffi.cast('const Span *', period) result = _lib.tinstant_restrict_tstzspan(inst_converted, period_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tinstant_restrict_tstzspanset( - inst: "const TInstant *", ss: "const SpanSet *", atfunc: bool -) -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tinstant_restrict_tstzspanset(inst: 'const TInstant *', ss: 'const SpanSet *', atfunc: bool) -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tinstant_restrict_tstzspanset(inst_converted, ss_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tinstant_restrict_timestamptz( - inst: "const TInstant *", t: int, atfunc: bool -) -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) - t_converted = _ffi.cast("TimestampTz", t) +def tinstant_restrict_timestamptz(inst: 'const TInstant *', t: int, atfunc: bool) -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tinstant_restrict_timestamptz(inst_converted, t_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tinstant_restrict_tstzset( - inst: "const TInstant *", s: "const Set *", atfunc: bool -) -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) - s_converted = _ffi.cast("const Set *", s) +def tinstant_restrict_tstzset(inst: 'const TInstant *', s: 'const Set *', atfunc: bool) -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) + s_converted = _ffi.cast('const Set *', s) result = _lib.tinstant_restrict_tstzset(inst_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tinstant_restrict_value( - inst: "const TInstant *", value: "Datum", atfunc: bool -) -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) - value_converted = _ffi.cast("Datum", value) +def tinstant_restrict_value(inst: 'const TInstant *', value: 'Datum', atfunc: bool) -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) + value_converted = _ffi.cast('Datum', value) result = _lib.tinstant_restrict_value(inst_converted, value_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tinstant_restrict_values( - inst: "const TInstant *", set: "const Set *", atfunc: bool -) -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) - set_converted = _ffi.cast("const Set *", set) +def tinstant_restrict_values(inst: 'const TInstant *', set: 'const Set *', atfunc: bool) -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) + set_converted = _ffi.cast('const Set *', set) result = _lib.tinstant_restrict_values(inst_converted, set_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumber_restrict_span( - temp: "const Temporal *", span: "const Span *", atfunc: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - span_converted = _ffi.cast("const Span *", span) +def tnumber_restrict_span(temp: 'const Temporal *', span: 'const Span *', atfunc: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + span_converted = _ffi.cast('const Span *', span) result = _lib.tnumber_restrict_span(temp_converted, span_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumber_restrict_spanset( - temp: "const Temporal *", ss: "const SpanSet *", atfunc: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tnumber_restrict_spanset(temp: 'const Temporal *', ss: 'const SpanSet *', atfunc: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tnumber_restrict_spanset(temp_converted, ss_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumberinst_restrict_span( - inst: "const TInstant *", span: "const Span *", atfunc: bool -) -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) - span_converted = _ffi.cast("const Span *", span) +def tnumberinst_restrict_span(inst: 'const TInstant *', span: 'const Span *', atfunc: bool) -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) + span_converted = _ffi.cast('const Span *', span) result = _lib.tnumberinst_restrict_span(inst_converted, span_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumberinst_restrict_spanset( - inst: "const TInstant *", ss: "const SpanSet *", atfunc: bool -) -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tnumberinst_restrict_spanset(inst: 'const TInstant *', ss: 'const SpanSet *', atfunc: bool) -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tnumberinst_restrict_spanset(inst_converted, ss_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_restrict_span( - ss: "const TSequenceSet *", span: "const Span *", atfunc: bool -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - span_converted = _ffi.cast("const Span *", span) +def tnumberseqset_restrict_span(ss: 'const TSequenceSet *', span: 'const Span *', atfunc: bool) -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + span_converted = _ffi.cast('const Span *', span) result = _lib.tnumberseqset_restrict_span(ss_converted, span_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_restrict_spanset( - ss: "const TSequenceSet *", spanset: "const SpanSet *", atfunc: bool -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - spanset_converted = _ffi.cast("const SpanSet *", spanset) - result = _lib.tnumberseqset_restrict_spanset( - ss_converted, spanset_converted, atfunc - ) +def tnumberseqset_restrict_spanset(ss: 'const TSequenceSet *', spanset: 'const SpanSet *', atfunc: bool) -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + spanset_converted = _ffi.cast('const SpanSet *', spanset) + result = _lib.tnumberseqset_restrict_spanset(ss_converted, spanset_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tpoint_restrict_geom_time( - temp: "const Temporal *", - gs: "const GSERIALIZED *", - zspan: "const Span *", - period: "const Span *", - atfunc: bool, -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - zspan_converted = _ffi.cast("const Span *", zspan) - period_converted = _ffi.cast("const Span *", period) - result = _lib.tpoint_restrict_geom_time( - temp_converted, gs_converted, zspan_converted, period_converted, atfunc - ) +def tpoint_restrict_geom_time(temp: 'const Temporal *', gs: 'const GSERIALIZED *', zspan: 'const Span *', period: 'const Span *', atfunc: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + zspan_converted = _ffi.cast('const Span *', zspan) + period_converted = _ffi.cast('const Span *', period) + result = _lib.tpoint_restrict_geom_time(temp_converted, gs_converted, zspan_converted, period_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tpoint_restrict_stbox( - temp: "const Temporal *", box: "const STBox *", border_inc: bool, atfunc: bool -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - box_converted = _ffi.cast("const STBox *", box) - result = _lib.tpoint_restrict_stbox( - temp_converted, box_converted, border_inc, atfunc - ) +def tpoint_restrict_stbox(temp: 'const Temporal *', box: 'const STBox *', border_inc: bool, atfunc: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + box_converted = _ffi.cast('const STBox *', box) + result = _lib.tpoint_restrict_stbox(temp_converted, box_converted, border_inc, atfunc) _check_error() return result if result != _ffi.NULL else None -def tpointinst_restrict_geom_time( - inst: "const TInstant *", - gs: "const GSERIALIZED *", - zspan: "const Span *", - period: "const Span *", - atfunc: bool, -) -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - zspan_converted = _ffi.cast("const Span *", zspan) - period_converted = _ffi.cast("const Span *", period) - result = _lib.tpointinst_restrict_geom_time( - inst_converted, gs_converted, zspan_converted, period_converted, atfunc - ) +def tpointinst_restrict_geom_time(inst: 'const TInstant *', gs: 'const GSERIALIZED *', zspan: 'const Span *', period: 'const Span *', atfunc: bool) -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + zspan_converted = _ffi.cast('const Span *', zspan) + period_converted = _ffi.cast('const Span *', period) + result = _lib.tpointinst_restrict_geom_time(inst_converted, gs_converted, zspan_converted, period_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tpointinst_restrict_stbox( - inst: "const TInstant *", box: "const STBox *", border_inc: bool, atfunc: bool -) -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) - box_converted = _ffi.cast("const STBox *", box) - result = _lib.tpointinst_restrict_stbox( - inst_converted, box_converted, border_inc, atfunc - ) +def tpointinst_restrict_stbox(inst: 'const TInstant *', box: 'const STBox *', border_inc: bool, atfunc: bool) -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) + box_converted = _ffi.cast('const STBox *', box) + result = _lib.tpointinst_restrict_stbox(inst_converted, box_converted, border_inc, atfunc) _check_error() return result if result != _ffi.NULL else None -def tpointseq_restrict_geom_time( - seq: "const TSequence *", - gs: "const GSERIALIZED *", - zspan: "const Span *", - period: "const Span *", - atfunc: bool, -) -> "Temporal *": - seq_converted = _ffi.cast("const TSequence *", seq) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - zspan_converted = _ffi.cast("const Span *", zspan) - period_converted = _ffi.cast("const Span *", period) - result = _lib.tpointseq_restrict_geom_time( - seq_converted, gs_converted, zspan_converted, period_converted, atfunc - ) +def tpointseq_restrict_geom_time(seq: 'const TSequence *', gs: 'const GSERIALIZED *', zspan: 'const Span *', period: 'const Span *', atfunc: bool) -> 'Temporal *': + seq_converted = _ffi.cast('const TSequence *', seq) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + zspan_converted = _ffi.cast('const Span *', zspan) + period_converted = _ffi.cast('const Span *', period) + result = _lib.tpointseq_restrict_geom_time(seq_converted, gs_converted, zspan_converted, period_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tpointseq_restrict_stbox( - seq: "const TSequence *", box: "const STBox *", border_inc: bool, atfunc: bool -) -> "Temporal *": - seq_converted = _ffi.cast("const TSequence *", seq) - box_converted = _ffi.cast("const STBox *", box) - result = _lib.tpointseq_restrict_stbox( - seq_converted, box_converted, border_inc, atfunc - ) +def tpointseq_restrict_stbox(seq: 'const TSequence *', box: 'const STBox *', border_inc: bool, atfunc: bool) -> 'Temporal *': + seq_converted = _ffi.cast('const TSequence *', seq) + box_converted = _ffi.cast('const STBox *', box) + result = _lib.tpointseq_restrict_stbox(seq_converted, box_converted, border_inc, atfunc) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_restrict_geom_time( - ss: "const TSequenceSet *", - gs: "const GSERIALIZED *", - zspan: "const Span *", - period: "const Span *", - atfunc: bool, -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - gs_converted = _ffi.cast("const GSERIALIZED *", gs) - zspan_converted = _ffi.cast("const Span *", zspan) - period_converted = _ffi.cast("const Span *", period) - result = _lib.tpointseqset_restrict_geom_time( - ss_converted, gs_converted, zspan_converted, period_converted, atfunc - ) +def tpointseqset_restrict_geom_time(ss: 'const TSequenceSet *', gs: 'const GSERIALIZED *', zspan: 'const Span *', period: 'const Span *', atfunc: bool) -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + gs_converted = _ffi.cast('const GSERIALIZED *', gs) + zspan_converted = _ffi.cast('const Span *', zspan) + period_converted = _ffi.cast('const Span *', period) + result = _lib.tpointseqset_restrict_geom_time(ss_converted, gs_converted, zspan_converted, period_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_restrict_stbox( - ss: "const TSequenceSet *", box: "const STBox *", border_inc: bool, atfunc: bool -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - box_converted = _ffi.cast("const STBox *", box) - result = _lib.tpointseqset_restrict_stbox( - ss_converted, box_converted, border_inc, atfunc - ) +def tpointseqset_restrict_stbox(ss: 'const TSequenceSet *', box: 'const STBox *', border_inc: bool, atfunc: bool) -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + box_converted = _ffi.cast('const STBox *', box) + result = _lib.tpointseqset_restrict_stbox(ss_converted, box_converted, border_inc, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequence_at_tstzspan(seq: "const TSequence *", s: "const Span *") -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) - s_converted = _ffi.cast("const Span *", s) +def tsequence_at_tstzspan(seq: 'const TSequence *', s: 'const Span *') -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) + s_converted = _ffi.cast('const Span *', s) result = _lib.tsequence_at_tstzspan(seq_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_at_timestamptz(seq: "const TSequence *", t: int) -> "TInstant *": - seq_converted = _ffi.cast("const TSequence *", seq) - t_converted = _ffi.cast("TimestampTz", t) +def tsequence_at_timestamptz(seq: 'const TSequence *', t: int) -> 'TInstant *': + seq_converted = _ffi.cast('const TSequence *', seq) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tsequence_at_timestamptz(seq_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_minmax( - seq: "const TSequence *", min: bool, atfunc: bool -) -> "TSequenceSet *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_restrict_minmax(seq: 'const TSequence *', min: bool, atfunc: bool) -> 'TSequenceSet *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_restrict_minmax(seq_converted, min, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_tstzspan( - seq: "const TSequence *", s: "const Span *", atfunc: bool -) -> "Temporal *": - seq_converted = _ffi.cast("const TSequence *", seq) - s_converted = _ffi.cast("const Span *", s) +def tsequence_restrict_tstzspan(seq: 'const TSequence *', s: 'const Span *', atfunc: bool) -> 'Temporal *': + seq_converted = _ffi.cast('const TSequence *', seq) + s_converted = _ffi.cast('const Span *', s) result = _lib.tsequence_restrict_tstzspan(seq_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_tstzspanset( - seq: "const TSequence *", ss: "const SpanSet *", atfunc: bool -) -> "Temporal *": - seq_converted = _ffi.cast("const TSequence *", seq) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tsequence_restrict_tstzspanset(seq: 'const TSequence *', ss: 'const SpanSet *', atfunc: bool) -> 'Temporal *': + seq_converted = _ffi.cast('const TSequence *', seq) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tsequence_restrict_tstzspanset(seq_converted, ss_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_timestamptz( - seq: "const TSequence *", t: int, atfunc: bool -) -> "TInstant *": - seq_converted = _ffi.cast("const TSequence *", seq) - t_converted = _ffi.cast("TimestampTz", t) +def tsequence_restrict_timestamptz(seq: 'const TSequence *', t: int, atfunc: bool) -> 'TInstant *': + seq_converted = _ffi.cast('const TSequence *', seq) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tsequence_restrict_timestamptz(seq_converted, t_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_tstzset( - seq: "const TSequence *", s: "const Set *", atfunc: bool -) -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) - s_converted = _ffi.cast("const Set *", s) +def tsequence_restrict_tstzset(seq: 'const TSequence *', s: 'const Set *', atfunc: bool) -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) + s_converted = _ffi.cast('const Set *', s) result = _lib.tsequence_restrict_tstzset(seq_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_value( - seq: "const TSequence *", value: "Datum", atfunc: bool -) -> "TSequenceSet *": - seq_converted = _ffi.cast("const TSequence *", seq) - value_converted = _ffi.cast("Datum", value) +def tsequence_restrict_value(seq: 'const TSequence *', value: 'Datum', atfunc: bool) -> 'TSequenceSet *': + seq_converted = _ffi.cast('const TSequence *', seq) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequence_restrict_value(seq_converted, value_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_values( - seq: "const TSequence *", s: "const Set *", atfunc: bool -) -> "TSequenceSet *": - seq_converted = _ffi.cast("const TSequence *", seq) - s_converted = _ffi.cast("const Set *", s) +def tsequence_restrict_values(seq: 'const TSequence *', s: 'const Set *', atfunc: bool) -> 'TSequenceSet *': + seq_converted = _ffi.cast('const TSequence *', seq) + s_converted = _ffi.cast('const Set *', s) result = _lib.tsequence_restrict_values(seq_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_minmax( - ss: "const TSequenceSet *", min: bool, atfunc: bool -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_restrict_minmax(ss: 'const TSequenceSet *', min: bool, atfunc: bool) -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_restrict_minmax(ss_converted, min, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_tstzspan( - ss: "const TSequenceSet *", s: "const Span *", atfunc: bool -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def tsequenceset_restrict_tstzspan(ss: 'const TSequenceSet *', s: 'const Span *', atfunc: bool) -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.tsequenceset_restrict_tstzspan(ss_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_tstzspanset( - ss: "const TSequenceSet *", ps: "const SpanSet *", atfunc: bool -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - ps_converted = _ffi.cast("const SpanSet *", ps) +def tsequenceset_restrict_tstzspanset(ss: 'const TSequenceSet *', ps: 'const SpanSet *', atfunc: bool) -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + ps_converted = _ffi.cast('const SpanSet *', ps) result = _lib.tsequenceset_restrict_tstzspanset(ss_converted, ps_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_timestamptz( - ss: "const TSequenceSet *", t: int, atfunc: bool -) -> "Temporal *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def tsequenceset_restrict_timestamptz(ss: 'const TSequenceSet *', t: int, atfunc: bool) -> 'Temporal *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tsequenceset_restrict_timestamptz(ss_converted, t_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_tstzset( - ss: "const TSequenceSet *", s: "const Set *", atfunc: bool -) -> "Temporal *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - s_converted = _ffi.cast("const Set *", s) +def tsequenceset_restrict_tstzset(ss: 'const TSequenceSet *', s: 'const Set *', atfunc: bool) -> 'Temporal *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + s_converted = _ffi.cast('const Set *', s) result = _lib.tsequenceset_restrict_tstzset(ss_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_value( - ss: "const TSequenceSet *", value: "Datum", atfunc: bool -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - value_converted = _ffi.cast("Datum", value) +def tsequenceset_restrict_value(ss: 'const TSequenceSet *', value: 'Datum', atfunc: bool) -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequenceset_restrict_value(ss_converted, value_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_values( - ss: "const TSequenceSet *", s: "const Set *", atfunc: bool -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - s_converted = _ffi.cast("const Set *", s) +def tsequenceset_restrict_values(ss: 'const TSequenceSet *', s: 'const Set *', atfunc: bool) -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + s_converted = _ffi.cast('const Set *', s) result = _lib.tsequenceset_restrict_values(ss_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_derivative(seq: "const TSequence *") -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_derivative(seq: 'const TSequence *') -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tnumberseq_derivative(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_derivative(ss: "const TSequenceSet *") -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_derivative(ss: 'const TSequenceSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tnumberseqset_derivative(ss_converted) _check_error() return result if result != _ffi.NULL else None -def distance_tnumber_number( - temp: "const Temporal *", value: "Datum", valuetype: "meosType", restype: "meosType" -) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) - valuetype_converted = _ffi.cast("meosType", valuetype) - restype_converted = _ffi.cast("meosType", restype) - result = _lib.distance_tnumber_number( - temp_converted, value_converted, valuetype_converted, restype_converted - ) +def distance_tnumber_number(temp: 'const Temporal *', value: 'Datum', valuetype: 'meosType', restype: 'meosType') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) + value_converted = _ffi.cast('Datum', value) + valuetype_converted = _ffi.cast('meosType', valuetype) + restype_converted = _ffi.cast('meosType', restype) + result = _lib.distance_tnumber_number(temp_converted, value_converted, valuetype_converted, restype_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnumber_number( - temp: "const Temporal *", value: "Datum", basetype: "meosType" -) -> "double": - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) - basetype_converted = _ffi.cast("meosType", basetype) - result = _lib.nad_tnumber_number( - temp_converted, value_converted, basetype_converted - ) +def nad_tnumber_number(temp: 'const Temporal *', value: 'Datum', basetype: 'meosType') -> 'double': + temp_converted = _ffi.cast('const Temporal *', temp) + value_converted = _ffi.cast('Datum', value) + basetype_converted = _ffi.cast('meosType', basetype) + result = _lib.nad_tnumber_number(temp_converted, value_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_always_eq(temp: "const Temporal *", value: "Datum") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def temporal_always_eq(temp: 'const Temporal *', value: 'Datum') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + value_converted = _ffi.cast('Datum', value) result = _lib.temporal_always_eq(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_always_le(temp: "const Temporal *", value: "Datum") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def temporal_always_le(temp: 'const Temporal *', value: 'Datum') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + value_converted = _ffi.cast('Datum', value) result = _lib.temporal_always_le(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_always_lt(temp: "const Temporal *", value: "Datum") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def temporal_always_lt(temp: 'const Temporal *', value: 'Datum') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + value_converted = _ffi.cast('Datum', value) result = _lib.temporal_always_lt(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_ever_eq(temp: "const Temporal *", value: "Datum") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def temporal_ever_eq(temp: 'const Temporal *', value: 'Datum') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + value_converted = _ffi.cast('Datum', value) result = _lib.temporal_ever_eq(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_ever_le(temp: "const Temporal *", value: "Datum") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def temporal_ever_le(temp: 'const Temporal *', value: 'Datum') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + value_converted = _ffi.cast('Datum', value) result = _lib.temporal_ever_le(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_ever_lt(temp: "const Temporal *", value: "Datum") -> "bool": - temp_converted = _ffi.cast("const Temporal *", temp) - value_converted = _ffi.cast("Datum", value) +def temporal_ever_lt(temp: 'const Temporal *', value: 'Datum') -> 'bool': + temp_converted = _ffi.cast('const Temporal *', temp) + value_converted = _ffi.cast('Datum', value) result = _lib.temporal_ever_lt(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_always_eq(inst: "const TInstant *", value: "Datum") -> "bool": - inst_converted = _ffi.cast("const TInstant *", inst) - value_converted = _ffi.cast("Datum", value) +def tinstant_always_eq(inst: 'const TInstant *', value: 'Datum') -> 'bool': + inst_converted = _ffi.cast('const TInstant *', inst) + value_converted = _ffi.cast('Datum', value) result = _lib.tinstant_always_eq(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_always_le(inst: "const TInstant *", value: "Datum") -> "bool": - inst_converted = _ffi.cast("const TInstant *", inst) - value_converted = _ffi.cast("Datum", value) +def tinstant_always_le(inst: 'const TInstant *', value: 'Datum') -> 'bool': + inst_converted = _ffi.cast('const TInstant *', inst) + value_converted = _ffi.cast('Datum', value) result = _lib.tinstant_always_le(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_always_lt(inst: "const TInstant *", value: "Datum") -> "bool": - inst_converted = _ffi.cast("const TInstant *", inst) - value_converted = _ffi.cast("Datum", value) +def tinstant_always_lt(inst: 'const TInstant *', value: 'Datum') -> 'bool': + inst_converted = _ffi.cast('const TInstant *', inst) + value_converted = _ffi.cast('Datum', value) result = _lib.tinstant_always_lt(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_ever_eq(inst: "const TInstant *", value: "Datum") -> "bool": - inst_converted = _ffi.cast("const TInstant *", inst) - value_converted = _ffi.cast("Datum", value) +def tinstant_ever_eq(inst: 'const TInstant *', value: 'Datum') -> 'bool': + inst_converted = _ffi.cast('const TInstant *', inst) + value_converted = _ffi.cast('Datum', value) result = _lib.tinstant_ever_eq(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_ever_le(inst: "const TInstant *", value: "Datum") -> "bool": - inst_converted = _ffi.cast("const TInstant *", inst) - value_converted = _ffi.cast("Datum", value) +def tinstant_ever_le(inst: 'const TInstant *', value: 'Datum') -> 'bool': + inst_converted = _ffi.cast('const TInstant *', inst) + value_converted = _ffi.cast('Datum', value) result = _lib.tinstant_ever_le(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_ever_lt(inst: "const TInstant *", value: "Datum") -> "bool": - inst_converted = _ffi.cast("const TInstant *", inst) - value_converted = _ffi.cast("Datum", value) +def tinstant_ever_lt(inst: 'const TInstant *', value: 'Datum') -> 'bool': + inst_converted = _ffi.cast('const TInstant *', inst) + value_converted = _ffi.cast('Datum', value) result = _lib.tinstant_ever_lt(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointinst_always_eq(inst: "const TInstant *", value: "Datum") -> "bool": - inst_converted = _ffi.cast("const TInstant *", inst) - value_converted = _ffi.cast("Datum", value) +def tpointinst_always_eq(inst: 'const TInstant *', value: 'Datum') -> 'bool': + inst_converted = _ffi.cast('const TInstant *', inst) + value_converted = _ffi.cast('Datum', value) result = _lib.tpointinst_always_eq(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointinst_ever_eq(inst: "const TInstant *", value: "Datum") -> "bool": - inst_converted = _ffi.cast("const TInstant *", inst) - value_converted = _ffi.cast("Datum", value) +def tpointinst_ever_eq(inst: 'const TInstant *', value: 'Datum') -> 'bool': + inst_converted = _ffi.cast('const TInstant *', inst) + value_converted = _ffi.cast('Datum', value) result = _lib.tpointinst_ever_eq(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_always_eq(seq: "const TSequence *", value: "Datum") -> "bool": - seq_converted = _ffi.cast("const TSequence *", seq) - value_converted = _ffi.cast("Datum", value) +def tpointseq_always_eq(seq: 'const TSequence *', value: 'Datum') -> 'bool': + seq_converted = _ffi.cast('const TSequence *', seq) + value_converted = _ffi.cast('Datum', value) result = _lib.tpointseq_always_eq(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_ever_eq(seq: "const TSequence *", value: "Datum") -> "bool": - seq_converted = _ffi.cast("const TSequence *", seq) - value_converted = _ffi.cast("Datum", value) +def tpointseq_ever_eq(seq: 'const TSequence *', value: 'Datum') -> 'bool': + seq_converted = _ffi.cast('const TSequence *', seq) + value_converted = _ffi.cast('Datum', value) result = _lib.tpointseq_ever_eq(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_always_eq(ss: "const TSequenceSet *", value: "Datum") -> "bool": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - value_converted = _ffi.cast("Datum", value) +def tpointseqset_always_eq(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + value_converted = _ffi.cast('Datum', value) result = _lib.tpointseqset_always_eq(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_ever_eq(ss: "const TSequenceSet *", value: "Datum") -> "bool": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - value_converted = _ffi.cast("Datum", value) +def tpointseqset_ever_eq(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + value_converted = _ffi.cast('Datum', value) result = _lib.tpointseqset_ever_eq(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_always_eq(seq: "const TSequence *", value: "Datum") -> "bool": - seq_converted = _ffi.cast("const TSequence *", seq) - value_converted = _ffi.cast("Datum", value) +def tsequence_always_eq(seq: 'const TSequence *', value: 'Datum') -> 'bool': + seq_converted = _ffi.cast('const TSequence *', seq) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequence_always_eq(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_always_le(seq: "const TSequence *", value: "Datum") -> "bool": - seq_converted = _ffi.cast("const TSequence *", seq) - value_converted = _ffi.cast("Datum", value) +def tsequence_always_le(seq: 'const TSequence *', value: 'Datum') -> 'bool': + seq_converted = _ffi.cast('const TSequence *', seq) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequence_always_le(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_always_lt(seq: "const TSequence *", value: "Datum") -> "bool": - seq_converted = _ffi.cast("const TSequence *", seq) - value_converted = _ffi.cast("Datum", value) +def tsequence_always_lt(seq: 'const TSequence *', value: 'Datum') -> 'bool': + seq_converted = _ffi.cast('const TSequence *', seq) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequence_always_lt(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_ever_eq(seq: "const TSequence *", value: "Datum") -> "bool": - seq_converted = _ffi.cast("const TSequence *", seq) - value_converted = _ffi.cast("Datum", value) +def tsequence_ever_eq(seq: 'const TSequence *', value: 'Datum') -> 'bool': + seq_converted = _ffi.cast('const TSequence *', seq) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequence_ever_eq(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_ever_le(seq: "const TSequence *", value: "Datum") -> "bool": - seq_converted = _ffi.cast("const TSequence *", seq) - value_converted = _ffi.cast("Datum", value) +def tsequence_ever_le(seq: 'const TSequence *', value: 'Datum') -> 'bool': + seq_converted = _ffi.cast('const TSequence *', seq) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequence_ever_le(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_ever_lt(seq: "const TSequence *", value: "Datum") -> "bool": - seq_converted = _ffi.cast("const TSequence *", seq) - value_converted = _ffi.cast("Datum", value) +def tsequence_ever_lt(seq: 'const TSequence *', value: 'Datum') -> 'bool': + seq_converted = _ffi.cast('const TSequence *', seq) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequence_ever_lt(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_always_eq(ss: "const TSequenceSet *", value: "Datum") -> "bool": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - value_converted = _ffi.cast("Datum", value) +def tsequenceset_always_eq(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequenceset_always_eq(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_always_le(ss: "const TSequenceSet *", value: "Datum") -> "bool": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - value_converted = _ffi.cast("Datum", value) +def tsequenceset_always_le(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequenceset_always_le(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_always_lt(ss: "const TSequenceSet *", value: "Datum") -> "bool": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - value_converted = _ffi.cast("Datum", value) +def tsequenceset_always_lt(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequenceset_always_lt(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_ever_eq(ss: "const TSequenceSet *", value: "Datum") -> "bool": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - value_converted = _ffi.cast("Datum", value) +def tsequenceset_ever_eq(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequenceset_ever_eq(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_ever_le(ss: "const TSequenceSet *", value: "Datum") -> "bool": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - value_converted = _ffi.cast("Datum", value) +def tsequenceset_ever_le(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequenceset_ever_le(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_ever_lt(ss: "const TSequenceSet *", value: "Datum") -> "bool": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - value_converted = _ffi.cast("Datum", value) +def tsequenceset_ever_lt(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + value_converted = _ffi.cast('Datum', value) result = _lib.tsequenceset_ever_lt(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_cmp(inst1: "const TInstant *", inst2: "const TInstant *") -> "int": - inst1_converted = _ffi.cast("const TInstant *", inst1) - inst2_converted = _ffi.cast("const TInstant *", inst2) +def tinstant_cmp(inst1: 'const TInstant *', inst2: 'const TInstant *') -> 'int': + inst1_converted = _ffi.cast('const TInstant *', inst1) + inst2_converted = _ffi.cast('const TInstant *', inst2) result = _lib.tinstant_cmp(inst1_converted, inst2_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_eq(inst1: "const TInstant *", inst2: "const TInstant *") -> "bool": - inst1_converted = _ffi.cast("const TInstant *", inst1) - inst2_converted = _ffi.cast("const TInstant *", inst2) +def tinstant_eq(inst1: 'const TInstant *', inst2: 'const TInstant *') -> 'bool': + inst1_converted = _ffi.cast('const TInstant *', inst1) + inst2_converted = _ffi.cast('const TInstant *', inst2) result = _lib.tinstant_eq(inst1_converted, inst2_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_cmp(seq1: "const TSequence *", seq2: "const TSequence *") -> "int": - seq1_converted = _ffi.cast("const TSequence *", seq1) - seq2_converted = _ffi.cast("const TSequence *", seq2) +def tsequence_cmp(seq1: 'const TSequence *', seq2: 'const TSequence *') -> 'int': + seq1_converted = _ffi.cast('const TSequence *', seq1) + seq2_converted = _ffi.cast('const TSequence *', seq2) result = _lib.tsequence_cmp(seq1_converted, seq2_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_eq(seq1: "const TSequence *", seq2: "const TSequence *") -> "bool": - seq1_converted = _ffi.cast("const TSequence *", seq1) - seq2_converted = _ffi.cast("const TSequence *", seq2) +def tsequence_eq(seq1: 'const TSequence *', seq2: 'const TSequence *') -> 'bool': + seq1_converted = _ffi.cast('const TSequence *', seq1) + seq2_converted = _ffi.cast('const TSequence *', seq2) result = _lib.tsequence_eq(seq1_converted, seq2_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_cmp(ss1: "const TSequenceSet *", ss2: "const TSequenceSet *") -> "int": - ss1_converted = _ffi.cast("const TSequenceSet *", ss1) - ss2_converted = _ffi.cast("const TSequenceSet *", ss2) +def tsequenceset_cmp(ss1: 'const TSequenceSet *', ss2: 'const TSequenceSet *') -> 'int': + ss1_converted = _ffi.cast('const TSequenceSet *', ss1) + ss2_converted = _ffi.cast('const TSequenceSet *', ss2) result = _lib.tsequenceset_cmp(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_eq(ss1: "const TSequenceSet *", ss2: "const TSequenceSet *") -> "bool": - ss1_converted = _ffi.cast("const TSequenceSet *", ss1) - ss2_converted = _ffi.cast("const TSequenceSet *", ss2) +def tsequenceset_eq(ss1: 'const TSequenceSet *', ss2: 'const TSequenceSet *') -> 'bool': + ss1_converted = _ffi.cast('const TSequenceSet *', ss1) + ss2_converted = _ffi.cast('const TSequenceSet *', ss2) result = _lib.tsequenceset_eq(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def tpointinst_srid(inst: "const TInstant *") -> "int": - inst_converted = _ffi.cast("const TInstant *", inst) +def tpointinst_srid(inst: 'const TInstant *') -> 'int': + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tpointinst_srid(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_trajectory(seq: "const TSequence *") -> "GSERIALIZED *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_trajectory(seq: 'const TSequence *') -> 'GSERIALIZED *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tpointseq_trajectory(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_azimuth(seq: "const TSequence *") -> "TSequenceSet *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_azimuth(seq: 'const TSequence *') -> 'TSequenceSet *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tpointseq_azimuth(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_cumulative_length( - seq: "const TSequence *", prevlength: float -) -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_cumulative_length(seq: 'const TSequence *', prevlength: float) -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tpointseq_cumulative_length(seq_converted, prevlength) _check_error() return result if result != _ffi.NULL else None -def tpointseq_is_simple(seq: "const TSequence *") -> "bool": - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_is_simple(seq: 'const TSequence *') -> 'bool': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tpointseq_is_simple(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_length(seq: "const TSequence *") -> "double": - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_length(seq: 'const TSequence *') -> 'double': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tpointseq_length(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_speed(seq: "const TSequence *") -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_speed(seq: 'const TSequence *') -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tpointseq_speed(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_srid(seq: "const TSequence *") -> "int": - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_srid(seq: 'const TSequence *') -> 'int': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tpointseq_srid(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_stboxes(seq: "const TSequence *") -> "Tuple['STBox *', 'int']": - seq_converted = _ffi.cast("const TSequence *", seq) - count = _ffi.new("int *") +def tpointseq_stboxes(seq: 'const TSequence *') -> "Tuple['STBox *', 'int']": + seq_converted = _ffi.cast('const TSequence *', seq) + count = _ffi.new('int *') result = _lib.tpointseq_stboxes(seq_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tpointseqset_azimuth(ss: "const TSequenceSet *") -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tpointseqset_azimuth(ss: 'const TSequenceSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tpointseqset_azimuth(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_cumulative_length(ss: "const TSequenceSet *") -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tpointseqset_cumulative_length(ss: 'const TSequenceSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tpointseqset_cumulative_length(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_is_simple(ss: "const TSequenceSet *") -> "bool": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tpointseqset_is_simple(ss: 'const TSequenceSet *') -> 'bool': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tpointseqset_is_simple(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_length(ss: "const TSequenceSet *") -> "double": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tpointseqset_length(ss: 'const TSequenceSet *') -> 'double': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tpointseqset_length(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_speed(ss: "const TSequenceSet *") -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tpointseqset_speed(ss: 'const TSequenceSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tpointseqset_speed(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_srid(ss: "const TSequenceSet *") -> "int": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tpointseqset_srid(ss: 'const TSequenceSet *') -> 'int': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tpointseqset_srid(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_stboxes(ss: "const TSequenceSet *") -> "Tuple['STBox *', 'int']": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - count = _ffi.new("int *") +def tpointseqset_stboxes(ss: 'const TSequenceSet *') -> "Tuple['STBox *', 'int']": + ss_converted = _ffi.cast('const TSequenceSet *', ss) + count = _ffi.new('int *') result = _lib.tpointseqset_stboxes(ss_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tpointseqset_trajectory(ss: "const TSequenceSet *") -> "GSERIALIZED *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tpointseqset_trajectory(ss: 'const TSequenceSet *') -> 'GSERIALIZED *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tpointseqset_trajectory(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_get_coord(temp: "const Temporal *", coord: int) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tpoint_get_coord(temp: 'const Temporal *', coord: int) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tpoint_get_coord(temp_converted, coord) _check_error() return result if result != _ffi.NULL else None -def tgeompointinst_tgeogpointinst(inst: "const TInstant *", oper: bool) -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) +def tgeompointinst_tgeogpointinst(inst: 'const TInstant *', oper: bool) -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) result = _lib.tgeompointinst_tgeogpointinst(inst_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tgeompointseq_tgeogpointseq(seq: "const TSequence *", oper: bool) -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tgeompointseq_tgeogpointseq(seq: 'const TSequence *', oper: bool) -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tgeompointseq_tgeogpointseq(seq_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tgeompointseqset_tgeogpointseqset( - ss: "const TSequenceSet *", oper: bool -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tgeompointseqset_tgeogpointseqset(ss: 'const TSequenceSet *', oper: bool) -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tgeompointseqset_tgeogpointseqset(ss_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_tgeogpoint(temp: "const Temporal *", oper: bool) -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def tgeompoint_tgeogpoint(temp: 'const Temporal *', oper: bool) -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tgeompoint_tgeogpoint(temp_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tpointinst_set_srid(inst: "const TInstant *", srid: int) -> "TInstant *": - inst_converted = _ffi.cast("const TInstant *", inst) - srid_converted = _ffi.cast("int32", srid) +def tpointinst_set_srid(inst: 'const TInstant *', srid: int) -> 'TInstant *': + inst_converted = _ffi.cast('const TInstant *', inst) + srid_converted = _ffi.cast('int32', srid) result = _lib.tpointinst_set_srid(inst_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_make_simple(seq: "const TSequence *") -> "Tuple['TSequence **', 'int']": - seq_converted = _ffi.cast("const TSequence *", seq) - count = _ffi.new("int *") +def tpointseq_make_simple(seq: 'const TSequence *') -> "Tuple['TSequence **', 'int']": + seq_converted = _ffi.cast('const TSequence *', seq) + count = _ffi.new('int *') result = _lib.tpointseq_make_simple(seq_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tpointseq_set_srid(seq: "const TSequence *", srid: int) -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) - srid_converted = _ffi.cast("int32", srid) +def tpointseq_set_srid(seq: 'const TSequence *', srid: int) -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) + srid_converted = _ffi.cast('int32', srid) result = _lib.tpointseq_set_srid(seq_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_make_simple( - ss: "const TSequenceSet *", -) -> "Tuple['TSequence **', 'int']": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - count = _ffi.new("int *") +def tpointseqset_make_simple(ss: 'const TSequenceSet *') -> "Tuple['TSequence **', 'int']": + ss_converted = _ffi.cast('const TSequenceSet *', ss) + count = _ffi.new('int *') result = _lib.tpointseqset_make_simple(ss_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tpointseqset_set_srid(ss: "const TSequenceSet *", srid: int) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - srid_converted = _ffi.cast("int32", srid) +def tpointseqset_set_srid(ss: 'const TSequenceSet *', srid: int) -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + srid_converted = _ffi.cast('int32', srid) result = _lib.tpointseqset_set_srid(ss_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_insert( - seq1: "const TSequence *", seq2: "const TSequence *", connect: bool -) -> "Temporal *": - seq1_converted = _ffi.cast("const TSequence *", seq1) - seq2_converted = _ffi.cast("const TSequence *", seq2) +def tsequence_insert(seq1: 'const TSequence *', seq2: 'const TSequence *', connect: bool) -> 'Temporal *': + seq1_converted = _ffi.cast('const TSequence *', seq1) + seq2_converted = _ffi.cast('const TSequence *', seq2) result = _lib.tsequence_insert(seq1_converted, seq2_converted, connect) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_insert( - ss1: "const TSequenceSet *", ss2: "const TSequenceSet *" -) -> "TSequenceSet *": - ss1_converted = _ffi.cast("const TSequenceSet *", ss1) - ss2_converted = _ffi.cast("const TSequenceSet *", ss2) +def tsequenceset_insert(ss1: 'const TSequenceSet *', ss2: 'const TSequenceSet *') -> 'TSequenceSet *': + ss1_converted = _ffi.cast('const TSequenceSet *', ss1) + ss2_converted = _ffi.cast('const TSequenceSet *', ss2) result = _lib.tsequenceset_insert(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_delete_timestamptz( - seq: "const TSequence *", t: int, connect: bool -) -> "Temporal *": - seq_converted = _ffi.cast("const TSequence *", seq) - t_converted = _ffi.cast("TimestampTz", t) +def tsequence_delete_timestamptz(seq: 'const TSequence *', t: int, connect: bool) -> 'Temporal *': + seq_converted = _ffi.cast('const TSequence *', seq) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tsequence_delete_timestamptz(seq_converted, t_converted, connect) _check_error() return result if result != _ffi.NULL else None -def tsequence_delete_tstzset( - seq: "const TSequence *", s: "const Set *", connect: bool -) -> "Temporal *": - seq_converted = _ffi.cast("const TSequence *", seq) - s_converted = _ffi.cast("const Set *", s) +def tsequence_delete_tstzset(seq: 'const TSequence *', s: 'const Set *', connect: bool) -> 'Temporal *': + seq_converted = _ffi.cast('const TSequence *', seq) + s_converted = _ffi.cast('const Set *', s) result = _lib.tsequence_delete_tstzset(seq_converted, s_converted, connect) _check_error() return result if result != _ffi.NULL else None -def tsequence_delete_tstzspan( - seq: "const TSequence *", s: "const Span *", connect: bool -) -> "Temporal *": - seq_converted = _ffi.cast("const TSequence *", seq) - s_converted = _ffi.cast("const Span *", s) +def tsequence_delete_tstzspan(seq: 'const TSequence *', s: 'const Span *', connect: bool) -> 'Temporal *': + seq_converted = _ffi.cast('const TSequence *', seq) + s_converted = _ffi.cast('const Span *', s) result = _lib.tsequence_delete_tstzspan(seq_converted, s_converted, connect) _check_error() return result if result != _ffi.NULL else None -def tsequence_delete_tstzspanset( - seq: "const TSequence *", ss: "const SpanSet *", connect: bool -) -> "Temporal *": - seq_converted = _ffi.cast("const TSequence *", seq) - ss_converted = _ffi.cast("const SpanSet *", ss) +def tsequence_delete_tstzspanset(seq: 'const TSequence *', ss: 'const SpanSet *', connect: bool) -> 'Temporal *': + seq_converted = _ffi.cast('const TSequence *', seq) + ss_converted = _ffi.cast('const SpanSet *', ss) result = _lib.tsequence_delete_tstzspanset(seq_converted, ss_converted, connect) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_delete_timestamptz( - ss: "const TSequenceSet *", t: int -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - t_converted = _ffi.cast("TimestampTz", t) +def tsequenceset_delete_timestamptz(ss: 'const TSequenceSet *', t: int) -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + t_converted = _ffi.cast('TimestampTz', t) result = _lib.tsequenceset_delete_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_delete_tstzset( - ss: "const TSequenceSet *", s: "const Set *" -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - s_converted = _ffi.cast("const Set *", s) +def tsequenceset_delete_tstzset(ss: 'const TSequenceSet *', s: 'const Set *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + s_converted = _ffi.cast('const Set *', s) result = _lib.tsequenceset_delete_tstzset(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_delete_tstzspan( - ss: "const TSequenceSet *", s: "const Span *" -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - s_converted = _ffi.cast("const Span *", s) +def tsequenceset_delete_tstzspan(ss: 'const TSequenceSet *', s: 'const Span *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + s_converted = _ffi.cast('const Span *', s) result = _lib.tsequenceset_delete_tstzspan(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_delete_tstzspanset( - ss: "const TSequenceSet *", ps: "const SpanSet *" -) -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) - ps_converted = _ffi.cast("const SpanSet *", ps) +def tsequenceset_delete_tstzspanset(ss: 'const TSequenceSet *', ps: 'const SpanSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) + ps_converted = _ffi.cast('const SpanSet *', ps) result = _lib.tsequenceset_delete_tstzspanset(ss_converted, ps_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_integral(seq: "const TSequence *") -> "double": - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_integral(seq: 'const TSequence *') -> 'double': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tnumberseq_integral(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_twavg(seq: "const TSequence *") -> "double": - seq_converted = _ffi.cast("const TSequence *", seq) +def tnumberseq_twavg(seq: 'const TSequence *') -> 'double': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tnumberseq_twavg(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_integral(ss: "const TSequenceSet *") -> "double": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_integral(ss: 'const TSequenceSet *') -> 'double': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tnumberseqset_integral(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_twavg(ss: "const TSequenceSet *") -> "double": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tnumberseqset_twavg(ss: 'const TSequenceSet *') -> 'double': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tnumberseqset_twavg(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_twcentroid(seq: "const TSequence *") -> "GSERIALIZED *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tpointseq_twcentroid(seq: 'const TSequence *') -> 'GSERIALIZED *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tpointseq_twcentroid(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_twcentroid(ss: "const TSequenceSet *") -> "GSERIALIZED *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tpointseqset_twcentroid(ss: 'const TSequenceSet *') -> 'GSERIALIZED *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tpointseqset_twcentroid(ss_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_compact(temp: "const Temporal *") -> "Temporal *": - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_compact(temp: 'const Temporal *') -> 'Temporal *': + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_compact(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_compact(seq: "const TSequence *") -> "TSequence *": - seq_converted = _ffi.cast("const TSequence *", seq) +def tsequence_compact(seq: 'const TSequence *') -> 'TSequence *': + seq_converted = _ffi.cast('const TSequence *', seq) result = _lib.tsequence_compact(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_compact(ss: "const TSequenceSet *") -> "TSequenceSet *": - ss_converted = _ffi.cast("const TSequenceSet *", ss) +def tsequenceset_compact(ss: 'const TSequenceSet *') -> 'TSequenceSet *': + ss_converted = _ffi.cast('const TSequenceSet *', ss) result = _lib.tsequenceset_compact(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_tand_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_tand_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_tand_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_tor_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tbool_tor_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tbool_tor_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_tagg_finalfn(state: "SkipList *") -> "Temporal *": - state_converted = _ffi.cast("SkipList *", state) +def temporal_tagg_finalfn(state: 'SkipList *') -> 'Temporal *': + state_converted = _ffi.cast('SkipList *', state) result = _lib.temporal_tagg_finalfn(state_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_tcount_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def temporal_tcount_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.temporal_tcount_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_tmax_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_tmax_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_tmax_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_tmin_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_tmin_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_tmin_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_tsum_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tfloat_tsum_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tfloat_tsum_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_wmax_transfn( - state: "SkipList *", temp: "const Temporal *", interval: "const Interval *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interval_converted = _ffi.cast("const Interval *", interval) - result = _lib.tfloat_wmax_transfn( - state_converted, temp_converted, interval_converted - ) +def tfloat_wmax_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) + temp_converted = _ffi.cast('const Temporal *', temp) + interval_converted = _ffi.cast('const Interval *', interval) + result = _lib.tfloat_wmax_transfn(state_converted, temp_converted, interval_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_wmin_transfn( - state: "SkipList *", temp: "const Temporal *", interval: "const Interval *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interval_converted = _ffi.cast("const Interval *", interval) - result = _lib.tfloat_wmin_transfn( - state_converted, temp_converted, interval_converted - ) +def tfloat_wmin_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) + temp_converted = _ffi.cast('const Temporal *', temp) + interval_converted = _ffi.cast('const Interval *', interval) + result = _lib.tfloat_wmin_transfn(state_converted, temp_converted, interval_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_wsum_transfn( - state: "SkipList *", temp: "const Temporal *", interval: "const Interval *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interval_converted = _ffi.cast("const Interval *", interval) - result = _lib.tfloat_wsum_transfn( - state_converted, temp_converted, interval_converted - ) +def tfloat_wsum_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) + temp_converted = _ffi.cast('const Temporal *', temp) + interval_converted = _ffi.cast('const Interval *', interval) + result = _lib.tfloat_wsum_transfn(state_converted, temp_converted, interval_converted) _check_error() return result if result != _ffi.NULL else None -def tint_tmin_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_tmin_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_tmin_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_tmax_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_tmax_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_tmax_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_tsum_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tint_tsum_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tint_tsum_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_wmax_transfn( - state: "SkipList *", temp: "const Temporal *", interval: "const Interval *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interval_converted = _ffi.cast("const Interval *", interval) +def tint_wmax_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) + temp_converted = _ffi.cast('const Temporal *', temp) + interval_converted = _ffi.cast('const Interval *', interval) result = _lib.tint_wmax_transfn(state_converted, temp_converted, interval_converted) _check_error() return result if result != _ffi.NULL else None -def tint_wmin_transfn( - state: "SkipList *", temp: "const Temporal *", interval: "const Interval *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interval_converted = _ffi.cast("const Interval *", interval) +def tint_wmin_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) + temp_converted = _ffi.cast('const Temporal *', temp) + interval_converted = _ffi.cast('const Interval *', interval) result = _lib.tint_wmin_transfn(state_converted, temp_converted, interval_converted) _check_error() return result if result != _ffi.NULL else None -def tint_wsum_transfn( - state: "SkipList *", temp: "const Temporal *", interval: "const Interval *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interval_converted = _ffi.cast("const Interval *", interval) +def tint_wsum_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) + temp_converted = _ffi.cast('const Temporal *', temp) + interval_converted = _ffi.cast('const Interval *', interval) result = _lib.tint_wsum_transfn(state_converted, temp_converted, interval_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_tavg_finalfn(state: "SkipList *") -> "Temporal *": - state_converted = _ffi.cast("SkipList *", state) +def tnumber_tavg_finalfn(state: 'SkipList *') -> 'Temporal *': + state_converted = _ffi.cast('SkipList *', state) result = _lib.tnumber_tavg_finalfn(state_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_tavg_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def tnumber_tavg_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.tnumber_tavg_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_wavg_transfn( - state: "SkipList *", temp: "const Temporal *", interval: "const Interval *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) - temp_converted = _ffi.cast("const Temporal *", temp) - interval_converted = _ffi.cast("const Interval *", interval) - result = _lib.tnumber_wavg_transfn( - state_converted, temp_converted, interval_converted - ) +def tnumber_wavg_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) + temp_converted = _ffi.cast('const Temporal *', temp) + interval_converted = _ffi.cast('const Interval *', interval) + result = _lib.tnumber_wavg_transfn(state_converted, temp_converted, interval_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_tmin_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_tmin_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ttext_tmin_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_tmax_transfn( - state: "Optional['SkipList *']", temp: "const Temporal *" -) -> "SkipList *": - state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast("const Temporal *", temp) +def ttext_tmax_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': + state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast('const Temporal *', temp) result = _lib.ttext_tmax_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_value_split( - temp: "const Temporal *", size: "Datum", origin: "Datum", buckets: "Datum **" -) -> "Tuple['Temporal **', 'int']": - temp_converted = _ffi.cast("const Temporal *", temp) - size_converted = _ffi.cast("Datum", size) - origin_converted = _ffi.cast("Datum", origin) - buckets_converted = [_ffi.cast("Datum *", x) for x in buckets] - count = _ffi.new("int *") - result = _lib.tnumber_value_split( - temp_converted, size_converted, origin_converted, buckets_converted, count - ) +def tnumber_value_split(temp: 'const Temporal *', size: 'Datum', origin: 'Datum', buckets: 'Datum **') -> "Tuple['Temporal **', 'int']": + temp_converted = _ffi.cast('const Temporal *', temp) + size_converted = _ffi.cast('Datum', size) + origin_converted = _ffi.cast('Datum', origin) + buckets_converted = [_ffi.cast('Datum *', x) for x in buckets] + count = _ffi.new('int *') + result = _lib.tnumber_value_split(temp_converted, size_converted, origin_converted, buckets_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] + + From c4ec31e72d8cc7f34eaba465034e204488bf558d Mon Sep 17 00:00:00 2001 From: Diviloper Date: Wed, 3 Jan 2024 17:54:28 +0300 Subject: [PATCH 16/37] Fix some dateset tests --- pymeos/pymeos/collections/base/set.py | 3 +- pymeos/pymeos/collections/time/dateset.py | 72 +++---- pymeos/pymeos/collections/time/datespan.py | 35 ++- pymeos/tests/collections/time/dateset_test.py | 204 +++++++++--------- .../builder/build_pymeos_functions.py | 1 + pymeos_cffi/pymeos_cffi/functions.py | 6 +- 6 files changed, 160 insertions(+), 161 deletions(-) diff --git a/pymeos/pymeos/collections/base/set.py b/pymeos/pymeos/collections/base/set.py index 5e25bc06..6fa51ad6 100644 --- a/pymeos/pymeos/collections/base/set.py +++ b/pymeos/pymeos/collections/base/set.py @@ -275,8 +275,7 @@ def is_contained_in(self, container) -> bool: True if contained, False otherwise MEOS Functions: - contained_span_span, contained_span_spanset, contained_set_set, - contained_spanset_spanset + contained_set_set """ if isinstance(container, Set): return contained_set_set(self._inner, container._inner) diff --git a/pymeos/pymeos/collections/time/dateset.py b/pymeos/pymeos/collections/time/dateset.py index 1a65de6a..c20b5a0b 100644 --- a/pymeos/pymeos/collections/time/dateset.py +++ b/pymeos/pymeos/collections/time/dateset.py @@ -10,7 +10,6 @@ date_to_date_adt, dateset_make, dateset_out, - date_to_tstzspan, dateset_start_value, date_adt_to_date, dateset_end_value, @@ -103,40 +102,27 @@ def to_spanset(self) -> DateSpanSet: return DateSpanSet(_inner=super().to_spanset()) - def to_tstzspanset(self) -> TsTzSpanSet: - """ - Returns a TsTzSpanSet that contains a TsTzSpan for each Timestamp in - ``self``. + # TODO Add back if function is actually implemented + # def to_tstzspanset(self) -> TsTzSpanSet: + # """ + # Returns a TsTzSpanSet that contains a TsTzSpan for each Timestamp in + # ``self``. - Returns: - A new :class:`TsTzSpanSet` instance + # Returns: + # A new :class:`TsTzSpanSet` instance - MEOS Functions: - set_to_spanset - """ - from .tstzspanset import TsTzSpanSet - from .tstzspan import TsTzSpan - - return TsTzSpanSet( - span_list=[ - TsTzSpan(_inner=date_to_tstzspan(date_to_date_adt(d))) - for d in self.elements() - ] - ) + # MEOS Functions: + # set_to_spanset + # """ + # from .tstzspanset import TsTzSpanSet + # from .tstzspan import TsTzSpan - def to_span(self) -> DateSpan: - """ - Returns a :class:`DateSpan` that encompasses ``self``. - - Returns: - A new :class:`DateSpan` instance - - MEOS Functions: - set_span - """ - from .datespan import DateSpan - - return DateSpan(_inner=super().to_span()) + # return TsTzSpanSet( + # span_list=[ + # TsTzSpan(_inner=date_to_tstzspan(date_to_date_adt(d))) + # for d in self.elements() + # ] + # ) # ------------------------- Accessors ------------------------------------- def duration(self) -> timedelta: @@ -150,7 +136,7 @@ def duration(self) -> timedelta: MEOS Functions: tstzspan_duration """ - return self.to_tstzspanset().duration(ignore_gaps=True) + return self.to_span().duration() def start_element(self) -> date: """ @@ -363,7 +349,7 @@ def overlaps(self, other: Union[date, DateSet, DateSpan, DateSpanSet]) -> bool: overlaps_set_set, overlaps_span_span, overlaps_spanset_spanset """ - if isinstance(other, datetime): + if isinstance(other, date): return contains_set_date(self._inner, date_to_date_adt(other)) elif isinstance(other, DateSpan): return self.to_span().is_adjacent(other) @@ -373,7 +359,7 @@ def overlaps(self, other: Union[date, DateSet, DateSpan, DateSpanSet]) -> bool: return super().overlaps(other) # ------------------------- Position Operations --------------------------- - def is_left(self, other: Union[TimeDate]) -> bool: + def is_left(self, other: TimeDate) -> bool: """ Returns whether ``self`` is strictly before ``other``. That is, ``self`` ends before ``other`` starts. @@ -405,7 +391,7 @@ def is_left(self, other: Union[TimeDate]) -> bool: else: return super().is_left(other) - def is_over_or_left(self, other: Union[TimeDate]) -> bool: + def is_over_or_left(self, other: TimeDate) -> bool: """ Returns whether ``self`` is before ``other`` allowing overlap. That is, ``self`` ends before ``other`` ends (or at the same time). @@ -436,7 +422,7 @@ def is_over_or_left(self, other: Union[TimeDate]) -> bool: else: return super().is_over_or_left(other) - def is_over_or_right(self, other: Union[TimeDate]) -> bool: + def is_over_or_right(self, other: TimeDate) -> bool: """ Returns whether ``self`` is after ``other`` allowing overlap. That is, ``self`` starts after ``other`` starts (or at the same time). @@ -467,7 +453,7 @@ def is_over_or_right(self, other: Union[TimeDate]) -> bool: else: return super().is_over_or_left(other) - def is_right(self, other: Union[TimeDate]) -> bool: + def is_right(self, other: TimeDate) -> bool: """ Returns whether ``self`` is strictly after ``other``. That is, the first timestamp in ``self`` is after ``other``. @@ -499,7 +485,7 @@ def is_right(self, other: Union[TimeDate]) -> bool: return super().is_over_or_left(other) # ------------------------- Distance Operations --------------------------- - def distance(self, other: Union[TimeDate]) -> timedelta: + def distance(self, other: TimeDate) -> timedelta: """ Returns the temporal distance between ``self`` and ``other``. @@ -536,7 +522,7 @@ def intersection( ) -> Optional[DateSpanSet]: ... - def intersection(self, other: Union[TimeDate]) -> Optional[TimeDate]: + def intersection(self, other: TimeDate) -> Optional[TimeDate]: """ Returns the temporal intersection of ``self`` and ``other``. @@ -574,7 +560,7 @@ def minus(self, other: Union[date, DateSet]) -> Optional[DateSet]: def minus(self, other: Union[DateSpan, DateSpanSet]) -> Optional[DateSpanSet]: ... - def minus(self, other: Union[TimeDate]) -> Optional[TimeDate]: + def minus(self, other: TimeDate) -> Optional[TimeDate]: """ Returns the temporal difference of ``self`` and ``other``. @@ -630,7 +616,7 @@ def union(self, other: Union[date, DateSet]) -> DateSet: def union(self, other: Union[DateSpan, DateSpanSet]) -> DateSpanSet: ... - def union(self, other: Union[TimeDate]) -> Union[DateSpanSet, DateSet]: + def union(self, other: TimeDate) -> Union[DateSpanSet, DateSet]: """ Returns the temporal union of ``self`` and ``other``. @@ -664,4 +650,4 @@ def union(self, other: Union[TimeDate]) -> Union[DateSpanSet, DateSet]: def plot(self, *args, **kwargs): from ...plotters import TimePlotter - return TimePlotter.plot_tstzspanset(self.to_tstzspanset(), *args, **kwargs) + return TimePlotter.plot_tstzspanset(self.to_spanset().to_tstzspanset(), *args, **kwargs) diff --git a/pymeos/pymeos/collections/time/datespan.py b/pymeos/pymeos/collections/time/datespan.py index ea67ea0a..3a5b31a8 100644 --- a/pymeos/pymeos/collections/time/datespan.py +++ b/pymeos/pymeos/collections/time/datespan.py @@ -5,6 +5,7 @@ from dateutil.parser import parse from pymeos_cffi import ( + adjacent_span_date, datespan_in, date_to_date_adt, pg_date_in, @@ -260,7 +261,27 @@ def shift_scale( return DateSpan(_inner=modified) # ------------------------- Topological Operations ------------------------ - def contains(self, content: Union[TimeDate]) -> bool: + + def is_adjacent(self, other: Union[date, DateSpan, DateSpanSet]) -> bool: + """ + Returns whether ``self`` is adjacent to ``other``. That is, they share + a bound but only one of them contains it. + + Args: + other: object to compare with + + Returns: + True if adjacent, False otherwise + + MEOS Functions: + adjacent_span_span, adjacent_span_spanset, adjacent_span_date + """ + if isinstance(other, date): + return adjacent_span_date(self._inner, date_to_date_adt(other)) + else: + return super().is_adjacent(other) + + def contains(self, content: TimeDate) -> bool: """ Returns whether ``self`` temporally contains ``content``. @@ -287,7 +308,7 @@ def contains(self, content: Union[TimeDate]) -> bool: else: return super().contains(content) - def overlaps(self, other: Union[TimeDate]) -> bool: + def overlaps(self, other: TimeDate) -> bool: """ Returns whether ``self`` temporally overlaps ``other``. That is, both share at least an instant @@ -316,7 +337,7 @@ def overlaps(self, other: Union[TimeDate]) -> bool: return super().overlaps(other) # ------------------------- Position Operations --------------------------- - def is_left(self, other: Union[TimeDate]) -> bool: + def is_left(self, other: TimeDate) -> bool: """ Returns whether ``self`` is strictly before ``other``. That is, ``self`` ends before ``other`` starts. @@ -344,7 +365,7 @@ def is_left(self, other: Union[TimeDate]) -> bool: else: return super().is_left(other) - def is_over_or_left(self, other: Union[TimeDate]) -> bool: + def is_over_or_left(self, other: TimeDate) -> bool: """ Returns whether ``self`` is before ``other`` allowing overlap. That is, ``self`` ends before ``other`` ends (or at the same time). @@ -372,7 +393,7 @@ def is_over_or_left(self, other: Union[TimeDate]) -> bool: else: return super().is_over_or_left(other) - def is_right(self, other: Union[TimeDate]) -> bool: + def is_right(self, other: TimeDate) -> bool: """ Returns whether ``self`` is strictly after ``other``. That is, ``self`` starts after ``other`` ends. @@ -399,7 +420,7 @@ def is_right(self, other: Union[TimeDate]) -> bool: else: return super().is_right(other) - def is_over_or_right(self, other: Union[TimeDate]) -> bool: + def is_over_or_right(self, other: TimeDate) -> bool: """ Returns whether ``self`` is after ``other`` allowing overlap. That is, ``self`` starts after ``other`` starts (or at the same time). @@ -428,7 +449,7 @@ def is_over_or_right(self, other: Union[TimeDate]) -> bool: return super().is_over_or_right(other) # ------------------------- Distance Operations --------------------------- - def distance(self, other: Union[TimeDate]) -> timedelta: + def distance(self, other: TimeDate) -> timedelta: """ Returns the temporal distance between ``self`` and ``other``. diff --git a/pymeos/tests/collections/time/dateset_test.py b/pymeos/tests/collections/time/dateset_test.py index 829f36df..72955268 100644 --- a/pymeos/tests/collections/time/dateset_test.py +++ b/pymeos/tests/collections/time/dateset_test.py @@ -1,6 +1,5 @@ from copy import copy -from datetime import date, timezone, timedelta -from typing import List +from datetime import date, timedelta import pytest @@ -48,11 +47,11 @@ def test_copy_constructor(self): class TestDateSetOutputs(TestDateSet): def test_str(self): - assert str(self.date_set) == '{"2019-09-25", "2019-09-26", "2019-09-27"}' + assert str(self.date_set) == '{2019-09-25, 2019-09-26, 2019-09-27}' def test_repr(self): assert ( - repr(self.date_set) == 'TsTzSet({"2019-09-25", "2019-09-26", "2019-09-27"})' + repr(self.date_set) == 'DateSet({2019-09-25, 2019-09-26, 2019-09-27})' ) def test_as_hexwkb(self): @@ -80,13 +79,13 @@ def test_num_elements(self): assert len(self.date_set) == 3 def test_start_element(self): - assert self.date_set.start_element() == date(2019, 9, 1) + assert self.date_set.start_element() == date(2019, 9, 25) def test_end_element(self): - assert self.date_set.end_element() == date(2019, 9, 3) + assert self.date_set.end_element() == date(2019, 9, 27) def test_element_n(self): - assert self.date_set.element_n(1) == date(2019, 9, 2) + assert self.date_set.element_n(1) == date(2019, 9, 26) def test_element_n_out_of_range(self): with pytest.raises(IndexError): @@ -94,200 +93,193 @@ def test_element_n_out_of_range(self): def test_elements(self): assert self.date_set.elements() == [ - date(2019, 9, 1), - date(2019, 9, 2), - date(2019, 9, 3), + date(2019, 9, 25), + date(2019, 9, 26), + date(2019, 9, 27), ] class TestDateSetPositionFunctions(TestDateSet): - date_value = date(year=2020, month=1, day=1) + date_value = date(year=2020, month=1, day=25) other_date_set = DateSet("{2020-01-01, 2020-01-31}") - @pytest.mark.parametrize("other, expected", [(other_date_set, False)], ids=["tstzset"]) + @pytest.mark.parametrize( + "other, expected", + [(other_date_set, False)], + ids=["dateset"], + ) def test_is_contained_in(self, other, expected): assert self.date_set.is_contained_in(other) == expected @pytest.mark.parametrize( - "other", [timestamp, tstzset], ids=["timestamp", "tstzset"] + "other, expected", + [(date_value, True), (other_date_set, False)], + ids=["date", "dateset"], ) - def test_contains(self, other): - self.date_set.contains(other) - _ = other in self.tstzset + def test_contains(self, other, expected): + assert self.date_set.contains(other) == expected + assert other in self.date_set == expected - @pytest.mark.parametrize("other", [tstzset], ids=["tstzset"]) + @pytest.mark.parametrize( + "other", + [other_date_set], + ids=["dateset"], + ) def test_overlaps(self, other): self.date_set.overlaps(other) @pytest.mark.parametrize( - "other", [timestamp, tstzset], ids=["timestamp", "tstzset"] + "other", [date_value, other_date_set], ids=["date", "dateset"] ) def test_is_before(self, other): self.date_set.is_before(other) @pytest.mark.parametrize( - "other", [timestamp, tstzset], ids=["timestamp", "tstzset"] + "other", [date_value, other_date_set], ids=["date", "dateset"] ) def test_is_over_or_before(self, other): self.date_set.is_over_or_before(other) @pytest.mark.parametrize( - "other", [timestamp, tstzset], ids=["timestamp", "tstzset"] + "other", [date_value, other_date_set], ids=["date", "dateset"] ) def test_is_after(self, other): self.date_set.is_after(other) @pytest.mark.parametrize( - "other", [timestamp, tstzset], ids=["timestamp", "tstzset"] + "other", [date_value, other_date_set], ids=["date", "dateset"] ) def test_is_over_or_after(self, other): self.date_set.is_over_or_after(other) @pytest.mark.parametrize( - "other", [timestamp, tstzset], ids=["timestamp", "tstzset"] + "other", [date_value, other_date_set], ids=["date", "dateset"] ) def test_distance(self, other): self.date_set.distance(other) class TestDateSetSetFunctions(TestDateSet): - timestamp = datetime(year=2020, month=1, day=1) - tstzset = TsTzSet("{2020-01-01, 2020-01-31}") - tstzspan = TsTzSpan("(2020-01-01, 2020-01-31)") - tstzspanset = TsTzSpanSet("{(2020-01-01, 2020-01-31), (2021-01-01, 2021-01-31)}") + date_value = date(year=2020, month=1, day=1) + dateset = DateSet("{2020-01-01, 2020-01-31}") + datespan = DateSpan("(2020-01-01, 2020-01-31)") + datespanset = DateSpanSet("{(2020-01-01, 2020-01-31), (2021-01-01, 2021-01-31)}") @pytest.mark.parametrize( "other", - [tstzspan, tstzspanset, timestamp, tstzset], - ids=["tstzspan", "tstzspanset", "timestamp", "tstzset"], + [datespan, datespanset, date_value, dateset], + ids=["datespan", "datespanset", "date", "dateset"], ) def test_intersection(self, other): - self.tstzset.intersection(other) - self.tstzset * other + self.dateset.intersection(other) + self.dateset * other @pytest.mark.parametrize( "other", - [tstzspan, tstzspanset, timestamp, tstzset], - ids=["tstzspan", "tstzspanset", "timestamp", "tstzset"], + [datespan, datespanset, date_value, dateset], + ids=["datespan", "datespanset", "date", "dateset"], ) def test_union(self, other): - self.tstzset.union(other) - self.tstzset + other + self.dateset.union(other) + self.dateset + other @pytest.mark.parametrize( "other", - [tstzspan, tstzspanset, timestamp, tstzset], - ids=["tstzspan", "tstzspanset", "timestamp", "tstzset"], + [datespan, datespanset, date_value, dateset], + ids=["datespan", "datespanset", "date", "dateset"], ) def test_minus(self, other): - self.tstzset.minus(other) - self.tstzset - other + self.dateset.minus(other) + self.dateset - other class TestDateSetComparisons(TestDateSet): - tstzset = TsTzSet("{2020-01-01, 2020-01-31}") - other = TsTzSet("{2020-01-02, 2020-03-31}") + dateset = DateSet("{2020-01-01, 2020-01-31}") + other = DateSet("{2020-01-02, 2020-03-31}") def test_eq(self): - _ = self.tstzset == self.other + assert not self.dateset == self.other def test_ne(self): - _ = self.tstzset != self.other + assert self.dateset != self.other def test_lt(self): - _ = self.tstzset < self.other + assert self.dateset < self.other def test_le(self): - _ = self.tstzset <= self.other + assert self.dateset <= self.other def test_gt(self): - _ = self.tstzset > self.other + assert not self.dateset > self.other def test_ge(self): - _ = self.tstzset >= self.other + assert not self.dateset >= self.other class TestDateSetFunctionsFunctions(TestDateSet): - tstzset = TsTzSet("{2020-01-01, 2020-01-02, 2020-01-04}") + dateset = DateSet("{2020-01-01, 2020-01-02, 2020-01-04}") @pytest.mark.parametrize( - "delta,result", + "delta,expected", [ ( timedelta(days=4), - [ - datetime(2020, 1, 5, tzinfo=timezone.utc), - datetime(2020, 1, 6, tzinfo=timezone.utc), - datetime(2020, 1, 8, tzinfo=timezone.utc), - ], + DateSet("{2020-1-5, 2020-1-6, 2020-1-8}"), ), ( timedelta(days=-4), - [ - datetime(2019, 12, 28, tzinfo=timezone.utc), - datetime(2019, 12, 29, tzinfo=timezone.utc), - datetime(2019, 12, 31, tzinfo=timezone.utc), - ], + DateSet("{2019-12-28,2019-12-29, 2019-12-31}"), ), ( - timedelta(hours=2), - [ - datetime(2020, 1, 1, 2, tzinfo=timezone.utc), - datetime(2020, 1, 2, 2, tzinfo=timezone.utc), - datetime(2020, 1, 4, 2, tzinfo=timezone.utc), - ], + 4, + DateSet("{2020-1-5, 2020-1-6, 2020-1-8}"), ), ( - timedelta(hours=-2), - [ - datetime(2019, 12, 31, 22, tzinfo=timezone.utc), - datetime(2020, 1, 1, 22, tzinfo=timezone.utc), - datetime(2020, 1, 3, 22, tzinfo=timezone.utc), - ], + -4, + DateSet("{2019-12-28,2019-12-29, 2019-12-31}"), ), ], - ids=["positive days", "negative days", "positive hours", "negative hours"], + ids=[ + "positive timedelta", + "negative timedelta", + "positive int", + "negative int", + ], ) - def test_shift(self, delta, result): - shifted = self.tstzset.shift(delta) - self.assert_tstzset_equality(shifted, result) + def test_shift(self, delta, expected): + shifted = self.dateset.shift(delta) + assert shifted == expected @pytest.mark.parametrize( - "delta,result", + "delta", + [timedelta(days=6), 6], + ids=["timedelta", "int"], + ) + def test_scale(self, delta): + expected = DateSet("{2020-1-1, 2020-1-3, 2020-1-7}") + + scaled = self.dateset.scale(delta) + + assert scaled == expected + + @pytest.mark.parametrize( + "shift, scale", [ - ( - timedelta(days=6), - [ - datetime(2020, 1, 1, tzinfo=timezone.utc), - datetime(2020, 1, 3, tzinfo=timezone.utc), - datetime(2020, 1, 7, tzinfo=timezone.utc), - ], - ), - ( - timedelta(hours=3), - [ - datetime(2020, 1, 1, tzinfo=timezone.utc), - datetime(2020, 1, 1, 1, tzinfo=timezone.utc), - datetime(2020, 1, 1, 3, tzinfo=timezone.utc), - ], - ), + (timedelta(days=4), timedelta(days=4)), + (timedelta(days=4), 4), + (4, timedelta(days=4)), + (4, 4), + ], + ids=[ + "timedelta timedelta", + "timedelta int", + "int timedelta", + "int int", ], - ids=["days", "hours"], ) - def test_scale(self, delta, result): - scaled = self.tstzset.scale(delta) - self.assert_tstzset_equality(scaled, result) - - def test_shift_scale(self): - shifted_scaled = self.tstzset.shift_scale(timedelta(days=4), timedelta(hours=3)) - self.assert_tstzset_equality( - shifted_scaled, - [ - datetime(2020, 1, 5, tzinfo=timezone.utc), - datetime(2020, 1, 5, 1, tzinfo=timezone.utc), - datetime(2020, 1, 5, 3, tzinfo=timezone.utc), - ], - ) + def test_shift_scale(self, shift, scale): + shifted_scaled = self.dateset.shift_scale(shift, scale) + assert shifted_scaled == DateSet("{2020-01-05, 2020-01-06, 2020-01-10}") class TestDateSetMiscFunctions(TestDateSet): diff --git a/pymeos_cffi/pymeos_cffi/builder/build_pymeos_functions.py b/pymeos_cffi/pymeos_cffi/builder/build_pymeos_functions.py index 447c6ab1..3a74b4c7 100644 --- a/pymeos_cffi/pymeos_cffi/builder/build_pymeos_functions.py +++ b/pymeos_cffi/pymeos_cffi/builder/build_pymeos_functions.py @@ -84,6 +84,7 @@ def __init__(self, ctype: str, ptype: str, conversion: Optional[str]) -> None: "tbox_as_wkb": as_wkb_modifier, "stbox_as_wkb": as_wkb_modifier, "tstzset_make": tstzset_make_modifier, + "dateset_make": array_parameter_modifier("values", "count"), "intset_make": array_parameter_modifier("values", "count"), "bigintset_make": array_parameter_modifier("values", "count"), "floatset_make": array_parameter_modifier("values", "count"), diff --git a/pymeos_cffi/pymeos_cffi/functions.py b/pymeos_cffi/pymeos_cffi/functions.py index 04be29bb..548a1cb0 100644 --- a/pymeos_cffi/pymeos_cffi/functions.py +++ b/pymeos_cffi/pymeos_cffi/functions.py @@ -1040,9 +1040,9 @@ def bigintspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> return result if result != _ffi.NULL else None -def dateset_make(values: 'const DateADT *', count: int) -> 'Set *': - values_converted = _ffi.cast('const DateADT *', values) - result = _lib.dateset_make(values_converted, count) +def dateset_make(values: 'List[const DateADT]') -> 'Set *': + values_converted = _ffi.new('const DateADT []', values) + result = _lib.dateset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None From 34979276d75b0c048f6474609095b3a1d369a0c5 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Fri, 12 Jan 2024 20:37:40 +0300 Subject: [PATCH 17/37] Remove override of to_spanset in favor of overloads in same class (may be canged later). Fix a couple of tests. --- pymeos/pymeos/collections/base/set.py | 16 ++++++++++++ pymeos/pymeos/collections/number/floatset.py | 25 ------------------- pymeos/pymeos/collections/time/dateset.py | 18 +++---------- pymeos/pymeos/collections/time/datespan.py | 4 +-- pymeos/tests/collections/time/dateset_test.py | 20 ++++++++------- 5 files changed, 32 insertions(+), 51 deletions(-) diff --git a/pymeos/pymeos/collections/base/set.py b/pymeos/pymeos/collections/base/set.py index 6fa51ad6..fceb8694 100644 --- a/pymeos/pymeos/collections/base/set.py +++ b/pymeos/pymeos/collections/base/set.py @@ -175,6 +175,22 @@ def to_span(self) -> Span: return _CollectionFactory.create_collection(set_span(self._inner)) + @overload + def to_spanset(self: Type[IntSet]) -> IntSpanSet: + ... + + @overload + def to_spanset(self: Type[FloatSet]) -> FloatSpanSet: + ... + + @overload + def to_spanset(self: Type[TsTzSet]) -> TsTzSpanSet: + ... + + @overload + def to_spanset(self: Type[DateSet]) -> DateSpanSet: + ... + def to_spanset(self) -> SpanSet: """ Returns a SpanSet that contains a Span for each element in ``self``. diff --git a/pymeos/pymeos/collections/number/floatset.py b/pymeos/pymeos/collections/number/floatset.py index b789d2bf..0aac60ab 100644 --- a/pymeos/pymeos/collections/number/floatset.py +++ b/pymeos/pymeos/collections/number/floatset.py @@ -77,31 +77,6 @@ def __str__(self, max_decimals: int = 15): # ------------------------- Conversions ----------------------------------- - def to_spanset(self) -> FloatSpanSet: - """ - Returns a SpanSet that contains a Span for each element in ``self``. - - Returns: - A new :class:`FloatSpanSet` instance - - MEOS Functions: - set_to_spanset - """ - - return FloatSpanSet(_inner=super().to_spanset()) - - def to_span(self) -> FloatSpan: - """ - Returns a span that encompasses ``self``. - - Returns: - A new :class:`FloatSpan` instance - - MEOS Functions: - set_span - """ - return super().to_span() - def to_intset(self) -> IntSet: """ Converts ``self`` to an :class:`IntSet` instance. diff --git a/pymeos/pymeos/collections/time/dateset.py b/pymeos/pymeos/collections/time/dateset.py index c20b5a0b..0b04aaa3 100644 --- a/pymeos/pymeos/collections/time/dateset.py +++ b/pymeos/pymeos/collections/time/dateset.py @@ -87,20 +87,6 @@ def __str__(self): return dateset_out(self._inner) # ------------------------- Conversions ----------------------------------- - def to_spanset(self) -> DateSpanSet: - """ - Returns a :class:`DateSpanSet` that contains a :class:`DateSpan` for each - date in ``self``. - - Returns: - A new :class:`DateSpanSet` instance - - MEOS Functions: - set_to_spanset - """ - from .datespanset import DateSpanSet - - return DateSpanSet(_inner=super().to_spanset()) # TODO Add back if function is actually implemented # def to_tstzspanset(self) -> TsTzSpanSet: @@ -650,4 +636,6 @@ def union(self, other: TimeDate) -> Union[DateSpanSet, DateSet]: def plot(self, *args, **kwargs): from ...plotters import TimePlotter - return TimePlotter.plot_tstzspanset(self.to_spanset().to_tstzspanset(), *args, **kwargs) + return TimePlotter.plot_tstzspanset( + self.to_spanset().to_tstzspanset(), *args, **kwargs + ) diff --git a/pymeos/pymeos/collections/time/datespan.py b/pymeos/pymeos/collections/time/datespan.py index 3a5b31a8..5e189647 100644 --- a/pymeos/pymeos/collections/time/datespan.py +++ b/pymeos/pymeos/collections/time/datespan.py @@ -261,7 +261,7 @@ def shift_scale( return DateSpan(_inner=modified) # ------------------------- Topological Operations ------------------------ - + def is_adjacent(self, other: Union[date, DateSpan, DateSpanSet]) -> bool: """ Returns whether ``self`` is adjacent to ``other``. That is, they share @@ -280,7 +280,7 @@ def is_adjacent(self, other: Union[date, DateSpan, DateSpanSet]) -> bool: return adjacent_span_date(self._inner, date_to_date_adt(other)) else: return super().is_adjacent(other) - + def contains(self, content: TimeDate) -> bool: """ Returns whether ``self`` temporally contains ``content``. diff --git a/pymeos/tests/collections/time/dateset_test.py b/pymeos/tests/collections/time/dateset_test.py index 72955268..fd37723c 100644 --- a/pymeos/tests/collections/time/dateset_test.py +++ b/pymeos/tests/collections/time/dateset_test.py @@ -47,12 +47,10 @@ def test_copy_constructor(self): class TestDateSetOutputs(TestDateSet): def test_str(self): - assert str(self.date_set) == '{2019-09-25, 2019-09-26, 2019-09-27}' + assert str(self.date_set) == "{2019-09-25, 2019-09-26, 2019-09-27}" def test_repr(self): - assert ( - repr(self.date_set) == 'DateSet({2019-09-25, 2019-09-26, 2019-09-27})' - ) + assert repr(self.date_set) == "DateSet({2019-09-25, 2019-09-26, 2019-09-27})" def test_as_hexwkb(self): assert self.date_set == DateSet.from_hexwkb(self.date_set.as_hexwkb()) @@ -60,15 +58,19 @@ def test_as_hexwkb(self): class TestCollectionConversions(TestDateSet): def test_to_span(self): - assert self.date_set.to_span() == DateSpan("[2019-09-01, 2019-09-03]") + assert self.date_set.to_span() == DateSpan("[2019-09-25, 2019-09-27]") def test_to_spanset(self): - assert self.date_set.to_spanset() == DateSpanSet( - "{[2019-09-01, 2019-09-01], " - "[2019-09-02, 2019-09-02], " - "[2019-09-03, 2019-09-03]}" + expected = DateSpanSet( + "{[2019-09-25, 2019-09-25], " + "[2019-09-26, 2019-09-26], " + "[2019-09-27, 2019-09-27]}" ) + spanset = self.date_set.to_spanset() + + assert spanset == expected + class TestDateSetAccessors(TestDateSet): def test_duration(self): From 1f662edda5327f0aeb4ea48733cc241d6fe2d409 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Fri, 12 Jan 2024 23:39:38 +0100 Subject: [PATCH 18/37] Sync pymeos_cffi with latest meos changes --- pymeos_cffi/pymeos_cffi/__init__.py | 3990 ++-- .../builder/build_pymeos_functions.py | 4 +- .../build_pymeos_functions_modifiers.py | 2 +- pymeos_cffi/pymeos_cffi/builder/meos.h | 1265 +- .../builder/templates/functions.py | 4 +- pymeos_cffi/pymeos_cffi/functions.py | 16273 +++++++++------- 6 files changed, 12248 insertions(+), 9290 deletions(-) diff --git a/pymeos_cffi/pymeos_cffi/__init__.py b/pymeos_cffi/pymeos_cffi/__init__.py index 42d7e3ed..70cecf68 100644 --- a/pymeos_cffi/pymeos_cffi/__init__.py +++ b/pymeos_cffi/pymeos_cffi/__init__.py @@ -34,1910 +34,2088 @@ "InterpolationType", "SpatialRelation", # Functions - 'py_error_handler', - 'create_pointer', - 'get_address', - 'datetime_to_timestamptz', - 'timestamptz_to_datetime', - 'date_to_date_adt', - 'date_adt_to_date', - 'timedelta_to_interval', - 'interval_to_timedelta', - 'geo_to_gserialized', - 'geometry_to_gserialized', - 'geography_to_gserialized', - 'gserialized_to_shapely_point', - 'gserialized_to_shapely_geometry', - 'as_tinstant', - 'as_tsequence', - 'as_tsequenceset', - 'lwpoint_make', - 'lwgeom_from_gserialized', - 'gserialized_from_lwgeom', - 'lwgeom_get_srid', - 'lwpoint_get_x', - 'lwpoint_get_y', - 'lwpoint_get_z', - 'lwpoint_get_m', - 'lwgeom_has_z', - 'lwgeom_has_m', - 'meos_errno', - 'meos_errno_set', - 'meos_errno_restore', - 'meos_errno_reset', - 'meos_set_datestyle', - 'meos_set_intervalstyle', - 'meos_get_datestyle', - 'meos_get_intervalstyle', - 'meos_initialize', - 'meos_finalize', - 'bool_in', - 'bool_out', - 'cstring2text', - 'pg_date_in', - 'pg_date_out', - 'pg_date_mi', - 'pg_date_mi_int', - 'pg_date_pl_int', - 'pg_date_timestamptz', - 'pg_interval_cmp', - 'pg_interval_in', - 'pg_interval_make', - 'pg_interval_mul', - 'pg_interval_out', - 'pg_interval_to_char', - 'pg_interval_pl', - 'pg_time_in', - 'pg_time_out', - 'pg_timestamp_in', - 'pg_timestamp_mi', - 'pg_timestamp_mi_interval', - 'pg_timestamp_out', - 'pg_timestamp_pl_interval', - 'pg_timestamp_to_char', - 'pg_timestamptz_in', - 'pg_timestamptz_date', - 'pg_timestamptz_out', - 'pg_timestamptz_to_char', - 'pg_to_date', - 'pg_to_timestamptz', - 'text2cstring', - 'text_out', - 'geography_from_hexewkb', - 'geography_from_text', - 'geometry_from_hexewkb', - 'geometry_from_text', - 'gserialized_as_ewkb', - 'gserialized_as_ewkt', - 'gserialized_as_geojson', - 'gserialized_as_hexewkb', - 'gserialized_as_text', - 'gserialized_from_ewkb', - 'gserialized_from_geojson', - 'gserialized_out', - 'pgis_geography_in', - 'pgis_geometry_in', - 'pgis_gserialized_same', - 'bigintset_in', - 'bigintset_out', - 'bigintspan_in', - 'bigintspan_out', - 'bigintspanset_in', - 'bigintspanset_out', - 'dateset_in', - 'dateset_out', - 'datespan_in', - 'datespan_out', - 'datespanset_in', - 'datespanset_out', - 'floatset_in', - 'floatset_out', - 'floatspan_in', - 'floatspan_out', - 'floatspanset_in', - 'floatspanset_out', - 'geogset_in', - 'geomset_in', - 'geoset_as_ewkt', - 'geoset_as_text', - 'geoset_out', - 'intset_in', - 'intset_out', - 'intspan_in', - 'intspan_out', - 'intspanset_in', - 'intspanset_out', - 'set_as_hexwkb', - 'set_as_wkb', - 'set_from_hexwkb', - 'set_from_wkb', - 'span_as_hexwkb', - 'span_as_wkb', - 'span_from_hexwkb', - 'span_from_wkb', - 'spanset_as_hexwkb', - 'spanset_as_wkb', - 'spanset_from_hexwkb', - 'spanset_from_wkb', - 'textset_in', - 'textset_out', - 'tstzset_in', - 'tstzset_out', - 'tstzspan_in', - 'tstzspan_out', - 'tstzspanset_in', - 'tstzspanset_out', - 'bigintset_make', - 'bigintspan_make', - 'dateset_make', - 'datespan_make', - 'floatset_make', - 'floatspan_make', - 'geoset_make', - 'intset_make', - 'intspan_make', - 'set_copy', - 'span_copy', - 'spanset_copy', - 'spanset_make', - 'textset_make', - 'tstzset_make', - 'tstzspan_make', - 'bigint_to_set', - 'bigint_to_span', - 'bigint_to_spanset', - 'date_to_set', - 'date_to_span', - 'date_to_spanset', - 'date_to_tstzspan', - 'float_to_set', - 'float_to_span', - 'float_to_spanset', - 'geo_to_set', - 'int_to_set', - 'int_to_span', - 'int_to_spanset', - 'set_to_spanset', - 'span_to_spanset', - 'text_to_set', - 'timestamptz_to_set', - 'timestamptz_to_span', - 'timestamptz_to_spanset', - 'bigintset_end_value', - 'bigintset_start_value', - 'bigintset_value_n', - 'bigintset_values', - 'bigintspan_lower', - 'bigintspan_upper', - 'bigintspanset_lower', - 'bigintspanset_upper', - 'dateset_end_value', - 'dateset_start_value', - 'dateset_value_n', - 'dateset_values', - 'datespan_duration', - 'datespan_lower', - 'datespan_upper', - 'datespanset_duration', - 'datespanset_end_date', - 'datespanset_num_dates', - 'datespanset_start_date', - 'datespanset_date_n', - 'datespanset_dates', - 'floatset_end_value', - 'floatset_start_value', - 'floatset_value_n', - 'floatset_values', - 'floatspan_lower', - 'floatspan_upper', - 'floatspanset_lower', - 'floatspanset_upper', - 'geoset_end_value', - 'geoset_srid', - 'geoset_set_srid', - 'geoset_start_value', - 'geoset_value_n', - 'geoset_values', - 'intset_end_value', - 'intset_start_value', - 'intset_value_n', - 'intset_values', - 'intspan_lower', - 'intspan_upper', - 'intspanset_lower', - 'intspanset_upper', - 'set_hash', - 'set_hash_extended', - 'set_num_values', - 'set_to_span', - 'span_hash', - 'span_hash_extended', - 'span_lower_inc', - 'span_upper_inc', - 'span_width', - 'spanset_end_span', - 'spanset_hash', - 'spanset_hash_extended', - 'spanset_lower_inc', - 'spanset_num_spans', - 'spanset_span', - 'spanset_span_n', - 'spanset_spans', - 'spanset_start_span', - 'spanset_upper_inc', - 'spanset_width', - 'spatialset_to_stbox', - 'textset_end_value', - 'textset_start_value', - 'textset_value_n', - 'textset_values', - 'tstzset_end_value', - 'tstzset_start_value', - 'tstzset_value_n', - 'tstzset_values', - 'tstzspan_duration', - 'tstzspan_lower', - 'tstzspan_upper', - 'tstzspanset_duration', - 'tstzspanset_end_timestamptz', - 'tstzspanset_lower', - 'tstzspanset_num_timestamps', - 'tstzspanset_start_timestamptz', - 'tstzspanset_timestamptz_n', - 'tstzspanset_timestamps', - 'tstzspanset_upper', - 'bigintset_shift_scale', - 'bigintspan_shift_scale', - 'bigintspanset_shift_scale', - 'dateset_shift_scale', - 'dateset_to_tstzset', - 'datespan_shift_scale', - 'datespan_to_tstzspan', - 'datespanset_shift_scale', - 'datespanset_to_tstzspanset', - 'floatset_round', - 'floatset_shift_scale', - 'floatset_to_intset', - 'floatspan_round', - 'floatspan_shift_scale', - 'floatspan_to_intspan', - 'floatspanset_to_intspanset', - 'floatspanset_round', - 'floatspanset_shift_scale', - 'geoset_round', - 'intset_shift_scale', - 'intset_to_floatset', - 'intspan_shift_scale', - 'intspan_to_floatspan', - 'intspanset_to_floatspanset', - 'intspanset_shift_scale', - 'textset_lower', - 'textset_upper', - 'timestamptz_tprecision', - 'tstzset_shift_scale', - 'datespan_shift_scale', - 'tstzspan_shift_scale', - 'tstzspan_tprecision', - 'tstzset_to_dateset', - 'tstzspan_to_datespan', - 'tstzspanset_to_datespanset', - 'tstzspanset_shift_scale', - 'tstzspanset_tprecision', - 'intersection_set_bigint', - 'intersection_set_date', - 'intersection_set_float', - 'intersection_set_geo', - 'intersection_set_int', - 'intersection_set_set', - 'intersection_set_text', - 'intersection_set_timestamptz', - 'intersection_span_bigint', - 'intersection_span_date', - 'intersection_span_float', - 'intersection_span_int', - 'intersection_span_timestamptz', - 'intersection_span_span', - 'intersection_spanset_bigint', - 'intersection_spanset_date', - 'intersection_spanset_float', - 'intersection_spanset_int', - 'intersection_spanset_span', - 'intersection_spanset_spanset', - 'intersection_spanset_timestamptz', - 'minus_bigint_set', - 'minus_bigint_span', - 'minus_bigint_spanset', - 'minus_date_set', - 'minus_date_span', - 'minus_date_spanset', - 'minus_float_set', - 'minus_float_span', - 'minus_float_spanset', - 'minus_geo_set', - 'minus_int_set', - 'minus_int_span', - 'minus_int_spanset', - 'minus_set_bigint', - 'minus_set_date', - 'minus_set_float', - 'minus_set_geo', - 'minus_set_int', - 'minus_set_set', - 'minus_set_text', - 'minus_set_timestamptz', - 'minus_span_bigint', - 'minus_span_date', - 'minus_span_float', - 'minus_span_int', - 'minus_span_span', - 'minus_span_spanset', - 'minus_span_timestamptz', - 'minus_spanset_bigint', - 'minus_spanset_date', - 'minus_spanset_float', - 'minus_spanset_int', - 'minus_spanset_span', - 'minus_spanset_spanset', - 'minus_spanset_timestamptz', - 'minus_text_set', - 'minus_timestamptz_span', - 'minus_timestamptz_spanset', - 'minus_timestamptz_set', - 'super_union_span_span', - 'union_set_bigint', - 'union_set_date', - 'union_set_float', - 'union_set_geo', - 'union_set_int', - 'union_set_set', - 'union_set_text', - 'union_set_timestamptz', - 'union_span_bigint', - 'union_span_date', - 'union_span_float', - 'union_span_int', - 'union_span_span', - 'union_span_timestamptz', - 'union_spanset_bigint', - 'union_spanset_date', - 'union_spanset_float', - 'union_spanset_int', - 'union_spanset_span', - 'union_spanset_spanset', - 'union_spanset_timestamptz', - 'adjacent_span_bigint', - 'adjacent_span_date', - 'adjacent_span_float', - 'adjacent_span_int', - 'adjacent_span_span', - 'adjacent_span_timestamptz', - 'adjacent_spanset_bigint', - 'adjacent_spanset_date', - 'adjacent_spanset_float', - 'adjacent_spanset_int', - 'adjacent_spanset_timestamptz', - 'adjacent_spanset_span', - 'adjacent_spanset_spanset', - 'contained_bigint_set', - 'contained_bigint_span', - 'contained_bigint_spanset', - 'contained_date_set', - 'contained_date_span', - 'contained_date_spanset', - 'contained_float_set', - 'contained_float_span', - 'contained_float_spanset', - 'contained_geo_set', - 'contained_int_set', - 'contained_int_span', - 'contained_int_spanset', - 'contained_set_set', - 'contained_span_span', - 'contained_span_spanset', - 'contained_spanset_span', - 'contained_spanset_spanset', - 'contained_text_set', - 'contained_timestamptz_set', - 'contained_timestamptz_span', - 'contained_timestamptz_spanset', - 'contains_set_bigint', - 'contains_set_date', - 'contains_set_float', - 'contains_set_geo', - 'contains_set_int', - 'contains_set_set', - 'contains_set_text', - 'contains_set_timestamptz', - 'contains_span_bigint', - 'contains_span_float', - 'contains_span_int', - 'contains_span_span', - 'contains_span_spanset', - 'contains_span_timestamptz', - 'contains_span_date', - 'contains_spanset_bigint', - 'contains_spanset_float', - 'contains_spanset_int', - 'contains_spanset_span', - 'contains_spanset_spanset', - 'contains_spanset_timestamptz', - 'contains_spanset_date', - 'overlaps_set_set', - 'overlaps_span_span', - 'overlaps_spanset_span', - 'overlaps_spanset_spanset', - 'after_date_set', - 'after_date_span', - 'after_date_spanset', - 'after_set_date', - 'after_set_timestamptz', - 'after_span_date', - 'after_span_timestamptz', - 'after_spanset_date', - 'after_spanset_timestamptz', - 'after_timestamptz_set', - 'after_timestamptz_span', - 'after_timestamptz_spanset', - 'before_date_set', - 'before_date_span', - 'before_date_spanset', - 'before_set_date', - 'before_set_timestamptz', - 'before_span_date', - 'before_span_timestamptz', - 'before_spanset_date', - 'before_spanset_timestamptz', - 'before_timestamptz_set', - 'before_timestamptz_span', - 'before_timestamptz_spanset', - 'left_bigint_set', - 'left_bigint_span', - 'left_bigint_spanset', - 'left_float_set', - 'left_float_span', - 'left_float_spanset', - 'left_int_set', - 'left_int_span', - 'left_int_spanset', - 'left_set_bigint', - 'left_set_float', - 'left_set_int', - 'left_set_set', - 'left_set_text', - 'left_span_bigint', - 'left_span_float', - 'left_span_int', - 'left_span_span', - 'left_span_spanset', - 'left_spanset_bigint', - 'left_spanset_float', - 'left_spanset_int', - 'left_spanset_span', - 'left_spanset_spanset', - 'left_text_set', - 'overafter_set_date', - 'overafter_set_timestamptz', - 'overafter_span_timestamptz', - 'overafter_span_date', - 'overafter_spanset_timestamptz', - 'overafter_spanset_date', - 'overafter_timestamptz_set', - 'overafter_timestamptz_span', - 'overafter_timestamptz_spanset', - 'overbefore_set_date', - 'overbefore_set_timestamptz', - 'overbefore_span_timestamptz', - 'overbefore_span_date', - 'overbefore_spanset_timestamptz', - 'overbefore_spanset_date', - 'overbefore_timestamptz_set', - 'overbefore_timestamptz_span', - 'overbefore_timestamptz_spanset', - 'overleft_bigint_set', - 'overleft_bigint_span', - 'overleft_bigint_spanset', - 'overleft_float_set', - 'overleft_float_span', - 'overleft_float_spanset', - 'overleft_int_set', - 'overleft_int_span', - 'overleft_int_spanset', - 'overleft_set_bigint', - 'overleft_set_float', - 'overleft_set_int', - 'overleft_set_set', - 'overleft_set_text', - 'overleft_span_bigint', - 'overleft_span_float', - 'overleft_span_int', - 'overleft_span_span', - 'overleft_span_spanset', - 'overleft_spanset_bigint', - 'overleft_spanset_float', - 'overleft_spanset_int', - 'overleft_spanset_span', - 'overleft_spanset_spanset', - 'overleft_text_set', - 'overright_bigint_set', - 'overright_bigint_span', - 'overright_bigint_spanset', - 'overright_float_set', - 'overright_float_span', - 'overright_float_spanset', - 'overright_int_set', - 'overright_int_span', - 'overright_int_spanset', - 'overright_set_bigint', - 'overright_set_float', - 'overright_set_int', - 'overright_set_set', - 'overright_set_text', - 'overright_span_bigint', - 'overright_span_float', - 'overright_span_int', - 'overright_span_span', - 'overright_span_spanset', - 'overright_spanset_bigint', - 'overright_spanset_float', - 'overright_spanset_int', - 'overright_spanset_span', - 'overright_spanset_spanset', - 'overright_text_set', - 'right_bigint_set', - 'right_bigint_span', - 'right_bigint_spanset', - 'right_float_set', - 'right_float_span', - 'right_float_spanset', - 'right_int_set', - 'right_int_span', - 'right_int_spanset', - 'right_set_bigint', - 'right_set_float', - 'right_set_int', - 'right_set_set', - 'right_set_text', - 'right_span_bigint', - 'right_span_float', - 'right_span_int', - 'right_span_span', - 'right_span_spanset', - 'right_spanset_bigint', - 'right_spanset_float', - 'right_spanset_int', - 'right_spanset_span', - 'right_spanset_spanset', - 'right_text_set', - 'distance_set_bigint', - 'distance_set_float', - 'distance_set_int', - 'distance_set_set', - 'distance_set_timestamptz', - 'distance_set_date', - 'distance_span_bigint', - 'distance_span_float', - 'distance_span_int', - 'distance_span_span', - 'distance_span_timestamptz', - 'distance_span_date', - 'distance_spanset_bigint', - 'distance_spanset_float', - 'distance_spanset_int', - 'distance_spanset_timestamptz', - 'distance_spanset_date', - 'distance_spanset_span', - 'distance_spanset_spanset', - 'set_cmp', - 'set_eq', - 'set_ge', - 'set_gt', - 'set_le', - 'set_lt', - 'set_ne', - 'span_cmp', - 'span_eq', - 'span_ge', - 'span_gt', - 'span_le', - 'span_lt', - 'span_ne', - 'spanset_cmp', - 'spanset_eq', - 'spanset_ge', - 'spanset_gt', - 'spanset_le', - 'spanset_lt', - 'spanset_ne', - 'bigint_extent_transfn', - 'bigint_union_transfn', - 'float_extent_transfn', - 'float_union_transfn', - 'int_extent_transfn', - 'int_union_transfn', - 'set_extent_transfn', - 'set_union_finalfn', - 'set_union_transfn', - 'span_extent_transfn', - 'span_union_transfn', - 'spanset_extent_transfn', - 'spanset_union_finalfn', - 'spanset_union_transfn', - 'text_union_transfn', - 'timestamptz_extent_transfn', - 'timestamptz_tcount_transfn', - 'timestamptz_union_transfn', - 'tstzset_tcount_transfn', - 'tstzspan_tcount_transfn', - 'tstzspanset_tcount_transfn', - 'tbox_in', - 'tbox_out', - 'tbox_from_wkb', - 'tbox_from_hexwkb', - 'stbox_from_wkb', - 'stbox_from_hexwkb', - 'tbox_as_wkb', - 'tbox_as_hexwkb', - 'stbox_as_wkb', - 'stbox_as_hexwkb', - 'stbox_in', - 'stbox_out', - 'float_tstzspan_to_tbox', - 'float_timestamptz_to_tbox', - 'geo_tstzspan_to_stbox', - 'geo_timestamptz_to_stbox', - 'int_tstzspan_to_tbox', - 'int_timestamptz_to_tbox', - 'numspan_tstzspan_to_tbox', - 'numspan_timestamptz_to_tbox', - 'stbox_copy', - 'stbox_make', - 'tbox_copy', - 'tbox_make', - 'box3d_to_stbox', - 'gbox_to_stbox', - 'float_to_tbox', - 'geo_to_stbox', - 'int_to_tbox', - 'numset_to_tbox', - 'numspan_to_tbox', - 'numspanset_to_tbox', - 'tstzspan_to_stbox', - 'tstzspan_to_tbox', - 'tstzspanset_to_stbox', - 'tstzspanset_to_tbox', - 'stbox_to_gbox', - 'stbox_to_box3d', - 'stbox_to_geo', - 'stbox_to_tstzspan', - 'tbox_to_intspan', - 'tbox_to_floatspan', - 'tbox_to_tstzspan', - 'timestamptz_to_stbox', - 'timestamptz_to_tbox', - 'tstzset_to_stbox', - 'tstzset_to_tbox', - 'tnumber_to_tbox', - 'tpoint_to_stbox', - 'stbox_hast', - 'stbox_hasx', - 'stbox_hasz', - 'stbox_isgeodetic', - 'stbox_srid', - 'stbox_tmax', - 'stbox_tmax_inc', - 'stbox_tmin', - 'stbox_tmin_inc', - 'stbox_xmax', - 'stbox_xmin', - 'stbox_ymax', - 'stbox_ymin', - 'stbox_zmax', - 'stbox_zmin', - 'tbox_hast', - 'tbox_hasx', - 'tbox_tmax', - 'tbox_tmax_inc', - 'tbox_tmin', - 'tbox_tmin_inc', - 'tbox_xmax', - 'tbox_xmax_inc', - 'tbox_xmin', - 'tbox_xmin_inc', - 'tboxfloat_xmax', - 'tboxfloat_xmin', - 'tboxint_xmax', - 'tboxint_xmin', - 'stbox_expand_space', - 'stbox_expand_time', - 'stbox_get_space', - 'stbox_round', - 'stbox_set_srid', - 'stbox_shift_scale_time', - 'tbox_expand_time', - 'tbox_expand_float', - 'tbox_expand_int', - 'tbox_round', - 'tbox_shift_scale_float', - 'tbox_shift_scale_int', - 'tbox_shift_scale_time', - 'union_tbox_tbox', - 'inter_tbox_tbox', - 'intersection_tbox_tbox', - 'union_stbox_stbox', - 'inter_stbox_stbox', - 'intersection_stbox_stbox', - 'contains_tbox_tbox', - 'contained_tbox_tbox', - 'overlaps_tbox_tbox', - 'same_tbox_tbox', - 'adjacent_tbox_tbox', - 'contains_stbox_stbox', - 'contained_stbox_stbox', - 'overlaps_stbox_stbox', - 'same_stbox_stbox', - 'adjacent_stbox_stbox', - 'left_tbox_tbox', - 'overleft_tbox_tbox', - 'right_tbox_tbox', - 'overright_tbox_tbox', - 'before_tbox_tbox', - 'overbefore_tbox_tbox', - 'after_tbox_tbox', - 'overafter_tbox_tbox', - 'left_stbox_stbox', - 'overleft_stbox_stbox', - 'right_stbox_stbox', - 'overright_stbox_stbox', - 'below_stbox_stbox', - 'overbelow_stbox_stbox', - 'above_stbox_stbox', - 'overabove_stbox_stbox', - 'front_stbox_stbox', - 'overfront_stbox_stbox', - 'back_stbox_stbox', - 'overback_stbox_stbox', - 'before_stbox_stbox', - 'overbefore_stbox_stbox', - 'after_stbox_stbox', - 'overafter_stbox_stbox', - 'stbox_quad_split', - 'tbox_eq', - 'tbox_ne', - 'tbox_cmp', - 'tbox_lt', - 'tbox_le', - 'tbox_ge', - 'tbox_gt', - 'stbox_eq', - 'stbox_ne', - 'stbox_cmp', - 'stbox_lt', - 'stbox_le', - 'stbox_ge', - 'stbox_gt', - 'tbool_in', - 'tbool_out', - 'temporal_as_hexwkb', - 'temporal_as_mfjson', - 'temporal_as_wkb', - 'temporal_from_hexwkb', - 'temporal_from_mfjson', - 'temporal_from_wkb', - 'tfloat_in', - 'tfloat_out', - 'tgeogpoint_in', - 'tgeompoint_in', - 'tint_in', - 'tint_out', - 'tpoint_as_ewkt', - 'tpoint_as_text', - 'tpoint_out', - 'ttext_in', - 'ttext_out', - 'temporal_cp', - 'tbool_from_base_temp', - 'tboolinst_make', - 'tboolseq_from_base_tstzset', - 'tboolseq_from_base_tstzspan', - 'tboolseqset_from_base_tstzspanset', - 'temporal_copy', - 'tfloat_from_base_temp', - 'tfloatinst_make', - 'tfloatseq_from_base_tstzspan', - 'tfloatseq_from_base_tstzset', - 'tfloatseqset_from_base_tstzspanset', - 'tint_from_base_temp', - 'tintinst_make', - 'tintseq_from_base_tstzspan', - 'tintseq_from_base_tstzset', - 'tintseqset_from_base_tstzspanset', - 'tpoint_from_base_temp', - 'tpointinst_make', - 'tpointseq_from_base_tstzspan', - 'tpointseq_from_base_tstzset', - 'tpointseqset_from_base_tstzspanset', - 'tsequence_make', - 'tsequenceset_make', - 'tsequenceset_make_gaps', - 'ttext_from_base_temp', - 'ttextinst_make', - 'ttextseq_from_base_tstzspan', - 'ttextseq_from_base_tstzset', - 'ttextseqset_from_base_tstzspanset', - 'temporal_to_tstzspan', - 'tfloat_to_tint', - 'tint_to_tfloat', - 'tnumber_to_span', - 'tbool_end_value', - 'tbool_start_value', - 'tbool_values', - 'temporal_duration', - 'temporal_end_instant', - 'temporal_end_sequence', - 'temporal_end_timestamptz', - 'temporal_hash', - 'temporal_instant_n', - 'temporal_instants', - 'temporal_interp', - 'temporal_max_instant', - 'temporal_min_instant', - 'temporal_num_instants', - 'temporal_num_sequences', - 'temporal_num_timestamps', - 'temporal_segments', - 'temporal_sequence_n', - 'temporal_sequences', - 'temporal_start_instant', - 'temporal_start_sequence', - 'temporal_start_timestamptz', - 'temporal_stops', - 'temporal_subtype', - 'temporal_time', - 'temporal_timestamptz_n', - 'temporal_timestamps', - 'tfloat_end_value', - 'tfloat_max_value', - 'tfloat_min_value', - 'tfloat_start_value', - 'tfloat_values', - 'tint_end_value', - 'tint_max_value', - 'tint_min_value', - 'tint_start_value', - 'tint_values', - 'tnumber_valuespans', - 'tpoint_end_value', - 'tpoint_start_value', - 'tpoint_values', - 'ttext_end_value', - 'ttext_max_value', - 'ttext_min_value', - 'ttext_start_value', - 'ttext_values', - 'temporal_scale_time', - 'temporal_set_interp', - 'temporal_shift_scale_time', - 'temporal_shift_time', - 'temporal_to_tinstant', - 'temporal_to_tsequence', - 'temporal_to_tsequenceset', - 'tfloat_scale_value', - 'tfloat_shift_scale_value', - 'tfloat_shift_value', - 'tint_scale_value', - 'tint_shift_scale_value', - 'tint_shift_value', - 'temporal_append_tinstant', - 'temporal_append_tsequence', - 'temporal_delete_tstzspan', - 'temporal_delete_tstzspanset', - 'temporal_delete_timestamptz', - 'temporal_delete_tstzset', - 'temporal_insert', - 'temporal_merge', - 'temporal_merge_array', - 'temporal_update', - 'tbool_at_value', - 'tbool_minus_value', - 'tbool_value_at_timestamptz', - 'temporal_at_max', - 'temporal_at_min', - 'temporal_at_tstzspan', - 'temporal_at_tstzspanset', - 'temporal_at_timestamptz', - 'temporal_at_tstzset', - 'temporal_at_values', - 'temporal_minus_max', - 'temporal_minus_min', - 'temporal_minus_tstzspan', - 'temporal_minus_tstzspanset', - 'temporal_minus_timestamptz', - 'temporal_minus_tstzset', - 'temporal_minus_values', - 'tfloat_at_value', - 'tfloat_minus_value', - 'tfloat_value_at_timestamptz', - 'tint_at_value', - 'tint_minus_value', - 'tint_value_at_timestamptz', - 'tnumber_at_span', - 'tnumber_at_spanset', - 'tnumber_at_tbox', - 'tnumber_minus_span', - 'tnumber_minus_spanset', - 'tnumber_minus_tbox', - 'tpoint_at_geom_time', - 'tpoint_at_stbox', - 'tpoint_at_value', - 'tpoint_minus_geom_time', - 'tpoint_minus_stbox', - 'tpoint_minus_value', - 'tpoint_value_at_timestamptz', - 'ttext_at_value', - 'ttext_minus_value', - 'ttext_value_at_timestamptz', - 'temporal_cmp', - 'temporal_eq', - 'temporal_ge', - 'temporal_gt', - 'temporal_le', - 'temporal_lt', - 'temporal_ne', - 'tbool_always_eq', - 'tbool_ever_eq', - 'tfloat_always_eq', - 'tfloat_always_le', - 'tfloat_always_lt', - 'tfloat_ever_eq', - 'tfloat_ever_le', - 'tfloat_ever_lt', - 'tint_always_eq', - 'tint_always_le', - 'tint_always_lt', - 'tint_ever_eq', - 'tint_ever_le', - 'tint_ever_lt', - 'tpoint_always_eq', - 'tpoint_ever_eq', - 'ttext_always_eq', - 'ttext_always_le', - 'ttext_always_lt', - 'ttext_ever_eq', - 'ttext_ever_le', - 'ttext_ever_lt', - 'teq_bool_tbool', - 'teq_float_tfloat', - 'teq_int_tint', - 'teq_point_tpoint', - 'teq_tbool_bool', - 'teq_temporal_temporal', - 'teq_text_ttext', - 'teq_tfloat_float', - 'teq_tpoint_point', - 'teq_tint_int', - 'teq_ttext_text', - 'tge_float_tfloat', - 'tge_int_tint', - 'tge_temporal_temporal', - 'tge_text_ttext', - 'tge_tfloat_float', - 'tge_tint_int', - 'tge_ttext_text', - 'tgt_float_tfloat', - 'tgt_int_tint', - 'tgt_temporal_temporal', - 'tgt_text_ttext', - 'tgt_tfloat_float', - 'tgt_tint_int', - 'tgt_ttext_text', - 'tle_float_tfloat', - 'tle_int_tint', - 'tle_temporal_temporal', - 'tle_text_ttext', - 'tle_tfloat_float', - 'tle_tint_int', - 'tle_ttext_text', - 'tlt_float_tfloat', - 'tlt_int_tint', - 'tlt_temporal_temporal', - 'tlt_text_ttext', - 'tlt_tfloat_float', - 'tlt_tint_int', - 'tlt_ttext_text', - 'tne_bool_tbool', - 'tne_float_tfloat', - 'tne_int_tint', - 'tne_point_tpoint', - 'tne_tbool_bool', - 'tne_temporal_temporal', - 'tne_text_ttext', - 'tne_tfloat_float', - 'tne_tpoint_point', - 'tne_tint_int', - 'tne_ttext_text', - 'adjacent_numspan_tnumber', - 'adjacent_stbox_tpoint', - 'adjacent_tbox_tnumber', - 'adjacent_temporal_temporal', - 'adjacent_temporal_tstzspan', - 'adjacent_tnumber_numspan', - 'adjacent_tnumber_tbox', - 'adjacent_tnumber_tnumber', - 'adjacent_tpoint_stbox', - 'adjacent_tpoint_tpoint', - 'adjacent_tstzspan_temporal', - 'contained_numspan_tnumber', - 'contained_stbox_tpoint', - 'contained_tbox_tnumber', - 'contained_temporal_temporal', - 'contained_temporal_tstzspan', - 'contained_tnumber_numspan', - 'contained_tnumber_tbox', - 'contained_tnumber_tnumber', - 'contained_tpoint_stbox', - 'contained_tpoint_tpoint', - 'contained_tstzspan_temporal', - 'contains_numspan_tnumber', - 'contains_stbox_tpoint', - 'contains_tbox_tnumber', - 'contains_temporal_tstzspan', - 'contains_temporal_temporal', - 'contains_tnumber_numspan', - 'contains_tnumber_tbox', - 'contains_tnumber_tnumber', - 'contains_tpoint_stbox', - 'contains_tpoint_tpoint', - 'contains_tstzspan_temporal', - 'overlaps_numspan_tnumber', - 'overlaps_stbox_tpoint', - 'overlaps_tbox_tnumber', - 'overlaps_temporal_temporal', - 'overlaps_temporal_tstzspan', - 'overlaps_tnumber_numspan', - 'overlaps_tnumber_tbox', - 'overlaps_tnumber_tnumber', - 'overlaps_tpoint_stbox', - 'overlaps_tpoint_tpoint', - 'overlaps_tstzspan_temporal', - 'same_numspan_tnumber', - 'same_stbox_tpoint', - 'same_tbox_tnumber', - 'same_temporal_temporal', - 'same_temporal_tstzspan', - 'same_tnumber_numspan', - 'same_tnumber_tbox', - 'same_tnumber_tnumber', - 'same_tpoint_stbox', - 'same_tpoint_tpoint', - 'same_tstzspan_temporal', - 'above_stbox_tpoint', - 'above_tpoint_stbox', - 'above_tpoint_tpoint', - 'after_stbox_tpoint', - 'after_tbox_tnumber', - 'after_temporal_tstzspan', - 'after_temporal_temporal', - 'after_tnumber_tbox', - 'after_tnumber_tnumber', - 'after_tpoint_stbox', - 'after_tpoint_tpoint', - 'after_tstzspan_temporal', - 'back_stbox_tpoint', - 'back_tpoint_stbox', - 'back_tpoint_tpoint', - 'before_stbox_tpoint', - 'before_tbox_tnumber', - 'before_temporal_tstzspan', - 'before_temporal_temporal', - 'before_tnumber_tbox', - 'before_tnumber_tnumber', - 'before_tpoint_stbox', - 'before_tpoint_tpoint', - 'before_tstzspan_temporal', - 'below_stbox_tpoint', - 'below_tpoint_stbox', - 'below_tpoint_tpoint', - 'front_stbox_tpoint', - 'front_tpoint_stbox', - 'front_tpoint_tpoint', - 'left_stbox_tpoint', - 'left_tbox_tnumber', - 'left_numspan_tnumber', - 'left_tnumber_numspan', - 'left_tnumber_tbox', - 'left_tnumber_tnumber', - 'left_tpoint_stbox', - 'left_tpoint_tpoint', - 'overabove_stbox_tpoint', - 'overabove_tpoint_stbox', - 'overabove_tpoint_tpoint', - 'overafter_stbox_tpoint', - 'overafter_tbox_tnumber', - 'overafter_temporal_tstzspan', - 'overafter_temporal_temporal', - 'overafter_tnumber_tbox', - 'overafter_tnumber_tnumber', - 'overafter_tpoint_stbox', - 'overafter_tpoint_tpoint', - 'overafter_tstzspan_temporal', - 'overback_stbox_tpoint', - 'overback_tpoint_stbox', - 'overback_tpoint_tpoint', - 'overbefore_stbox_tpoint', - 'overbefore_tbox_tnumber', - 'overbefore_temporal_tstzspan', - 'overbefore_temporal_temporal', - 'overbefore_tnumber_tbox', - 'overbefore_tnumber_tnumber', - 'overbefore_tpoint_stbox', - 'overbefore_tpoint_tpoint', - 'overbefore_tstzspan_temporal', - 'overbelow_stbox_tpoint', - 'overbelow_tpoint_stbox', - 'overbelow_tpoint_tpoint', - 'overfront_stbox_tpoint', - 'overfront_tpoint_stbox', - 'overfront_tpoint_tpoint', - 'overleft_numspan_tnumber', - 'overleft_stbox_tpoint', - 'overleft_tbox_tnumber', - 'overleft_tnumber_numspan', - 'overleft_tnumber_tbox', - 'overleft_tnumber_tnumber', - 'overleft_tpoint_stbox', - 'overleft_tpoint_tpoint', - 'overright_numspan_tnumber', - 'overright_stbox_tpoint', - 'overright_tbox_tnumber', - 'overright_tnumber_numspan', - 'overright_tnumber_tbox', - 'overright_tnumber_tnumber', - 'overright_tpoint_stbox', - 'overright_tpoint_tpoint', - 'right_numspan_tnumber', - 'right_stbox_tpoint', - 'right_tbox_tnumber', - 'right_tnumber_numspan', - 'right_tnumber_tbox', - 'right_tnumber_tnumber', - 'right_tpoint_stbox', - 'right_tpoint_tpoint', - 'tand_bool_tbool', - 'tand_tbool_bool', - 'tand_tbool_tbool', - 'tbool_when_true', - 'tnot_tbool', - 'tor_bool_tbool', - 'tor_tbool_bool', - 'tor_tbool_tbool', - 'add_float_tfloat', - 'add_int_tint', - 'add_tfloat_float', - 'add_tint_int', - 'add_tnumber_tnumber', - 'div_float_tfloat', - 'div_int_tint', - 'div_tfloat_float', - 'div_tint_int', - 'div_tnumber_tnumber', - 'float_degrees', - 'mult_float_tfloat', - 'mult_int_tint', - 'mult_tfloat_float', - 'mult_tint_int', - 'mult_tnumber_tnumber', - 'sub_float_tfloat', - 'sub_int_tint', - 'sub_tfloat_float', - 'sub_tint_int', - 'sub_tnumber_tnumber', - 'tfloat_round', - 'tfloatarr_round', - 'tfloat_degrees', - 'tfloat_derivative', - 'tfloat_radians', - 'tnumber_abs', - 'tnumber_angular_difference', - 'tnumber_delta_value', - 'textcat_text_ttext', - 'textcat_ttext_text', - 'textcat_ttext_ttext', - 'ttext_upper', - 'ttext_lower', - 'distance_tfloat_float', - 'distance_tint_int', - 'distance_tnumber_tnumber', - 'distance_tpoint_point', - 'distance_tpoint_tpoint', - 'nad_stbox_geo', - 'nad_stbox_stbox', - 'nad_tbox_tbox', - 'nad_tfloat_float', - 'nad_tfloat_tfloat', - 'nad_tint_int', - 'nad_tint_tint', - 'nad_tnumber_tbox', - 'nad_tpoint_geo', - 'nad_tpoint_stbox', - 'nad_tpoint_tpoint', - 'nai_tpoint_geo', - 'nai_tpoint_tpoint', - 'shortestline_tpoint_geo', - 'shortestline_tpoint_tpoint', - 'bearing_point_point', - 'bearing_tpoint_point', - 'bearing_tpoint_tpoint', - 'tpoint_angular_difference', - 'tpoint_azimuth', - 'tpoint_convex_hull', - 'tpoint_cumulative_length', - 'tpoint_direction', - 'tpoint_get_x', - 'tpoint_get_y', - 'tpoint_get_z', - 'tpoint_is_simple', - 'tpoint_length', - 'tpoint_speed', - 'tpoint_srid', - 'tpoint_stboxes', - 'tpoint_trajectory', - 'geo_expand_space', - 'geomeas_to_tpoint', - 'tgeogpoint_to_tgeompoint', - 'tgeompoint_to_tgeogpoint', - 'tpoint_AsMVTGeom', - 'tpoint_expand_space', - 'tpoint_make_simple', - 'tpoint_round', - 'tpointarr_round', - 'tpoint_set_srid', - 'tpoint_tfloat_to_geomeas', - 'econtains_geo_tpoint', - 'edisjoint_tpoint_geo', - 'edisjoint_tpoint_tpoint', - 'edwithin_tpoint_geo', - 'edwithin_tpoint_tpoint', - 'eintersects_tpoint_geo', - 'eintersects_tpoint_tpoint', - 'etouches_tpoint_geo', - 'tcontains_geo_tpoint', - 'tdisjoint_tpoint_geo', - 'tdwithin_tpoint_geo', - 'tdwithin_tpoint_tpoint', - 'tintersects_tpoint_geo', - 'ttouches_tpoint_geo', - 'tbool_tand_transfn', - 'tbool_tor_transfn', - 'temporal_extent_transfn', - 'temporal_tagg_finalfn', - 'temporal_tcount_transfn', - 'tfloat_tmax_transfn', - 'tfloat_tmin_transfn', - 'tfloat_tsum_transfn', - 'tint_tmax_transfn', - 'tint_tmin_transfn', - 'tint_tsum_transfn', - 'tnumber_extent_transfn', - 'tnumber_integral', - 'tnumber_tavg_finalfn', - 'tnumber_tavg_transfn', - 'tnumber_twavg', - 'tpoint_extent_transfn', - 'tpoint_tcentroid_finalfn', - 'tpoint_tcentroid_transfn', - 'tpoint_twcentroid', - 'ttext_tmax_transfn', - 'ttext_tmin_transfn', - 'temporal_simplify_min_dist', - 'temporal_simplify_min_tdelta', - 'temporal_simplify_dp', - 'temporal_simplify_max_dist', - 'temporal_tprecision', - 'temporal_tsample', - 'temporal_dyntimewarp_distance', - 'temporal_dyntimewarp_path', - 'temporal_frechet_distance', - 'temporal_frechet_path', - 'temporal_hausdorff_distance', - 'float_bucket', - 'floatspan_bucket_list', - 'int_bucket', - 'intspan_bucket_list', - 'tstzspan_bucket_list', - 'stbox_tile', - 'stbox_tile_list', - 'tintbox_tile_list', - 'tfloatbox_tile_list', - 'temporal_time_split', - 'tfloat_value_split', - 'tfloat_value_time_split', - 'timestamptz_bucket', - 'tint_value_split', - 'tint_value_time_split', - 'tpoint_space_split', - 'tpoint_space_time_split', - 'temptype_subtype', - 'temptype_subtype_all', - 'tempsubtype_name', - 'tempsubtype_from_string', - 'meosoper_name', - 'meosoper_from_string', - 'interptype_name', - 'interptype_from_string', - 'meostype_name', - 'temptype_basetype', - 'settype_basetype', - 'spantype_basetype', - 'spantype_spansettype', - 'spansettype_spantype', - 'basetype_spantype', - 'basetype_settype', - 'meostype_internal', - 'meos_basetype', - 'alpha_basetype', - 'tnumber_basetype', - 'alphanum_basetype', - 'geo_basetype', - 'spatial_basetype', - 'time_type', - 'set_basetype', - 'set_type', - 'numset_type', - 'ensure_numset_type', - 'timeset_type', - 'ensure_timeset_type', - 'set_spantype', - 'ensure_set_spantype', - 'alphanumset_type', - 'geoset_type', - 'ensure_geoset_type', - 'spatialset_type', - 'ensure_spatialset_type', - 'span_basetype', - 'span_canon_basetype', - 'span_type', - 'span_bbox_type', - 'numspan_basetype', - 'numspan_type', - 'ensure_numspan_type', - 'timespan_basetype', - 'timespan_type', - 'ensure_timespan_type', - 'spanset_type', - 'numspanset_type', - 'timespanset_type', - 'ensure_timespanset_type', - 'temporal_type', - 'temporal_basetype', - 'temptype_continuous', - 'basetype_byvalue', - 'basetype_varlength', - 'basetype_length', - 'talphanum_type', - 'talpha_type', - 'tnumber_type', - 'ensure_tnumber_type', - 'tnumber_basetype', - 'ensure_tnumber_basetype', - 'tnumber_settype', - 'tnumber_spantype', - 'tnumber_spansettype', - 'tspatial_type', - 'ensure_tspatial_type', - 'tspatial_basetype', - 'tgeo_type', - 'ensure_tgeo_type', - 'ensure_tnumber_tgeo_type', - 'datum_hash', - 'datum_hash_extended', - 'set_in', - 'set_out', - 'span_in', - 'span_out', - 'spanset_in', - 'spanset_out', - 'set_compact', - 'set_cp', - 'set_make', - 'set_make_exp', - 'set_make_free', - 'set_out', - 'span_cp', - 'span_make', - 'span_out', - 'span_set', - 'spanset_cp', - 'spanset_compact', - 'spanset_make_exp', - 'spanset_make_free', - 'spanset_out', - 'span_spanset', - 'value_to_set', - 'value_to_span', - 'value_to_spanset', - 'set_end_value', - 'set_mem_size', - 'set_set_span', - 'set_span', - 'set_start_value', - 'set_value_n', - 'set_values', - 'spanset_lower', - 'spanset_mem_size', - 'spanset_upper', - 'spatialset_set_stbox', - 'value_set_span', - 'datespan_set_tstzspan', - 'floatspan_rnd', - 'floatspan_set_intspan', - 'floatspan_set_numspan', - 'intspan_set_floatspan', - 'numset_shift_scale', - 'numspan_set_floatspan', - 'numspan_shift_scale', - 'numspanset_shift_scale', - 'set_compact', - 'span_expand', - 'spanset_compact', - 'tstzspan_set_datespan', - 'set_cmp1', - 'set_eq1', - 'span_cmp1', - 'span_eq1', - 'spanset_cmp1', - 'spanset_eq1', - 'spanbase_extent_transfn', - 'value_union_transfn', - 'adj_span_span', - 'adjacent_span_value', - 'adjacent_spanset_value', - 'cont_span_span', - 'contains_span_value', - 'contains_spanset_value', - 'contains_set_value', - 'contains_set_set', - 'contained_value_span', - 'contained_value_set', - 'contained_set_set', - 'contained_value_spanset', - 'over_span_span', - 'over_adj_span_span', - 'overlaps_value_span', - 'overlaps_value_spanset', - 'overlaps_span_value', - 'overlaps_spanset_value', - 'overlaps_set_set', - 'left_notadj_span_span', - 'left_set_set', - 'left_set_value', - 'left_span_value', - 'left_spanset_value', - 'left_value_set', - 'left_value_span', - 'left_value_spanset', - 'lf_span_span', - 'ri_span_span', - 'right_value_set', - 'right_set_value', - 'right_set_set', - 'right_value_span', - 'right_value_spanset', - 'right_span_value', - 'right_spanset_value', - 'overleft_value_set', - 'overleft_set_value', - 'overleft_set_set', - 'overleft_value_span', - 'overleft_value_spanset', - 'overleft_span_value', - 'overleft_spanset_value', - 'overright_value_set', - 'overright_set_value', - 'overright_set_set', - 'overright_value_span', - 'overright_value_spanset', - 'overright_span_value', - 'overright_spanset_value', - 'ovlf_span_span', - 'ovri_span_span', - 'inter_span_span', - 'intersection_set_value', - 'intersection_span_value', - 'intersection_spanset_value', - 'minus_set_value', - 'minus_span_value', - 'minus_spanset_value', - 'minus_value_set', - 'minus_value_span', - 'minus_value_spanset', - 'union_set_value', - 'union_span_value', - 'union_spanset_value', - 'dist_set_set', - 'dist_span_span', - 'distance_value_value', - 'distance_span_value', - 'distance_spanset_value', - 'distance_value_set', - 'distance_set_value', - 'datum_hash', - 'datum_hash_extended', - 'number_tstzspan_to_tbox', - 'number_timestamptz_to_tbox', - 'stbox_cp', - 'stbox_set', - 'tbox_cp', - 'tbox_set', - 'float_set_tbox', - 'geo_set_stbox', - 'geoarr_set_stbox', - 'int_set_tbox', - 'number_set_tbox', - 'number_to_tbox', - 'numset_set_tbox', - 'numspan_set_tbox', - 'numspanset_set_tbox', - 'tstzspan_set_stbox', - 'tstzspan_set_tbox', - 'tstzspanset_set_stbox', - 'tstzspanset_set_tbox', - 'stbox_set_box3d', - 'stbox_set_gbox', - 'timestamptz_set_stbox', - 'timestamptz_set_tbox', - 'tstzset_set_stbox', - 'tstzset_set_tbox', - 'tbox_shift_scale_value', - 'stbox_expand', - 'tbox_expand', - 'bbox_union_span_span', - 'inter_stbox_stbox', - 'inter_tbox_tbox', - 'geoarr_as_text', - 'tboolinst_as_mfjson', - 'tboolinst_from_mfjson', - 'tboolinst_in', - 'tboolseq_as_mfjson', - 'tboolseq_from_mfjson', - 'tboolseq_in', - 'tboolseqset_as_mfjson', - 'tboolseqset_from_mfjson', - 'tboolseqset_in', - 'temporal_in', - 'temporal_out', - 'temporal_values', - 'temporalarr_out', - 'tfloatinst_as_mfjson', - 'tfloatinst_from_mfjson', - 'tfloatinst_in', - 'tfloatseq_as_mfjson', - 'tfloatseq_from_mfjson', - 'tfloatseq_in', - 'tfloatseqset_as_mfjson', - 'tfloatseqset_from_mfjson', - 'tfloatseqset_in', - 'tgeogpointinst_from_mfjson', - 'tgeogpointinst_in', - 'tgeogpointseq_from_mfjson', - 'tgeogpointseq_in', - 'tgeogpointseqset_from_mfjson', - 'tgeogpointseqset_in', - 'tgeompointinst_from_mfjson', - 'tgeompointinst_in', - 'tgeompointseq_from_mfjson', - 'tgeompointseq_in', - 'tgeompointseqset_from_mfjson', - 'tgeompointseqset_in', - 'tinstant_as_mfjson', - 'tinstant_from_mfjson', - 'tinstant_in', - 'tinstant_out', - 'tintinst_as_mfjson', - 'tintinst_from_mfjson', - 'tintinst_in', - 'tintseq_as_mfjson', - 'tintseq_from_mfjson', - 'tintseq_in', - 'tintseqset_as_mfjson', - 'tintseqset_from_mfjson', - 'tintseqset_in', - 'tpointarr_as_text', - 'tpointinst_as_mfjson', - 'tpointseq_as_mfjson', - 'tpointseqset_as_mfjson', - 'tsequence_as_mfjson', - 'tsequence_from_mfjson', - 'tsequence_in', - 'tsequence_out', - 'tsequenceset_as_mfjson', - 'tsequenceset_from_mfjson', - 'tsequenceset_in', - 'tsequenceset_out', - 'ttextinst_as_mfjson', - 'ttextinst_from_mfjson', - 'ttextinst_in', - 'ttextseq_as_mfjson', - 'ttextseq_from_mfjson', - 'ttextseq_in', - 'ttextseqset_as_mfjson', - 'ttextseqset_from_mfjson', - 'ttextseqset_in', - 'temporal_cp', - 'temporal_from_base_temp', - 'tinstant_copy', - 'tinstant_make', - 'tpointseq_make_coords', - 'tsequence_from_base_tstzset', - 'tsequence_make_exp', - 'tsequence_compact', - 'tsequence_restart', - 'tsequence_subseq', - 'tsequence_copy', - 'tsequence_from_base_tstzspan', - 'tsequence_make_free', - 'tsequenceset_make_exp', - 'tsequenceset_compact', - 'tsequenceset_make_free', - 'tsequenceset_restart', - 'tsequenceset_copy', - 'tseqsetarr_to_tseqset', - 'tsequenceset_from_base_tstzspanset', - 'temporal_set_tstzspan', - 'tinstant_set_tstzspan', - 'tnumber_span', - 'tsequence_set_tstzspan', - 'tsequenceset_set_tstzspan', - 'temporal_end_value', - 'temporal_max_value', - 'temporal_mem_size', - 'temporal_min_value', - 'temporal_set_bbox', - 'tfloatseq_derivative', - 'tfloatseqset_derivative', - 'tnumber_set_span', - 'temporal_start_value', - 'tnumberinst_abs', - 'tnumberseq_abs', - 'tnumberseqset_abs', - 'tnumberseq_angular_difference', - 'tnumberseqset_angular_difference', - 'tnumberseq_delta_value', - 'tnumberseqset_delta_value', - 'tnumberinst_valuespans', - 'tnumberseq_valuespans', - 'tnumberseqset_valuespans', - 'tinstant_hash', - 'tinstant_instants', - 'tinstant_set_bbox', - 'tinstant_time', - 'tinstant_timestamps', - 'tinstant_value', - 'tinstant_value_at_timestamptz', - 'tinstant_value_copy', - 'tinstant_values', - 'tsequence_duration', - 'tsequence_end_timestamptz', - 'tsequence_hash', - 'tsequence_instants', - 'tsequence_max_instant', - 'tsequence_max_value', - 'tsequence_min_instant', - 'tsequence_min_value', - 'tsequence_segments', - 'tsequence_sequences', - 'tsequence_set_bbox', - 'tsequence_expand_bbox', - 'tsequenceset_expand_bbox', - 'tsequence_start_timestamptz', - 'tsequence_time', - 'tsequence_timestamps', - 'tsequence_value_at_timestamptz', - 'tsequence_values', - 'tsequenceset_duration', - 'tsequenceset_end_timestamptz', - 'tsequenceset_hash', - 'tsequenceset_inst_n', - 'tsequenceset_instants', - 'tsequenceset_max_instant', - 'tsequenceset_max_value', - 'tsequenceset_min_instant', - 'tsequenceset_min_value', - 'tsequenceset_num_instants', - 'tsequenceset_num_timestamps', - 'tsequenceset_segments', - 'tsequenceset_sequences', - 'tsequenceset_sequences_p', - 'tsequenceset_set_bbox', - 'tsequenceset_start_timestamptz', - 'tsequenceset_time', - 'tsequenceset_timespan', - 'tsequenceset_timestamptz_n', - 'tsequenceset_timestamps', - 'tsequenceset_value_at_timestamptz', - 'tsequenceset_values', - 'tinstant_merge', - 'tinstant_merge_array', - 'tinstant_shift_time', - 'tinstant_to_tsequence', - 'tinstant_to_tsequenceset', - 'tnumber_shift_scale_value', - 'tnuminst_shift_value', - 'tnumberseq_shift_scale_value', - 'tsequence_append_tinstant', - 'tsequence_append_tsequence', - 'tsequence_merge', - 'tsequence_merge_array', - 'tsequence_set_interp', - 'tsequence_shift_scale_time', - 'tsequence_to_tinstant', - 'tsequence_to_tdiscseq', - 'tsequence_to_tcontseq', - 'tsequence_to_tsequenceset', - 'tsequence_to_tsequenceset_interp', - 'tsequenceset_append_tinstant', - 'tsequenceset_append_tsequence', - 'tsequenceset_merge', - 'tsequenceset_merge_array', - 'tsequenceset_set_interp', - 'tnumberseqset_shift_scale_value', - 'tsequenceset_shift_scale_time', - 'tsequenceset_to_tinstant', - 'tsequenceset_to_discrete', - 'tsequenceset_to_step', - 'tsequenceset_to_linear', - 'tsequenceset_to_tsequence', - 'temporal_bbox_restrict_set', - 'temporal_restrict_minmax', - 'temporal_restrict_tstzspan', - 'temporal_restrict_tstzspanset', - 'temporal_restrict_timestamptz', - 'temporal_restrict_tstzset', - 'temporal_restrict_value', - 'temporal_restrict_values', - 'temporal_value_at_timestamptz', - 'tinstant_restrict_tstzspan', - 'tinstant_restrict_tstzspanset', - 'tinstant_restrict_timestamptz', - 'tinstant_restrict_tstzset', - 'tinstant_restrict_value', - 'tinstant_restrict_values', - 'tnumber_restrict_span', - 'tnumber_restrict_spanset', - 'tnumberinst_restrict_span', - 'tnumberinst_restrict_spanset', - 'tnumberseqset_restrict_span', - 'tnumberseqset_restrict_spanset', - 'tpoint_restrict_geom_time', - 'tpoint_restrict_stbox', - 'tpointinst_restrict_geom_time', - 'tpointinst_restrict_stbox', - 'tpointseq_restrict_geom_time', - 'tpointseq_restrict_stbox', - 'tpointseqset_restrict_geom_time', - 'tpointseqset_restrict_stbox', - 'tsequence_at_tstzspan', - 'tsequence_at_timestamptz', - 'tsequence_restrict_minmax', - 'tsequence_restrict_tstzspan', - 'tsequence_restrict_tstzspanset', - 'tsequence_restrict_timestamptz', - 'tsequence_restrict_tstzset', - 'tsequence_restrict_value', - 'tsequence_restrict_values', - 'tsequenceset_restrict_minmax', - 'tsequenceset_restrict_tstzspan', - 'tsequenceset_restrict_tstzspanset', - 'tsequenceset_restrict_timestamptz', - 'tsequenceset_restrict_tstzset', - 'tsequenceset_restrict_value', - 'tsequenceset_restrict_values', - 'tnumberseq_derivative', - 'tnumberseqset_derivative', - 'distance_tnumber_number', - 'nad_tnumber_number', - 'temporal_always_eq', - 'temporal_always_le', - 'temporal_always_lt', - 'temporal_ever_eq', - 'temporal_ever_le', - 'temporal_ever_lt', - 'tinstant_always_eq', - 'tinstant_always_le', - 'tinstant_always_lt', - 'tinstant_ever_eq', - 'tinstant_ever_le', - 'tinstant_ever_lt', - 'tpointinst_always_eq', - 'tpointinst_ever_eq', - 'tpointseq_always_eq', - 'tpointseq_ever_eq', - 'tpointseqset_always_eq', - 'tpointseqset_ever_eq', - 'tsequence_always_eq', - 'tsequence_always_le', - 'tsequence_always_lt', - 'tsequence_ever_eq', - 'tsequence_ever_le', - 'tsequence_ever_lt', - 'tsequenceset_always_eq', - 'tsequenceset_always_le', - 'tsequenceset_always_lt', - 'tsequenceset_ever_eq', - 'tsequenceset_ever_le', - 'tsequenceset_ever_lt', - 'tinstant_cmp', - 'tinstant_eq', - 'tsequence_cmp', - 'tsequence_eq', - 'tsequenceset_cmp', - 'tsequenceset_eq', - 'tpointinst_srid', - 'tpointseq_trajectory', - 'tpointseq_azimuth', - 'tpointseq_cumulative_length', - 'tpointseq_is_simple', - 'tpointseq_length', - 'tpointseq_speed', - 'tpointseq_srid', - 'tpointseq_stboxes', - 'tpointseqset_azimuth', - 'tpointseqset_cumulative_length', - 'tpointseqset_is_simple', - 'tpointseqset_length', - 'tpointseqset_speed', - 'tpointseqset_srid', - 'tpointseqset_stboxes', - 'tpointseqset_trajectory', - 'tpoint_get_coord', - 'tgeompointinst_tgeogpointinst', - 'tgeompointseq_tgeogpointseq', - 'tgeompointseqset_tgeogpointseqset', - 'tgeompoint_tgeogpoint', - 'tpointinst_set_srid', - 'tpointseq_make_simple', - 'tpointseq_set_srid', - 'tpointseqset_make_simple', - 'tpointseqset_set_srid', - 'tsequence_insert', - 'tsequenceset_insert', - 'tsequence_delete_timestamptz', - 'tsequence_delete_tstzset', - 'tsequence_delete_tstzspan', - 'tsequence_delete_tstzspanset', - 'tsequenceset_delete_timestamptz', - 'tsequenceset_delete_tstzset', - 'tsequenceset_delete_tstzspan', - 'tsequenceset_delete_tstzspanset', - 'tnumberseq_integral', - 'tnumberseq_twavg', - 'tnumberseqset_integral', - 'tnumberseqset_twavg', - 'tpointseq_twcentroid', - 'tpointseqset_twcentroid', - 'temporal_compact', - 'tsequence_compact', - 'tsequenceset_compact', - 'tbool_tand_transfn', - 'tbool_tor_transfn', - 'temporal_tagg_finalfn', - 'temporal_tcount_transfn', - 'tfloat_tmax_transfn', - 'tfloat_tmin_transfn', - 'tfloat_tsum_transfn', - 'tfloat_wmax_transfn', - 'tfloat_wmin_transfn', - 'tfloat_wsum_transfn', - 'tint_tmin_transfn', - 'tint_tmax_transfn', - 'tint_tsum_transfn', - 'tint_wmax_transfn', - 'tint_wmin_transfn', - 'tint_wsum_transfn', - 'tnumber_tavg_finalfn', - 'tnumber_tavg_transfn', - 'tnumber_wavg_transfn', - 'ttext_tmin_transfn', - 'ttext_tmax_transfn', - 'tnumber_value_split', - + "py_error_handler", + "create_pointer", + "get_address", + "datetime_to_timestamptz", + "timestamptz_to_datetime", + "date_to_date_adt", + "date_adt_to_date", + "timedelta_to_interval", + "interval_to_timedelta", + "geo_to_gserialized", + "geometry_to_gserialized", + "geography_to_gserialized", + "gserialized_to_shapely_point", + "gserialized_to_shapely_geometry", + "as_tinstant", + "as_tsequence", + "as_tsequenceset", + "lwpoint_make", + "lwgeom_from_gserialized", + "geo_from_lwgeom", + "lwgeom_get_srid", + "lwpoint_get_x", + "lwpoint_get_y", + "lwpoint_get_z", + "lwpoint_get_m", + "lwgeom_has_z", + "lwgeom_has_m", + "meos_errno", + "meos_errno_set", + "meos_errno_restore", + "meos_errno_reset", + "meos_set_datestyle", + "meos_set_intervalstyle", + "meos_get_datestyle", + "meos_get_intervalstyle", + "meos_initialize", + "meos_finalize", + "add_date_int", + "add_interval_interval", + "add_timestamptz_interval", + "bool_in", + "bool_out", + "cstring2text", + "date_to_timestamptz", + "minus_date_date", + "minus_date_int", + "minus_timestamptz_interval", + "minus_timestamptz_timestamptz", + "mult_interval_double", + "pg_date_in", + "pg_date_out", + "pg_interval_cmp", + "pg_interval_in", + "pg_interval_make", + "pg_interval_out", + "pg_time_in", + "pg_time_out", + "pg_timestamp_in", + "pg_timestamp_out", + "pg_timestamptz_in", + "pg_timestamptz_out", + "text2cstring", + "text_cmp", + "text_copy", + "text_out", + "timestamptz_to_date", + "geo_as_ewkb", + "geo_as_ewkt", + "geo_as_geojson", + "geo_as_hexewkb", + "geo_as_text", + "geo_from_ewkb", + "geo_from_geojson", + "geo_out", + "geo_same", + "geography_from_hexewkb", + "geography_from_text", + "geometry_from_hexewkb", + "geometry_from_text", + "pgis_geography_in", + "pgis_geometry_in", + "bigintset_in", + "bigintset_out", + "bigintspan_in", + "bigintspan_out", + "bigintspanset_in", + "bigintspanset_out", + "dateset_in", + "dateset_out", + "datespan_in", + "datespan_out", + "datespanset_in", + "datespanset_out", + "floatset_in", + "floatset_out", + "floatspan_in", + "floatspan_out", + "floatspanset_in", + "floatspanset_out", + "geogset_in", + "geomset_in", + "geoset_as_ewkt", + "geoset_as_text", + "geoset_out", + "intset_in", + "intset_out", + "intspan_in", + "intspan_out", + "intspanset_in", + "intspanset_out", + "set_as_hexwkb", + "set_as_wkb", + "set_from_hexwkb", + "set_from_wkb", + "span_as_hexwkb", + "span_as_wkb", + "span_from_hexwkb", + "span_from_wkb", + "spanset_as_hexwkb", + "spanset_as_wkb", + "spanset_from_hexwkb", + "spanset_from_wkb", + "textset_in", + "textset_out", + "tstzset_in", + "tstzset_out", + "tstzspan_in", + "tstzspan_out", + "tstzspanset_in", + "tstzspanset_out", + "bigintset_make", + "bigintspan_make", + "dateset_make", + "datespan_make", + "floatset_make", + "floatspan_make", + "geoset_make", + "intset_make", + "intspan_make", + "set_copy", + "span_copy", + "spanset_copy", + "spanset_make", + "textset_make", + "tstzset_make", + "tstzspan_make", + "bigint_to_set", + "bigint_to_span", + "bigint_to_spanset", + "date_to_set", + "date_to_span", + "date_to_spanset", + "dateset_to_tstzset", + "datespan_to_tstzspan", + "datespanset_to_tstzspanset", + "float_to_set", + "float_to_span", + "float_to_spanset", + "floatset_to_intset", + "floatspan_to_intspan", + "floatspanset_to_intspanset", + "geo_to_set", + "int_to_set", + "int_to_span", + "int_to_spanset", + "intset_to_floatset", + "intspan_to_floatspan", + "intspanset_to_floatspanset", + "set_to_spanset", + "span_to_spanset", + "text_to_set", + "timestamptz_to_set", + "timestamptz_to_span", + "timestamptz_to_spanset", + "tstzset_to_dateset", + "tstzspan_to_datespan", + "tstzspanset_to_datespanset", + "bigintset_end_value", + "bigintset_start_value", + "bigintset_value_n", + "bigintset_values", + "bigintspan_lower", + "bigintspan_upper", + "bigintspan_width", + "bigintspanset_lower", + "bigintspanset_upper", + "bigintspanset_width", + "dateset_end_value", + "dateset_start_value", + "dateset_value_n", + "dateset_values", + "datespan_duration", + "datespan_lower", + "datespan_upper", + "datespanset_date_n", + "datespanset_dates", + "datespanset_duration", + "datespanset_end_date", + "datespanset_num_dates", + "datespanset_start_date", + "floatset_end_value", + "floatset_start_value", + "floatset_value_n", + "floatset_values", + "floatspan_lower", + "floatspan_upper", + "floatspan_width", + "floatspanset_lower", + "floatspanset_upper", + "floatspanset_width", + "geoset_end_value", + "geoset_srid", + "geoset_start_value", + "geoset_value_n", + "geoset_values", + "intset_end_value", + "intset_start_value", + "intset_value_n", + "intset_values", + "intspan_lower", + "intspan_upper", + "intspan_width", + "intspanset_lower", + "intspanset_upper", + "intspanset_width", + "set_hash", + "set_hash_extended", + "set_num_values", + "set_to_span", + "span_hash", + "span_hash_extended", + "span_lower_inc", + "span_upper_inc", + "spanset_end_span", + "spanset_hash", + "spanset_hash_extended", + "spanset_lower_inc", + "spanset_num_spans", + "spanset_span", + "spanset_span_n", + "spanset_spans", + "spanset_start_span", + "spanset_upper_inc", + "textset_end_value", + "textset_start_value", + "textset_value_n", + "textset_values", + "tstzset_end_value", + "tstzset_start_value", + "tstzset_value_n", + "tstzset_values", + "tstzspan_duration", + "tstzspan_lower", + "tstzspan_upper", + "tstzspanset_duration", + "tstzspanset_end_timestamptz", + "tstzspanset_lower", + "tstzspanset_num_timestamps", + "tstzspanset_start_timestamptz", + "tstzspanset_timestamptz_n", + "tstzspanset_timestamps", + "tstzspanset_upper", + "bigintset_shift_scale", + "bigintspan_shift_scale", + "bigintspanset_shift_scale", + "dateset_shift_scale", + "datespan_shift_scale", + "datespanset_shift_scale", + "floatset_round", + "floatset_shift_scale", + "floatspan_round", + "floatspan_shift_scale", + "floatspanset_round", + "floatspanset_shift_scale", + "geoset_round", + "geoset_set_srid", + "intset_shift_scale", + "intspan_shift_scale", + "intspanset_shift_scale", + "textset_lower", + "textset_upper", + "timestamptz_tprecision", + "tstzset_shift_scale", + "tstzset_tprecision", + "tstzspan_shift_scale", + "tstzspan_tprecision", + "tstzspanset_shift_scale", + "tstzspanset_tprecision", + "set_cmp", + "set_eq", + "set_ge", + "set_gt", + "set_le", + "set_lt", + "set_ne", + "span_cmp", + "span_eq", + "span_ge", + "span_gt", + "span_le", + "span_lt", + "span_ne", + "spanset_cmp", + "spanset_eq", + "spanset_ge", + "spanset_gt", + "spanset_le", + "spanset_lt", + "spanset_ne", + "adjacent_span_bigint", + "adjacent_span_date", + "adjacent_span_float", + "adjacent_span_int", + "adjacent_span_span", + "adjacent_span_spanset", + "adjacent_span_timestamptz", + "adjacent_spanset_bigint", + "adjacent_spanset_date", + "adjacent_spanset_float", + "adjacent_spanset_int", + "adjacent_spanset_timestamptz", + "adjacent_spanset_span", + "adjacent_spanset_spanset", + "contained_bigint_set", + "contained_bigint_span", + "contained_bigint_spanset", + "contained_date_set", + "contained_date_span", + "contained_date_spanset", + "contained_float_set", + "contained_float_span", + "contained_float_spanset", + "contained_geo_set", + "contained_int_set", + "contained_int_span", + "contained_int_spanset", + "contained_set_set", + "contained_span_span", + "contained_span_spanset", + "contained_spanset_span", + "contained_spanset_spanset", + "contained_text_set", + "contained_timestamptz_set", + "contained_timestamptz_span", + "contained_timestamptz_spanset", + "contains_set_bigint", + "contains_set_date", + "contains_set_float", + "contains_set_geo", + "contains_set_int", + "contains_set_set", + "contains_set_text", + "contains_set_timestamptz", + "contains_span_bigint", + "contains_span_date", + "contains_span_float", + "contains_span_int", + "contains_span_span", + "contains_span_spanset", + "contains_span_timestamptz", + "contains_spanset_bigint", + "contains_spanset_date", + "contains_spanset_float", + "contains_spanset_int", + "contains_spanset_span", + "contains_spanset_spanset", + "contains_spanset_timestamptz", + "overlaps_set_set", + "overlaps_span_span", + "overlaps_span_spanset", + "overlaps_spanset_span", + "overlaps_spanset_spanset", + "after_date_set", + "after_date_span", + "after_date_spanset", + "after_set_date", + "after_set_timestamptz", + "after_span_date", + "after_span_timestamptz", + "after_spanset_date", + "after_spanset_timestamptz", + "after_timestamptz_set", + "after_timestamptz_span", + "after_timestamptz_spanset", + "before_date_set", + "before_date_span", + "before_date_spanset", + "before_set_date", + "before_set_timestamptz", + "before_span_date", + "before_span_timestamptz", + "before_spanset_date", + "before_spanset_timestamptz", + "before_timestamptz_set", + "before_timestamptz_span", + "before_timestamptz_spanset", + "left_bigint_set", + "left_bigint_span", + "left_bigint_spanset", + "left_float_set", + "left_float_span", + "left_float_spanset", + "left_int_set", + "left_int_span", + "left_int_spanset", + "left_set_bigint", + "left_set_float", + "left_set_int", + "left_set_set", + "left_set_text", + "left_span_bigint", + "left_span_float", + "left_span_int", + "left_span_span", + "left_span_spanset", + "left_spanset_bigint", + "left_spanset_float", + "left_spanset_int", + "left_spanset_span", + "left_spanset_spanset", + "left_text_set", + "overafter_date_set", + "overafter_date_span", + "overafter_date_spanset", + "overafter_set_date", + "overafter_set_timestamptz", + "overafter_span_date", + "overafter_span_timestamptz", + "overafter_spanset_date", + "overafter_spanset_timestamptz", + "overafter_timestamptz_set", + "overafter_timestamptz_span", + "overafter_timestamptz_spanset", + "overbefore_date_set", + "overbefore_date_span", + "overbefore_date_spanset", + "overbefore_set_date", + "overbefore_set_timestamptz", + "overbefore_span_date", + "overbefore_span_timestamptz", + "overbefore_spanset_date", + "overbefore_spanset_timestamptz", + "overbefore_timestamptz_set", + "overbefore_timestamptz_span", + "overbefore_timestamptz_spanset", + "overleft_bigint_set", + "overleft_bigint_span", + "overleft_bigint_spanset", + "overleft_float_set", + "overleft_float_span", + "overleft_float_spanset", + "overleft_int_set", + "overleft_int_span", + "overleft_int_spanset", + "overleft_set_bigint", + "overleft_set_float", + "overleft_set_int", + "overleft_set_set", + "overleft_set_text", + "overleft_span_bigint", + "overleft_span_float", + "overleft_span_int", + "overleft_span_span", + "overleft_span_spanset", + "overleft_spanset_bigint", + "overleft_spanset_float", + "overleft_spanset_int", + "overleft_spanset_span", + "overleft_spanset_spanset", + "overleft_text_set", + "overright_bigint_set", + "overright_bigint_span", + "overright_bigint_spanset", + "overright_float_set", + "overright_float_span", + "overright_float_spanset", + "overright_int_set", + "overright_int_span", + "overright_int_spanset", + "overright_set_bigint", + "overright_set_float", + "overright_set_int", + "overright_set_set", + "overright_set_text", + "overright_span_bigint", + "overright_span_float", + "overright_span_int", + "overright_span_span", + "overright_span_spanset", + "overright_spanset_bigint", + "overright_spanset_float", + "overright_spanset_int", + "overright_spanset_span", + "overright_spanset_spanset", + "overright_text_set", + "right_bigint_set", + "right_bigint_span", + "right_bigint_spanset", + "right_float_set", + "right_float_span", + "right_float_spanset", + "right_int_set", + "right_int_span", + "right_int_spanset", + "right_set_bigint", + "right_set_float", + "right_set_int", + "right_set_set", + "right_set_text", + "right_span_bigint", + "right_span_float", + "right_span_int", + "right_span_span", + "right_span_spanset", + "right_spanset_bigint", + "right_spanset_float", + "right_spanset_int", + "right_spanset_span", + "right_spanset_spanset", + "right_text_set", + "intersection_bigint_set", + "intersection_date_set", + "intersection_float_set", + "intersection_geo_set", + "intersection_int_set", + "intersection_set_bigint", + "intersection_set_date", + "intersection_set_float", + "intersection_set_geo", + "intersection_set_int", + "intersection_set_set", + "intersection_set_text", + "intersection_set_timestamptz", + "intersection_span_bigint", + "intersection_span_date", + "intersection_span_float", + "intersection_span_int", + "intersection_span_span", + "intersection_span_spanset", + "intersection_span_timestamptz", + "intersection_spanset_bigint", + "intersection_spanset_date", + "intersection_spanset_float", + "intersection_spanset_int", + "intersection_spanset_span", + "intersection_spanset_spanset", + "intersection_spanset_timestamptz", + "intersection_text_set", + "intersection_timestamptz_set", + "minus_bigint_set", + "minus_bigint_span", + "minus_bigint_spanset", + "minus_date_set", + "minus_date_span", + "minus_date_spanset", + "minus_float_set", + "minus_float_span", + "minus_float_spanset", + "minus_geo_set", + "minus_int_set", + "minus_int_span", + "minus_int_spanset", + "minus_set_bigint", + "minus_set_date", + "minus_set_float", + "minus_set_geo", + "minus_set_int", + "minus_set_set", + "minus_set_text", + "minus_set_timestamptz", + "minus_span_bigint", + "minus_span_date", + "minus_span_float", + "minus_span_int", + "minus_span_span", + "minus_span_spanset", + "minus_span_timestamptz", + "minus_spanset_bigint", + "minus_spanset_date", + "minus_spanset_float", + "minus_spanset_int", + "minus_spanset_span", + "minus_spanset_spanset", + "minus_spanset_timestamptz", + "minus_text_set", + "minus_timestamptz_set", + "minus_timestamptz_span", + "minus_timestamptz_spanset", + "union_bigint_set", + "union_bigint_span", + "union_bigint_spanset", + "union_date_set", + "union_date_span", + "union_date_spanset", + "union_float_set", + "union_float_span", + "union_float_spanset", + "union_geo_set", + "union_int_set", + "union_int_span", + "union_int_spanset", + "union_set_bigint", + "union_set_date", + "union_set_float", + "union_set_geo", + "union_set_int", + "union_set_set", + "union_set_text", + "union_set_timestamptz", + "union_span_bigint", + "union_span_date", + "union_span_float", + "union_span_int", + "union_span_span", + "union_span_spanset", + "union_span_timestamptz", + "union_spanset_bigint", + "union_spanset_date", + "union_spanset_float", + "union_spanset_int", + "union_spanset_span", + "union_spanset_spanset", + "union_spanset_timestamptz", + "union_text_set", + "union_timestamptz_set", + "union_timestamptz_span", + "union_timestamptz_spanset", + "distance_bigintset_bigintset", + "distance_bigintspan_bigintspan", + "distance_bigintspanset_bigintspan", + "distance_bigintspanset_bigintspanset", + "distance_dateset_dateset", + "distance_datespan_datespan", + "distance_datespanset_datespan", + "distance_datespanset_datespanset", + "distance_floatset_floatset", + "distance_floatspan_floatspan", + "distance_floatspanset_floatspan", + "distance_floatspanset_floatspanset", + "distance_intset_intset", + "distance_intspan_intspan", + "distance_intspanset_intspan", + "distance_intspanset_intspanset", + "distance_set_bigint", + "distance_set_date", + "distance_set_float", + "distance_set_int", + "distance_set_timestamptz", + "distance_span_bigint", + "distance_span_date", + "distance_span_float", + "distance_span_int", + "distance_span_timestamptz", + "distance_spanset_bigint", + "distance_spanset_date", + "distance_spanset_float", + "distance_spanset_int", + "distance_spanset_timestamptz", + "distance_tstzset_tstzset", + "distance_tstzspan_tstzspan", + "distance_tstzspanset_tstzspan", + "distance_tstzspanset_tstzspanset", + "bigint_extent_transfn", + "bigint_union_transfn", + "date_extent_transfn", + "date_union_transfn", + "float_extent_transfn", + "float_union_transfn", + "int_extent_transfn", + "int_union_transfn", + "set_extent_transfn", + "set_union_finalfn", + "set_union_transfn", + "span_extent_transfn", + "span_union_transfn", + "spanset_extent_transfn", + "spanset_union_finalfn", + "spanset_union_transfn", + "text_union_transfn", + "timestamptz_extent_transfn", + "timestamptz_union_transfn", + "tbox_in", + "tbox_out", + "tbox_from_wkb", + "tbox_from_hexwkb", + "stbox_from_wkb", + "stbox_from_hexwkb", + "tbox_as_wkb", + "tbox_as_hexwkb", + "stbox_as_wkb", + "stbox_as_hexwkb", + "stbox_in", + "stbox_out", + "float_tstzspan_to_tbox", + "float_timestamptz_to_tbox", + "geo_tstzspan_to_stbox", + "geo_timestamptz_to_stbox", + "int_tstzspan_to_tbox", + "int_timestamptz_to_tbox", + "numspan_tstzspan_to_tbox", + "numspan_timestamptz_to_tbox", + "stbox_copy", + "stbox_make", + "tbox_copy", + "tbox_make", + "float_to_tbox", + "geo_to_stbox", + "int_to_tbox", + "set_to_tbox", + "span_to_tbox", + "spanset_to_tbox", + "spatialset_to_stbox", + "stbox_to_gbox", + "stbox_to_box3d", + "stbox_to_geo", + "stbox_to_tstzspan", + "tstzspanset_to_tbox", + "tbox_to_intspan", + "tbox_to_floatspan", + "tbox_to_tstzspan", + "timestamptz_to_stbox", + "timestamptz_to_tbox", + "tstzset_to_stbox", + "tstzspan_to_stbox", + "tstzspanset_to_stbox", + "tnumber_to_tbox", + "tpoint_to_stbox", + "stbox_hast", + "stbox_hasx", + "stbox_hasz", + "stbox_isgeodetic", + "stbox_srid", + "stbox_tmax", + "stbox_tmax_inc", + "stbox_tmin", + "stbox_tmin_inc", + "stbox_xmax", + "stbox_xmin", + "stbox_ymax", + "stbox_ymin", + "stbox_zmax", + "stbox_zmin", + "tbox_hast", + "tbox_hasx", + "tbox_tmax", + "tbox_tmax_inc", + "tbox_tmin", + "tbox_tmin_inc", + "tbox_xmax", + "tbox_xmax_inc", + "tbox_xmin", + "tbox_xmin_inc", + "tboxfloat_xmax", + "tboxfloat_xmin", + "tboxint_xmax", + "tboxint_xmin", + "stbox_expand_space", + "stbox_expand_time", + "stbox_get_space", + "stbox_quad_split", + "stbox_round", + "stbox_set_srid", + "stbox_shift_scale_time", + "tbox_expand_time", + "tbox_expand_float", + "tbox_expand_int", + "tbox_round", + "tbox_shift_scale_float", + "tbox_shift_scale_int", + "tbox_shift_scale_time", + "union_tbox_tbox", + "intersection_tbox_tbox", + "union_stbox_stbox", + "intersection_stbox_stbox", + "adjacent_stbox_stbox", + "adjacent_tbox_tbox", + "contained_tbox_tbox", + "contained_stbox_stbox", + "contains_stbox_stbox", + "contains_tbox_tbox", + "overlaps_tbox_tbox", + "overlaps_stbox_stbox", + "same_tbox_tbox", + "same_stbox_stbox", + "left_tbox_tbox", + "overleft_tbox_tbox", + "right_tbox_tbox", + "overright_tbox_tbox", + "before_tbox_tbox", + "overbefore_tbox_tbox", + "after_tbox_tbox", + "overafter_tbox_tbox", + "left_stbox_stbox", + "overleft_stbox_stbox", + "right_stbox_stbox", + "overright_stbox_stbox", + "below_stbox_stbox", + "overbelow_stbox_stbox", + "above_stbox_stbox", + "overabove_stbox_stbox", + "front_stbox_stbox", + "overfront_stbox_stbox", + "back_stbox_stbox", + "overback_stbox_stbox", + "before_stbox_stbox", + "overbefore_stbox_stbox", + "after_stbox_stbox", + "overafter_stbox_stbox", + "tbox_eq", + "tbox_ne", + "tbox_cmp", + "tbox_lt", + "tbox_le", + "tbox_ge", + "tbox_gt", + "stbox_eq", + "stbox_ne", + "stbox_cmp", + "stbox_lt", + "stbox_le", + "stbox_ge", + "stbox_gt", + "tbool_in", + "tbool_out", + "temporal_as_hexwkb", + "temporal_as_mfjson", + "temporal_as_wkb", + "temporal_from_hexwkb", + "temporal_from_mfjson", + "temporal_from_wkb", + "tfloat_in", + "tfloat_out", + "tgeogpoint_in", + "tgeompoint_in", + "tint_in", + "tint_out", + "tpoint_as_ewkt", + "tpoint_as_text", + "tpoint_out", + "ttext_in", + "ttext_out", + "tbool_from_base_temp", + "tboolinst_make", + "tboolseq_from_base_tstzset", + "tboolseq_from_base_tstzspan", + "tboolseqset_from_base_tstzspanset", + "temporal_copy", + "tfloat_from_base_temp", + "tfloatinst_make", + "tfloatseq_from_base_tstzspan", + "tfloatseq_from_base_tstzset", + "tfloatseqset_from_base_tstzspanset", + "tint_from_base_temp", + "tintinst_make", + "tintseq_from_base_tstzspan", + "tintseq_from_base_tstzset", + "tintseqset_from_base_tstzspanset", + "tpoint_from_base_temp", + "tpointinst_make", + "tpointseq_from_base_tstzspan", + "tpointseq_from_base_tstzset", + "tpointseqset_from_base_tstzspanset", + "tsequence_make", + "tsequenceset_make", + "tsequenceset_make_gaps", + "ttext_from_base_temp", + "ttextinst_make", + "ttextseq_from_base_tstzspan", + "ttextseq_from_base_tstzset", + "ttextseqset_from_base_tstzspanset", + "temporal_to_tstzspan", + "tfloat_to_tint", + "tint_to_tfloat", + "tnumber_to_span", + "tbool_end_value", + "tbool_start_value", + "tbool_value_at_timestamptz", + "tbool_values", + "temporal_duration", + "temporal_end_instant", + "temporal_end_sequence", + "temporal_end_timestamptz", + "temporal_hash", + "temporal_instant_n", + "temporal_instants", + "temporal_interp", + "temporal_max_instant", + "temporal_min_instant", + "temporal_num_instants", + "temporal_num_sequences", + "temporal_num_timestamps", + "temporal_segments", + "temporal_sequence_n", + "temporal_sequences", + "temporal_lower_inc", + "temporal_upper_inc", + "temporal_start_instant", + "temporal_start_sequence", + "temporal_start_timestamptz", + "temporal_stops", + "temporal_subtype", + "temporal_time", + "temporal_timestamptz_n", + "temporal_timestamps", + "tfloat_end_value", + "tfloat_max_value", + "tfloat_min_value", + "tfloat_start_value", + "tfloat_value_at_timestamptz", + "tfloat_values", + "tint_end_value", + "tint_max_value", + "tint_min_value", + "tint_start_value", + "tint_value_at_timestamptz", + "tint_values", + "tnumber_integral", + "tnumber_twavg", + "tnumber_valuespans", + "tpoint_end_value", + "tpoint_start_value", + "tpoint_value_at_timestamptz", + "tpoint_values", + "ttext_end_value", + "ttext_max_value", + "ttext_min_value", + "ttext_start_value", + "ttext_value_at_timestamptz", + "ttext_values", + "float_degrees", + "temporal_scale_time", + "temporal_set_interp", + "temporal_shift_scale_time", + "temporal_shift_time", + "temporal_to_tinstant", + "temporal_to_tsequence", + "temporal_to_tsequenceset", + "tfloat_degrees", + "tfloat_radians", + "tfloat_round", + "tfloat_scale_value", + "tfloat_shift_scale_value", + "tfloat_shift_value", + "tfloatarr_round", + "tint_scale_value", + "tint_shift_scale_value", + "tint_shift_value", + "tpoint_round", + "tpointarr_round", + "temporal_append_tinstant", + "temporal_append_tsequence", + "temporal_delete_tstzspan", + "temporal_delete_tstzspanset", + "temporal_delete_timestamptz", + "temporal_delete_tstzset", + "temporal_insert", + "temporal_merge", + "temporal_merge_array", + "temporal_update", + "tbool_at_value", + "tbool_minus_value", + "temporal_at_max", + "temporal_at_min", + "temporal_at_tstzspan", + "temporal_at_tstzspanset", + "temporal_at_timestamptz", + "temporal_at_tstzset", + "temporal_at_values", + "temporal_minus_max", + "temporal_minus_min", + "temporal_minus_tstzspan", + "temporal_minus_tstzspanset", + "temporal_minus_timestamptz", + "temporal_minus_tstzset", + "temporal_minus_values", + "tfloat_at_value", + "tfloat_minus_value", + "tint_at_value", + "tint_minus_value", + "tnumber_at_span", + "tnumber_at_spanset", + "tnumber_at_tbox", + "tnumber_minus_span", + "tnumber_minus_spanset", + "tnumber_minus_tbox", + "tpoint_at_geom_time", + "tpoint_at_stbox", + "tpoint_at_value", + "tpoint_minus_geom_time", + "tpoint_minus_stbox", + "tpoint_minus_value", + "ttext_at_value", + "ttext_minus_value", + "temporal_cmp", + "temporal_eq", + "temporal_ge", + "temporal_gt", + "temporal_le", + "temporal_lt", + "temporal_ne", + "always_eq_bool_tbool", + "always_eq_float_tfloat", + "always_eq_int_tint", + "always_eq_point_tpoint", + "always_eq_tbool_bool", + "always_eq_temporal_temporal", + "always_eq_text_ttext", + "always_eq_tfloat_float", + "always_eq_tint_int", + "always_eq_tpoint_point", + "always_eq_tpoint_tpoint", + "always_eq_ttext_text", + "always_ne_bool_tbool", + "always_ne_float_tfloat", + "always_ne_int_tint", + "always_ne_point_tpoint", + "always_ne_tbool_bool", + "always_ne_temporal_temporal", + "always_ne_text_ttext", + "always_ne_tfloat_float", + "always_ne_tint_int", + "always_ne_tpoint_point", + "always_ne_tpoint_tpoint", + "always_ne_ttext_text", + "always_ge_float_tfloat", + "always_ge_int_tint", + "always_ge_temporal_temporal", + "always_ge_text_ttext", + "always_ge_tfloat_float", + "always_ge_tint_int", + "always_ge_ttext_text", + "always_gt_float_tfloat", + "always_gt_int_tint", + "always_gt_temporal_temporal", + "always_gt_text_ttext", + "always_gt_tfloat_float", + "always_gt_tint_int", + "always_gt_ttext_text", + "always_le_float_tfloat", + "always_le_int_tint", + "always_le_temporal_temporal", + "always_le_text_ttext", + "always_le_tfloat_float", + "always_le_tint_int", + "always_le_ttext_text", + "always_lt_float_tfloat", + "always_lt_int_tint", + "always_lt_temporal_temporal", + "always_lt_text_ttext", + "always_lt_tfloat_float", + "always_lt_tint_int", + "always_lt_ttext_text", + "ever_eq_bool_tbool", + "ever_eq_float_tfloat", + "ever_eq_int_tint", + "ever_eq_point_tpoint", + "ever_eq_tbool_bool", + "ever_eq_temporal_temporal", + "ever_eq_text_ttext", + "ever_eq_tfloat_float", + "ever_eq_tint_int", + "ever_eq_tpoint_point", + "ever_eq_tpoint_tpoint", + "ever_eq_ttext_text", + "ever_ge_float_tfloat", + "ever_ge_int_tint", + "ever_ge_temporal_temporal", + "ever_ge_text_ttext", + "ever_ge_tfloat_float", + "ever_ge_tint_int", + "ever_ge_ttext_text", + "ever_gt_float_tfloat", + "ever_gt_int_tint", + "ever_gt_temporal_temporal", + "ever_gt_text_ttext", + "ever_gt_tfloat_float", + "ever_gt_tint_int", + "ever_gt_ttext_text", + "ever_le_float_tfloat", + "ever_le_int_tint", + "ever_le_temporal_temporal", + "ever_le_text_ttext", + "ever_le_tfloat_float", + "ever_le_tint_int", + "ever_le_ttext_text", + "ever_lt_float_tfloat", + "ever_lt_int_tint", + "ever_lt_temporal_temporal", + "ever_lt_text_ttext", + "ever_lt_tfloat_float", + "ever_lt_tint_int", + "ever_lt_ttext_text", + "ever_ne_bool_tbool", + "ever_ne_float_tfloat", + "ever_ne_int_tint", + "ever_ne_point_tpoint", + "ever_ne_tbool_bool", + "ever_ne_temporal_temporal", + "ever_ne_text_ttext", + "ever_ne_tfloat_float", + "ever_ne_tint_int", + "ever_ne_tpoint_point", + "ever_ne_tpoint_tpoint", + "ever_ne_ttext_text", + "teq_bool_tbool", + "teq_float_tfloat", + "teq_int_tint", + "teq_point_tpoint", + "teq_tbool_bool", + "teq_temporal_temporal", + "teq_text_ttext", + "teq_tfloat_float", + "teq_tpoint_point", + "teq_tpoint_tpoint", + "teq_tint_int", + "teq_ttext_text", + "tge_float_tfloat", + "tge_int_tint", + "tge_temporal_temporal", + "tge_text_ttext", + "tge_tfloat_float", + "tge_tint_int", + "tge_ttext_text", + "tgt_float_tfloat", + "tgt_int_tint", + "tgt_temporal_temporal", + "tgt_text_ttext", + "tgt_tfloat_float", + "tgt_tint_int", + "tgt_ttext_text", + "tle_float_tfloat", + "tle_int_tint", + "tle_temporal_temporal", + "tle_text_ttext", + "tle_tfloat_float", + "tle_tint_int", + "tle_ttext_text", + "tlt_float_tfloat", + "tlt_int_tint", + "tlt_temporal_temporal", + "tlt_text_ttext", + "tlt_tfloat_float", + "tlt_tint_int", + "tlt_ttext_text", + "tne_bool_tbool", + "tne_float_tfloat", + "tne_int_tint", + "tne_point_tpoint", + "tne_tbool_bool", + "tne_temporal_temporal", + "tne_text_ttext", + "tne_tfloat_float", + "tne_tpoint_point", + "tne_tpoint_tpoint", + "tne_tint_int", + "tne_ttext_text", + "adjacent_numspan_tnumber", + "adjacent_stbox_tpoint", + "adjacent_tbox_tnumber", + "adjacent_temporal_temporal", + "adjacent_temporal_tstzspan", + "adjacent_tnumber_numspan", + "adjacent_tnumber_tbox", + "adjacent_tnumber_tnumber", + "adjacent_tpoint_stbox", + "adjacent_tpoint_tpoint", + "adjacent_tstzspan_temporal", + "contained_numspan_tnumber", + "contained_stbox_tpoint", + "contained_tbox_tnumber", + "contained_temporal_temporal", + "contained_temporal_tstzspan", + "contained_tnumber_numspan", + "contained_tnumber_tbox", + "contained_tnumber_tnumber", + "contained_tpoint_stbox", + "contained_tpoint_tpoint", + "contained_tstzspan_temporal", + "contains_numspan_tnumber", + "contains_stbox_tpoint", + "contains_tbox_tnumber", + "contains_temporal_tstzspan", + "contains_temporal_temporal", + "contains_tnumber_numspan", + "contains_tnumber_tbox", + "contains_tnumber_tnumber", + "contains_tpoint_stbox", + "contains_tpoint_tpoint", + "contains_tstzspan_temporal", + "overlaps_numspan_tnumber", + "overlaps_stbox_tpoint", + "overlaps_tbox_tnumber", + "overlaps_temporal_temporal", + "overlaps_temporal_tstzspan", + "overlaps_tnumber_numspan", + "overlaps_tnumber_tbox", + "overlaps_tnumber_tnumber", + "overlaps_tpoint_stbox", + "overlaps_tpoint_tpoint", + "overlaps_tstzspan_temporal", + "same_numspan_tnumber", + "same_stbox_tpoint", + "same_tbox_tnumber", + "same_temporal_temporal", + "same_temporal_tstzspan", + "same_tnumber_numspan", + "same_tnumber_tbox", + "same_tnumber_tnumber", + "same_tpoint_stbox", + "same_tpoint_tpoint", + "same_tstzspan_temporal", + "above_stbox_tpoint", + "above_tpoint_stbox", + "above_tpoint_tpoint", + "after_stbox_tpoint", + "after_tbox_tnumber", + "after_temporal_tstzspan", + "after_temporal_temporal", + "after_tnumber_tbox", + "after_tnumber_tnumber", + "after_tpoint_stbox", + "after_tpoint_tpoint", + "after_tstzspan_temporal", + "back_stbox_tpoint", + "back_tpoint_stbox", + "back_tpoint_tpoint", + "before_stbox_tpoint", + "before_tbox_tnumber", + "before_temporal_tstzspan", + "before_temporal_temporal", + "before_tnumber_tbox", + "before_tnumber_tnumber", + "before_tpoint_stbox", + "before_tpoint_tpoint", + "before_tstzspan_temporal", + "below_stbox_tpoint", + "below_tpoint_stbox", + "below_tpoint_tpoint", + "front_stbox_tpoint", + "front_tpoint_stbox", + "front_tpoint_tpoint", + "left_stbox_tpoint", + "left_tbox_tnumber", + "left_numspan_tnumber", + "left_tnumber_numspan", + "left_tnumber_tbox", + "left_tnumber_tnumber", + "left_tpoint_stbox", + "left_tpoint_tpoint", + "overabove_stbox_tpoint", + "overabove_tpoint_stbox", + "overabove_tpoint_tpoint", + "overafter_stbox_tpoint", + "overafter_tbox_tnumber", + "overafter_temporal_tstzspan", + "overafter_temporal_temporal", + "overafter_tnumber_tbox", + "overafter_tnumber_tnumber", + "overafter_tpoint_stbox", + "overafter_tpoint_tpoint", + "overafter_tstzspan_temporal", + "overback_stbox_tpoint", + "overback_tpoint_stbox", + "overback_tpoint_tpoint", + "overbefore_stbox_tpoint", + "overbefore_tbox_tnumber", + "overbefore_temporal_tstzspan", + "overbefore_temporal_temporal", + "overbefore_tnumber_tbox", + "overbefore_tnumber_tnumber", + "overbefore_tpoint_stbox", + "overbefore_tpoint_tpoint", + "overbefore_tstzspan_temporal", + "overbelow_stbox_tpoint", + "overbelow_tpoint_stbox", + "overbelow_tpoint_tpoint", + "overfront_stbox_tpoint", + "overfront_tpoint_stbox", + "overfront_tpoint_tpoint", + "overleft_numspan_tnumber", + "overleft_stbox_tpoint", + "overleft_tbox_tnumber", + "overleft_tnumber_numspan", + "overleft_tnumber_tbox", + "overleft_tnumber_tnumber", + "overleft_tpoint_stbox", + "overleft_tpoint_tpoint", + "overright_numspan_tnumber", + "overright_stbox_tpoint", + "overright_tbox_tnumber", + "overright_tnumber_numspan", + "overright_tnumber_tbox", + "overright_tnumber_tnumber", + "overright_tpoint_stbox", + "overright_tpoint_tpoint", + "right_numspan_tnumber", + "right_stbox_tpoint", + "right_tbox_tnumber", + "right_tnumber_numspan", + "right_tnumber_tbox", + "right_tnumber_tnumber", + "right_tpoint_stbox", + "right_tpoint_tpoint", + "tand_bool_tbool", + "tand_tbool_bool", + "tand_tbool_tbool", + "tbool_when_true", + "tnot_tbool", + "tor_bool_tbool", + "tor_tbool_bool", + "tor_tbool_tbool", + "add_float_tfloat", + "add_int_tint", + "add_tfloat_float", + "add_tint_int", + "add_tnumber_tnumber", + "div_float_tfloat", + "div_int_tint", + "div_tfloat_float", + "div_tint_int", + "div_tnumber_tnumber", + "mult_float_tfloat", + "mult_int_tint", + "mult_tfloat_float", + "mult_tint_int", + "mult_tnumber_tnumber", + "sub_float_tfloat", + "sub_int_tint", + "sub_tfloat_float", + "sub_tint_int", + "sub_tnumber_tnumber", + "tfloat_derivative", + "tnumber_abs", + "tnumber_angular_difference", + "tnumber_delta_value", + "textcat_text_ttext", + "textcat_ttext_text", + "textcat_ttext_ttext", + "ttext_upper", + "ttext_lower", + "distance_tfloat_float", + "distance_tint_int", + "distance_tnumber_tnumber", + "distance_tpoint_point", + "distance_tpoint_tpoint", + "nad_stbox_geo", + "nad_stbox_stbox", + "nad_tbox_tbox", + "nad_tfloat_float", + "nad_tfloat_tfloat", + "nad_tint_int", + "nad_tint_tint", + "nad_tnumber_tbox", + "nad_tpoint_geo", + "nad_tpoint_stbox", + "nad_tpoint_tpoint", + "nai_tpoint_geo", + "nai_tpoint_tpoint", + "shortestline_tpoint_geo", + "shortestline_tpoint_tpoint", + "bearing_point_point", + "bearing_tpoint_point", + "bearing_tpoint_tpoint", + "tpoint_angular_difference", + "tpoint_azimuth", + "tpoint_convex_hull", + "tpoint_cumulative_length", + "tpoint_direction", + "tpoint_get_x", + "tpoint_get_y", + "tpoint_get_z", + "tpoint_is_simple", + "tpoint_length", + "tpoint_speed", + "tpoint_srid", + "tpoint_stboxes", + "tpoint_trajectory", + "tpoint_twcentroid", + "geo_expand_space", + "geomeas_to_tpoint", + "tgeogpoint_to_tgeompoint", + "tgeompoint_to_tgeogpoint", + "tpoint_AsMVTGeom", + "tpoint_expand_space", + "tpoint_make_simple", + "tpoint_set_srid", + "tpoint_tfloat_to_geomeas", + "acontains_geo_tpoint", + "adisjoint_tpoint_geo", + "adisjoint_tpoint_tpoint", + "adwithin_tpoint_geo", + "adwithin_tpoint_tpoint", + "aintersects_tpoint_geo", + "aintersects_tpoint_tpoint", + "atouches_tpoint_geo", + "econtains_geo_tpoint", + "edisjoint_tpoint_geo", + "edisjoint_tpoint_tpoint", + "edwithin_tpoint_geo", + "edwithin_tpoint_tpoint", + "eintersects_tpoint_geo", + "eintersects_tpoint_tpoint", + "etouches_tpoint_geo", + "tcontains_geo_tpoint", + "tdisjoint_tpoint_geo", + "tdwithin_tpoint_geo", + "tdwithin_tpoint_tpoint", + "tintersects_tpoint_geo", + "ttouches_tpoint_geo", + "tbool_tand_transfn", + "tbool_tor_transfn", + "temporal_extent_transfn", + "temporal_tagg_finalfn", + "temporal_tcount_transfn", + "tfloat_tmax_transfn", + "tfloat_tmin_transfn", + "tfloat_tsum_transfn", + "tfloat_wmax_transfn", + "tfloat_wmin_transfn", + "tfloat_wsum_transfn", + "timestamptz_tcount_transfn", + "tint_tmax_transfn", + "tint_tmin_transfn", + "tint_tsum_transfn", + "tint_wmax_transfn", + "tint_wmin_transfn", + "tint_wsum_transfn", + "tnumber_extent_transfn", + "tnumber_tavg_finalfn", + "tnumber_tavg_transfn", + "tnumber_wavg_transfn", + "tpoint_extent_transfn", + "tpoint_tcentroid_finalfn", + "tpoint_tcentroid_transfn", + "tstzset_tcount_transfn", + "tstzspan_tcount_transfn", + "tstzspanset_tcount_transfn", + "ttext_tmax_transfn", + "ttext_tmin_transfn", + "temporal_simplify_dp", + "temporal_simplify_max_dist", + "temporal_simplify_min_dist", + "temporal_simplify_min_tdelta", + "temporal_tprecision", + "temporal_tsample", + "temporal_dyntimewarp_distance", + "temporal_dyntimewarp_path", + "temporal_frechet_distance", + "temporal_frechet_path", + "temporal_hausdorff_distance", + "float_bucket", + "floatspan_bucket_list", + "int_bucket", + "intspan_bucket_list", + "stbox_tile", + "stbox_tile_list", + "temporal_time_split", + "tfloat_value_split", + "tfloat_value_time_split", + "tfloatbox_tile", + "tfloatbox_tile_list", + "timestamptz_bucket", + "tint_value_split", + "tint_value_time_split", + "tintbox_tile", + "tintbox_tile_list", + "tpoint_space_time_split", + "tstzspan_bucket_list", + "temptype_subtype", + "temptype_subtype_all", + "tempsubtype_name", + "tempsubtype_from_string", + "meosoper_name", + "meosoper_from_string", + "interptype_name", + "interptype_from_string", + "meostype_name", + "temptype_basetype", + "settype_basetype", + "spantype_basetype", + "spantype_spansettype", + "spansettype_spantype", + "basetype_spantype", + "basetype_settype", + "meos_basetype", + "alpha_basetype", + "tnumber_basetype", + "alphanum_basetype", + "geo_basetype", + "spatial_basetype", + "time_type", + "set_basetype", + "set_type", + "numset_type", + "ensure_numset_type", + "timeset_type", + "ensure_timeset_type", + "set_spantype", + "ensure_set_spantype", + "alphanumset_type", + "geoset_type", + "ensure_geoset_type", + "spatialset_type", + "ensure_spatialset_type", + "span_basetype", + "span_canon_basetype", + "span_type", + "span_bbox_type", + "numspan_basetype", + "numspan_type", + "ensure_numspan_type", + "timespan_basetype", + "timespan_type", + "ensure_timespan_type", + "spanset_type", + "numspanset_type", + "timespanset_type", + "ensure_timespanset_type", + "temporal_type", + "temporal_basetype", + "temptype_continuous", + "basetype_byvalue", + "basetype_varlength", + "basetype_length", + "talphanum_type", + "talpha_type", + "tnumber_type", + "ensure_tnumber_type", + "tnumber_basetype", + "ensure_tnumber_basetype", + "tnumber_settype", + "tnumber_spantype", + "tnumber_spansettype", + "tspatial_type", + "ensure_tspatial_type", + "tspatial_basetype", + "tgeo_type", + "ensure_tgeo_type", + "ensure_tnumber_tgeo_type", + "datum_hash", + "datum_hash_extended", + "set_in", + "set_out", + "span_in", + "span_out", + "spanset_in", + "spanset_out", + "set_cp", + "set_make", + "set_make_exp", + "set_make_free", + "span_cp", + "span_make", + "span_set", + "spanset_cp", + "spanset_make_exp", + "spanset_make_free", + "datespan_tstzspan", + "datespanset_tstzspanset", + "intspan_floatspan", + "intspanset_floatspanset", + "floatspan_intspan", + "floatspanset_intspanset", + "set_span", + "set_spanset", + "span_spanset", + "tstzspan_datespan", + "tstzspanset_datespanset", + "value_set_span", + "value_to_set", + "value_to_span", + "value_to_spanset", + "numspan_width", + "numspanset_width", + "set_end_value", + "set_mem_size", + "set_set_span", + "set_span", + "set_start_value", + "set_value_n", + "set_vals", + "set_values", + "spanset_lower", + "spanset_mem_size", + "spanset_sps", + "spanset_upper", + "datespan_set_tstzspan", + "floatspan_rnd", + "floatspan_set_intspan", + "intspan_set_floatspan", + "numset_shift_scale", + "numspan_shift_scale", + "numspanset_shift_scale", + "set_compact", + "span_expand", + "spanset_compact", + "tstzspan_set_datespan", + "adj_span_span", + "adjacent_span_value", + "adjacent_spanset_value", + "adjacent_value_spanset", + "cont_span_span", + "contained_value_set", + "contained_value_span", + "contained_value_spanset", + "contains_set_value", + "contains_span_value", + "contains_spanset_value", + "ovadj_span_span", + "over_span_span", + "left_set_value", + "left_span_value", + "left_spanset_value", + "left_value_set", + "left_value_span", + "left_value_spanset", + "lf_span_span", + "lfnadj_span_span", + "overleft_set_value", + "overleft_span_value", + "overleft_spanset_value", + "overleft_value_set", + "overleft_value_span", + "overleft_value_spanset", + "overright_set_value", + "overright_span_value", + "overright_spanset_value", + "overright_value_set", + "overright_value_span", + "overright_value_spanset", + "ovlf_span_span", + "ovri_span_span", + "ri_span_span", + "right_value_set", + "right_set_value", + "right_value_span", + "right_value_spanset", + "right_span_value", + "right_spanset_value", + "bbox_union_span_span", + "inter_span_span", + "intersection_set_value", + "intersection_span_value", + "intersection_spanset_value", + "intersection_value_set", + "intersection_value_span", + "intersection_value_spanset", + "mi_span_span", + "minus_set_value", + "minus_span_value", + "minus_spanset_value", + "minus_value_set", + "minus_value_span", + "minus_value_spanset", + "super_union_span_span", + "union_set_value", + "union_span_value", + "union_spanset_value", + "union_value_set", + "union_value_span", + "union_value_spanset", + "dist_set_set", + "dist_span_span", + "distance_set_set", + "distance_set_value", + "distance_span_span", + "distance_span_value", + "distance_spanset_span", + "distance_spanset_spanset", + "distance_spanset_value", + "distance_value_value", + "spanbase_extent_transfn", + "value_union_transfn", + "number_tstzspan_to_tbox", + "number_timestamptz_to_tbox", + "stbox_cp", + "stbox_set", + "tbox_cp", + "tbox_set", + "box3d_to_stbox", + "gbox_to_stbox", + "float_set_tbox", + "gbox_to_stbox", + "geo_set_stbox", + "geoarr_set_stbox", + "int_set_tbox", + "number_set_tbox", + "number_to_tbox", + "numset_set_tbox", + "numspan_set_tbox", + "numspanset_set_tbox", + "spatialset_set_stbox", + "stbox_set_box3d", + "stbox_set_gbox", + "timestamptz_set_stbox", + "timestamptz_set_tbox", + "tstzset_set_stbox", + "tstzset_set_tbox", + "tstzspan_set_stbox", + "tstzspan_set_tbox", + "tstzspanset_set_stbox", + "tstzspanset_set_tbox", + "tbox_shift_scale_value", + "stbox_expand", + "tbox_expand", + "inter_stbox_stbox", + "inter_tbox_tbox", + "geoarr_as_text", + "tboolinst_as_mfjson", + "tboolinst_from_mfjson", + "tboolinst_in", + "tboolseq_as_mfjson", + "tboolseq_from_mfjson", + "tboolseq_in", + "tboolseqset_as_mfjson", + "tboolseqset_from_mfjson", + "tboolseqset_in", + "temporal_in", + "temporal_out", + "temparr_out", + "tfloatinst_as_mfjson", + "tfloatinst_from_mfjson", + "tfloatinst_in", + "tfloatseq_as_mfjson", + "tfloatseq_from_mfjson", + "tfloatseq_in", + "tfloatseqset_as_mfjson", + "tfloatseqset_from_mfjson", + "tfloatseqset_in", + "tgeogpointinst_from_mfjson", + "tgeogpointinst_in", + "tgeogpointseq_from_mfjson", + "tgeogpointseq_in", + "tgeogpointseqset_from_mfjson", + "tgeogpointseqset_in", + "tgeompointinst_from_mfjson", + "tgeompointinst_in", + "tgeompointseq_from_mfjson", + "tgeompointseq_in", + "tgeompointseqset_from_mfjson", + "tgeompointseqset_in", + "tinstant_as_mfjson", + "tinstant_from_mfjson", + "tinstant_in", + "tinstant_out", + "tintinst_as_mfjson", + "tintinst_from_mfjson", + "tintinst_in", + "tintseq_as_mfjson", + "tintseq_from_mfjson", + "tintseq_in", + "tintseqset_as_mfjson", + "tintseqset_from_mfjson", + "tintseqset_in", + "tpointarr_as_text", + "tpointinst_as_mfjson", + "tpointseq_as_mfjson", + "tpointseqset_as_mfjson", + "tsequence_as_mfjson", + "tsequence_from_mfjson", + "tsequence_in", + "tsequence_out", + "tsequenceset_as_mfjson", + "tsequenceset_from_mfjson", + "tsequenceset_in", + "tsequenceset_out", + "ttextinst_as_mfjson", + "ttextinst_from_mfjson", + "ttextinst_in", + "ttextseq_as_mfjson", + "ttextseq_from_mfjson", + "ttextseq_in", + "ttextseqset_as_mfjson", + "ttextseqset_from_mfjson", + "ttextseqset_in", + "temporal_cp", + "temporal_from_base_temp", + "tinstant_copy", + "tinstant_make", + "tpointseq_make_coords", + "tsequence_copy", + "tsequence_from_base_tstzset", + "tsequence_from_base_tstzspan", + "tsequence_make_exp", + "tsequence_make_free", + "tsequenceset_copy", + "tseqsetarr_to_tseqset", + "tsequenceset_from_base_tstzspanset", + "tsequenceset_make_exp", + "tsequenceset_make_free", + "temporal_set_tstzspan", + "tinstant_set_tstzspan", + "tnumber_span", + "tsequence_set_tstzspan", + "tsequenceset_set_tstzspan", + "temporal_end_value", + "temporal_insts", + "temporal_max_value", + "temporal_mem_size", + "temporal_min_value", + "temporal_seqs", + "temporal_set_bbox", + "temporal_set_tstzspan", + "temporal_seqs", + "temporal_vals", + "temporal_values", + "tinstant_hash", + "tinstant_insts", + "tinstant_set_bbox", + "tinstant_set_tstzspan", + "tinstant_time", + "tinstant_timestamps", + "tinstant_val", + "tinstant_value", + "tinstant_value_at_timestamptz", + "tinstant_vals", + "tnumber_set_span", + "tnumberinst_valuespans", + "tnumberseq_valuespans", + "tnumberseqset_valuespans", + "tsequence_duration", + "tsequence_end_timestamptz", + "tsequence_hash", + "tsequence_insts", + "tsequence_max_inst", + "tsequence_max_val", + "tsequence_min_inst", + "tsequence_min_val", + "tsequence_segments", + "tsequence_seqs", + "tsequence_set_bbox", + "tsequence_expand_bbox", + "tsequence_start_timestamptz", + "tsequence_time", + "tsequence_timestamps", + "tsequence_value_at_timestamptz", + "tsequence_vals", + "tsequenceset_duration", + "tsequenceset_end_timestamptz", + "tsequenceset_hash", + "tsequenceset_inst_n", + "tsequenceset_insts", + "tsequenceset_max_inst", + "tsequenceset_max_val", + "tsequenceset_min_inst", + "tsequenceset_min_val", + "tsequenceset_num_instants", + "tsequenceset_num_timestamps", + "tsequenceset_segments", + "tsequenceset_seqs", + "tsequenceset_set_bbox", + "tsequenceset_start_timestamptz", + "tsequenceset_time", + "tsequenceset_timespan", + "tsequenceset_timestamptz_n", + "tsequenceset_timestamps", + "tsequenceset_value_at_timestamptz", + "tsequenceset_vals", + "temporal_compact", + "temporal_restart", + "temporal_tsequence", + "temporal_tsequenceset", + "tinstant_shift_time", + "tinstant_to_tsequence", + "tinstant_to_tsequenceset", + "tnumber_shift_scale_value", + "tnumberinst_shift_value", + "tnumberseq_shift_scale_value", + "tnumberseqset_shift_scale_value", + "tsequence_compact", + "tsequence_restart", + "tsequence_set_interp", + "tsequence_shift_scale_time", + "tsequence_subseq", + "tsequence_to_tinstant", + "tsequence_to_tsequenceset", + "tsequence_to_tsequenceset_interp", + "tsequenceset_compact", + "tsequenceset_restart", + "tsequenceset_set_interp", + "tsequenceset_shift_scale_time", + "tsequenceset_to_discrete", + "tsequenceset_to_linear", + "tsequenceset_to_step", + "tsequenceset_to_tinstant", + "tsequenceset_to_tsequence", + "tinstant_merge", + "tinstant_merge_array", + "tsequence_append_tinstant", + "tsequence_append_tsequence", + "tsequence_delete_timestamptz", + "tsequence_delete_tstzset", + "tsequence_delete_tstzspan", + "tsequence_delete_tstzspanset", + "tsequence_insert", + "tsequence_merge", + "tsequence_merge_array", + "tsequenceset_append_tinstant", + "tsequenceset_append_tsequence", + "tsequenceset_delete_timestamptz", + "tsequenceset_delete_tstzset", + "tsequenceset_delete_tstzspan", + "tsequenceset_delete_tstzspanset", + "tsequenceset_insert", + "tsequenceset_merge", + "tsequenceset_merge_array", + "tsequence_expand_bbox", + "tsequence_set_bbox", + "tsequenceset_expand_bbox", + "tsequenceset_set_bbox", + "tdiscseq_restrict_minmax", + "tcontseq_restrict_minmax", + "temporal_bbox_restrict_set", + "temporal_restrict_minmax", + "temporal_restrict_timestamptz", + "temporal_restrict_tstzset", + "temporal_restrict_tstzspan", + "temporal_restrict_tstzspanset", + "temporal_restrict_value", + "temporal_restrict_values", + "temporal_value_at_timestamptz", + "tinstant_restrict_tstzspan", + "tinstant_restrict_tstzspanset", + "tinstant_restrict_timestamptz", + "tinstant_restrict_tstzset", + "tinstant_restrict_value", + "tinstant_restrict_values", + "tnumber_restrict_span", + "tnumber_restrict_spanset", + "tnumberinst_restrict_span", + "tnumberinst_restrict_spanset", + "tnumberseqset_restrict_span", + "tnumberseqset_restrict_spanset", + "tpoint_restrict_geom_time", + "tpoint_restrict_stbox", + "tpointinst_restrict_geom_time", + "tpointinst_restrict_stbox", + "tpointseq_restrict_geom_time", + "tpointseq_restrict_stbox", + "tpointseqset_restrict_geom_time", + "tpointseqset_restrict_stbox", + "tsequence_at_timestamptz", + "tsequence_restrict_tstzspan", + "tsequence_restrict_tstzspanset", + "tsequenceset_restrict_minmax", + "tsequenceset_restrict_tstzspan", + "tsequenceset_restrict_tstzspanset", + "tsequenceset_restrict_timestamptz", + "tsequenceset_restrict_tstzset", + "tsequenceset_restrict_value", + "tsequenceset_restrict_values", + "tinstant_cmp", + "tinstant_eq", + "tsequence_cmp", + "tsequence_eq", + "tsequenceset_cmp", + "tsequenceset_eq", + "always_eq_base_temporal", + "always_eq_temporal_base", + "always_eq_tinstant_base", + "always_eq_tpointinst_base", + "always_eq_tpointseq_base", + "always_eq_tpointseqset_base", + "always_eq_tsequence_base", + "always_eq_tsequenceset_base", + "always_ne_base_temporal", + "always_ne_temporal_base", + "always_ne_tinstant_base", + "always_ne_tpointinst_base", + "always_ne_tpointseq_base", + "always_ne_tpointseqset_base", + "always_ne_tsequence_base", + "always_ne_tsequenceset_base", + "always_ge_base_temporal", + "always_ge_temporal_base", + "always_ge_tinstant_base", + "always_ge_tsequence_base", + "always_ge_tsequenceset_base", + "always_gt_base_temporal", + "always_gt_temporal_base", + "always_gt_tinstant_base", + "always_gt_tsequence_base", + "always_gt_tsequenceset_base", + "always_le_base_temporal", + "always_le_temporal_base", + "always_le_tinstant_base", + "always_le_tsequence_base", + "always_le_tsequenceset_base", + "always_lt_base_temporal", + "always_lt_temporal_base", + "always_lt_tinstant_base", + "always_lt_tsequence_base", + "always_lt_tsequenceset_base", + "ever_eq_base_temporal", + "ever_eq_temporal_base", + "ever_eq_tinstant_base", + "ever_eq_tpointinst_base", + "ever_eq_tpointseq_base", + "ever_eq_tpointseqset_base", + "ever_eq_tsequence_base", + "ever_eq_tsequenceset_base", + "ever_ne_base_temporal", + "ever_ne_temporal_base", + "ever_ne_tinstant_base", + "ever_ne_tpointinst_base", + "ever_ne_tpointseq_base", + "ever_ne_tpointseqset_base", + "ever_ne_tsequence_base", + "ever_ne_tsequenceset_base", + "ever_ge_base_temporal", + "ever_ge_temporal_base", + "ever_ge_tinstant_base", + "ever_ge_tsequence_base", + "ever_ge_tsequenceset_base", + "ever_gt_base_temporal", + "ever_gt_temporal_base", + "ever_gt_tinstant_base", + "ever_gt_tsequence_base", + "ever_gt_tsequenceset_base", + "ever_le_base_temporal", + "ever_le_temporal_base", + "ever_le_tinstant_base", + "ever_le_tsequence_base", + "ever_le_tsequenceset_base", + "ever_lt_base_temporal", + "ever_lt_temporal_base", + "tfloatseq_derivative", + "tfloatseqset_derivative", + "tnumberinst_abs", + "tnumberseq_abs", + "tnumberseq_angular_difference", + "tnumberseq_delta_value", + "tnumberseqset_abs", + "tnumberseqset_angular_difference", + "tnumberseqset_delta_value", + "distance_tnumber_number", + "nad_tnumber_number", + "tpointinst_srid", + "tpointseq_trajectory", + "tpointseq_azimuth", + "tpointseq_cumulative_length", + "tpointseq_is_simple", + "tpointseq_length", + "tpointseq_speed", + "tpointseq_srid", + "tpointseq_stboxes", + "tpointseqset_azimuth", + "tpointseqset_cumulative_length", + "tpointseqset_is_simple", + "tpointseqset_length", + "tpointseqset_speed", + "tpointseqset_srid", + "tpointseqset_stboxes", + "tpointseqset_trajectory", + "tpoint_get_coord", + "tgeompointinst_tgeogpointinst", + "tgeompointseq_tgeogpointseq", + "tgeompointseqset_tgeogpointseqset", + "tgeompoint_tgeogpoint", + "tpointinst_set_srid", + "tpointseq_make_simple", + "tpointseq_set_srid", + "tpointseqset_make_simple", + "tpointseqset_set_srid", + "tnumberseq_integral", + "tnumberseq_twavg", + "tnumberseqset_integral", + "tnumberseqset_twavg", + "tpointseq_twcentroid", + "tpointseqset_twcentroid", + "temporal_compact", + "tsequence_compact", + "tsequenceset_compact", + "skiplist_free", + "temporal_app_tinst_transfn", + "temporal_app_tseq_transfn", + "tnumberseq_integral", + "tnumberseq_twavg", + "tnumberseqset_integral", + "tnumberseqset_twavg", + "tpointseq_twcentroid", + "tpointseqset_twcentroid", + "tnumber_value_split", + "tbox_tile", ] diff --git a/pymeos_cffi/pymeos_cffi/builder/build_pymeos_functions.py b/pymeos_cffi/pymeos_cffi/builder/build_pymeos_functions.py index 3a74b4c7..f5d49114 100644 --- a/pymeos_cffi/pymeos_cffi/builder/build_pymeos_functions.py +++ b/pymeos_cffi/pymeos_cffi/builder/build_pymeos_functions.py @@ -69,7 +69,7 @@ def __init__(self, ctype: str, ptype: str, conversion: Optional[str]) -> None: "meos_finalize": remove_error_check_modifier, "cstring2text": cstring2text_modifier, "text2cstring": text2cstring_modifier, - "gserialized_from_lwgeom": gserialized_from_lwgeom_modifier, + "geo_from_lwgeom": geo_from_lwgeom_modifier, "spanset_make": spanset_make_modifier, "temporal_from_wkb": from_wkb_modifier("temporal_from_wkb", "Temporal"), "set_from_wkb": from_wkb_modifier("set_from_wkb", "Set"), @@ -135,7 +135,7 @@ def __init__(self, ctype: str, ptype: str, conversion: Optional[str]) -> None: ("meos_set_intervalstyle", "extra"), ("temporal_append_tinstant", "maxt"), ("temporal_as_mfjson", "srs"), - ("gserialized_as_geojson", "srs"), + ("geo_as_geojson", "srs"), ("tstzspan_shift_scale", "shift"), ("tstzspan_shift_scale", "duration"), ("tstzset_shift_scale", "shift"), diff --git a/pymeos_cffi/pymeos_cffi/builder/build_pymeos_functions_modifiers.py b/pymeos_cffi/pymeos_cffi/builder/build_pymeos_functions_modifiers.py index d89480bc..2a7d3763 100644 --- a/pymeos_cffi/pymeos_cffi/builder/build_pymeos_functions_modifiers.py +++ b/pymeos_cffi/pymeos_cffi/builder/build_pymeos_functions_modifiers.py @@ -103,7 +103,7 @@ def spanset_make_modifier(function: str) -> str: ) -def gserialized_from_lwgeom_modifier(function: str) -> str: +def geo_from_lwgeom_modifier(function: str) -> str: return function.replace(", size: 'size_t *'", "").replace( "_ffi.cast('size_t *', size)", "_ffi.NULL" ) diff --git a/pymeos_cffi/pymeos_cffi/builder/meos.h b/pymeos_cffi/pymeos_cffi/builder/meos.h index 27333be2..a28ef2d4 100644 --- a/pymeos_cffi/pymeos_cffi/builder/meos.h +++ b/pymeos_cffi/pymeos_cffi/builder/meos.h @@ -334,7 +334,7 @@ LWTIN; extern LWPOINT *lwpoint_make(int32_t srid, int hasz, int hasm, const POINT4D *p); extern LWGEOM *lwgeom_from_gserialized(const GSERIALIZED *g); -extern GSERIALIZED *gserialized_from_lwgeom(LWGEOM *geom, size_t *size); +/* extern GSERIALIZED *geo_from_lwgeom(LWGEOM *geom, size_t *size); (undefined) */ extern int32_t lwgeom_get_srid(const LWGEOM *geom); @@ -552,54 +552,51 @@ extern char *meos_get_intervalstyle(void); extern void meos_initialize(const char *tz_str, error_handler_fn err_handler); extern void meos_finalize(void); -extern bool bool_in(const char *in_str); +extern DateADT add_date_int(DateADT d, int32 days); +extern Interval *add_interval_interval(const Interval *interv1, const Interval *interv2); +extern TimestampTz add_timestamptz_interval(TimestampTz t, const Interval *interv); +extern bool bool_in(const char *str); extern char *bool_out(bool b); -extern text *cstring2text(const char *cstring); +extern text *cstring2text(const char *str); +extern TimestampTz date_to_timestamptz(DateADT d); +extern Interval *minus_date_date(DateADT d1, DateADT d2); +extern DateADT minus_date_int(DateADT d, int32 days); +extern TimestampTz minus_timestamptz_interval(TimestampTz t, const Interval *interv); +extern Interval *minus_timestamptz_timestamptz(TimestampTz t1, TimestampTz t2); +extern Interval *mult_interval_double(const Interval *interv, double factor); extern DateADT pg_date_in(const char *str); extern char *pg_date_out(DateADT d); -extern Interval *pg_date_mi(DateADT d1, DateADT d2); -extern DateADT pg_date_mi_int(DateADT d, int32 days); -extern DateADT pg_date_pl_int(DateADT d, int32 days); -extern TimestampTz pg_date_timestamptz(DateADT d); -extern int pg_interval_cmp(const Interval *interval1, const Interval *interval2); +extern int pg_interval_cmp(const Interval *interv1, const Interval *interv2); extern Interval *pg_interval_in(const char *str, int32 typmod); extern Interval *pg_interval_make(int32 years, int32 months, int32 weeks, int32 days, int32 hours, int32 mins, double secs); -extern Interval *pg_interval_mul(const Interval *span, double factor); -extern char *pg_interval_out(const Interval *span); -extern text *pg_interval_to_char(Interval *it, text *fmt); -extern Interval *pg_interval_pl(const Interval *span1, const Interval *span2); +extern char *pg_interval_out(const Interval *interv); extern TimeADT pg_time_in(const char *str, int32 typmod); -extern char *pg_time_out(TimeADT time); +extern char *pg_time_out(TimeADT t); extern Timestamp pg_timestamp_in(const char *str, int32 typmod); -extern Interval *pg_timestamp_mi(TimestampTz dt1, TimestampTz dt2); -extern TimestampTz pg_timestamp_mi_interval(TimestampTz timestamp, const Interval *span); -extern char *pg_timestamp_out(Timestamp dt); -extern TimestampTz pg_timestamp_pl_interval(TimestampTz timestamp, const Interval *span); -extern text *pg_timestamp_to_char(Timestamp dt, text *fmt); +extern char *pg_timestamp_out(Timestamp t); extern TimestampTz pg_timestamptz_in(const char *str, int32 typmod); -extern DateADT pg_timestamptz_date(TimestampTz t); -extern char *pg_timestamptz_out(TimestampTz dt); -extern text *pg_timestamptz_to_char(TimestampTz dt, text *fmt); -extern DateADT pg_to_date(text *date_txt, text *fmt); -/* extern TimestampTz pg_to_timestamptz(text *date_txt, text *fmt); (undefined) */ -extern char *text2cstring(const text *textptr); +extern char *pg_timestamptz_out(TimestampTz t); +extern char *text2cstring(const text *txt); +extern int text_cmp(const text *txt1, const text *txt2); +extern text *text_copy(const text *txt); extern char *text_out(const text *txt); - +extern DateADT timestamptz_to_date(TimestampTz t); + +extern bytea *geo_as_ewkb(const GSERIALIZED *gs, char *endian); +extern char *geo_as_ewkt(const GSERIALIZED *gs, int precision); +extern char *geo_as_geojson(const GSERIALIZED *gs, int option, int precision, char *srs); +extern char *geo_as_hexewkb(const GSERIALIZED *gs, const char *endian); +extern char *geo_as_text(const GSERIALIZED *gs, int precision); +extern GSERIALIZED *geo_from_ewkb(const bytea *bytea_wkb, int32 srid); +extern GSERIALIZED *geo_from_geojson(const char *geojson); +extern char *geo_out(const GSERIALIZED *gs); +extern bool geo_same(const GSERIALIZED *gs1, const GSERIALIZED *gs2); extern GSERIALIZED *geography_from_hexewkb(const char *wkt); extern GSERIALIZED *geography_from_text(char *wkt, int srid); extern GSERIALIZED *geometry_from_hexewkb(const char *wkt); extern GSERIALIZED *geometry_from_text(char *wkt, int srid); -extern bytea *gserialized_as_ewkb(const GSERIALIZED *gs, char *type); -extern char *gserialized_as_ewkt(const GSERIALIZED *gs, int precision); -extern char *gserialized_as_geojson(const GSERIALIZED *gs, int option, int precision, char *srs); -extern char *gserialized_as_hexewkb(const GSERIALIZED *gs, const char *type); -extern char *gserialized_as_text(const GSERIALIZED *gs, int precision); -extern GSERIALIZED *gserialized_from_ewkb(const bytea *bytea_wkb, int32 srid); -extern GSERIALIZED *gserialized_from_geojson(const char *geojson); -extern char *gserialized_out(const GSERIALIZED *gs); -extern GSERIALIZED *pgis_geography_in(char *input, int32 geom_typmod); -extern GSERIALIZED *pgis_geometry_in(char *input, int32 geom_typmod); -extern bool pgis_gserialized_same(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern GSERIALIZED *pgis_geography_in(char *str, int32 geog_typmod); +extern GSERIALIZED *pgis_geometry_in(char *str, int32 typmod); extern Set *bigintset_in(const char *str); extern char *bigintset_out(const Set *set); @@ -663,7 +660,7 @@ extern Span *intspan_make(int lower, int upper, bool lower_inc, bool upper_inc); extern Set *set_copy(const Set *s); extern Span *span_copy(const Span *s); extern SpanSet *spanset_copy(const SpanSet *ss); -extern SpanSet *spanset_make(Span *spans, int count, bool normalize); +extern SpanSet *spanset_make(Span *spans, int count, bool normalize, bool ordered); extern Set *textset_make(const text **values, int count); extern Set *tstzset_make(const TimestampTz *values, int count); extern Span *tstzspan_make(TimestampTz lower, TimestampTz upper, bool lower_inc, bool upper_inc); @@ -674,20 +671,31 @@ extern SpanSet *bigint_to_spanset(int i); extern Set *date_to_set(DateADT d); extern Span *date_to_span(DateADT d); extern SpanSet *date_to_spanset(DateADT d); -/* extern Span *date_to_tstzspan(DateADT d); (undefined) */ +extern Set *dateset_to_tstzset(const Set *s); +extern Span *datespan_to_tstzspan(const Span *s); +extern SpanSet *datespanset_to_tstzspanset(const SpanSet *ss); extern Set *float_to_set(double d); extern Span *float_to_span(double d); extern SpanSet *float_to_spanset(double d); +extern Set *floatset_to_intset(const Set *s); +extern Span *floatspan_to_intspan(const Span *s); +extern SpanSet *floatspanset_to_intspanset(const SpanSet *ss); extern Set *geo_to_set(GSERIALIZED *gs); extern Set *int_to_set(int i); extern Span *int_to_span(int i); extern SpanSet *int_to_spanset(int i); +extern Set *intset_to_floatset(const Set *s); +extern Span *intspan_to_floatspan(const Span *s); +extern SpanSet *intspanset_to_floatspanset(const SpanSet *ss); extern SpanSet *set_to_spanset(const Set *s); extern SpanSet *span_to_spanset(const Span *s); extern Set *text_to_set(text *txt); extern Set *timestamptz_to_set(TimestampTz t); extern Span *timestamptz_to_span(TimestampTz t); extern SpanSet *timestamptz_to_spanset(TimestampTz t); +extern Set *tstzset_to_dateset(const Set *s); +extern Span *tstzspan_to_datespan(const Span *s); +extern SpanSet *tstzspanset_to_datespanset(const SpanSet *ss); extern int64 bigintset_end_value(const Set *s); extern int64 bigintset_start_value(const Set *s); @@ -695,32 +703,35 @@ extern bool bigintset_value_n(const Set *s, int n, int64 *result); extern int64 *bigintset_values(const Set *s); extern int64 bigintspan_lower(const Span *s); extern int64 bigintspan_upper(const Span *s); +extern int64 bigintspan_width(const Span *s); extern int64 bigintspanset_lower(const SpanSet *ss); extern int64 bigintspanset_upper(const SpanSet *ss); +extern int64 bigintspanset_width(const SpanSet *ss, bool boundspan); extern DateADT dateset_end_value(const Set *s); extern DateADT dateset_start_value(const Set *s); -/* extern bool dateset_value_n(const Set *s, int n, DateADT *result); (undefined) */ +extern bool dateset_value_n(const Set *s, int n, DateADT *result); extern DateADT *dateset_values(const Set *s); extern Interval *datespan_duration(const Span *s); extern DateADT datespan_lower(const Span *s); extern DateADT datespan_upper(const Span *s); +extern bool datespanset_date_n(const SpanSet *ss, int n, DateADT *result); +extern DateADT *datespanset_dates(const SpanSet *ss, int *count); extern Interval *datespanset_duration(const SpanSet *ss, bool boundspan); extern DateADT datespanset_end_date(const SpanSet *ss); extern int datespanset_num_dates(const SpanSet *ss); extern DateADT datespanset_start_date(const SpanSet *ss); -extern bool datespanset_date_n(const SpanSet *ss, int n, DateADT *result); -extern DateADT *datespanset_dates(const SpanSet *ss, int *count); extern double floatset_end_value(const Set *s); extern double floatset_start_value(const Set *s); extern bool floatset_value_n(const Set *s, int n, double *result); extern double *floatset_values(const Set *s); extern double floatspan_lower(const Span *s); extern double floatspan_upper(const Span *s); +extern double floatspan_width(const Span *s); extern double floatspanset_lower(const SpanSet *ss); extern double floatspanset_upper(const SpanSet *ss); +extern double floatspanset_width(const SpanSet *ss, bool boundspan); extern GSERIALIZED *geoset_end_value(const Set *s); extern int geoset_srid(const Set *s); -extern Set *geoset_set_srid(const Set *s, int32 srid); extern GSERIALIZED *geoset_start_value(const Set *s); extern bool geoset_value_n(const Set *s, int n, GSERIALIZED **result); extern GSERIALIZED **geoset_values(const Set *s); @@ -730,8 +741,10 @@ extern bool intset_value_n(const Set *s, int n, int *result); extern int *intset_values(const Set *s); extern int intspan_lower(const Span *s); extern int intspan_upper(const Span *s); +extern int intspan_width(const Span *s); extern int intspanset_lower(const SpanSet *ss); extern int intspanset_upper(const SpanSet *ss); +extern int intspanset_width(const SpanSet *ss, bool boundspan); extern uint32 set_hash(const Set *s); extern uint64 set_hash_extended(const Set *s, uint64 seed); extern int set_num_values(const Set *s); @@ -740,19 +753,16 @@ extern uint32 span_hash(const Span *s); extern uint64 span_hash_extended(const Span *s, uint64 seed); extern bool span_lower_inc(const Span *s); extern bool span_upper_inc(const Span *s); -extern double span_width(const Span *s); -extern const Span *spanset_end_span(const SpanSet *ss); +extern Span *spanset_end_span(const SpanSet *ss); extern uint32 spanset_hash(const SpanSet *ss); extern uint64 spanset_hash_extended(const SpanSet *ss, uint64 seed); extern bool spanset_lower_inc(const SpanSet *ss); extern int spanset_num_spans(const SpanSet *ss); extern Span *spanset_span(const SpanSet *ss); -extern const Span *spanset_span_n(const SpanSet *ss, int i); -extern const Span **spanset_spans(const SpanSet *ss); -extern const Span *spanset_start_span(const SpanSet *ss); +extern Span *spanset_span_n(const SpanSet *ss, int i); +extern Span **spanset_spans(const SpanSet *ss); +extern Span *spanset_start_span(const SpanSet *ss); extern bool spanset_upper_inc(const SpanSet *ss); -extern double spanset_width(const SpanSet *ss, bool boundspan); -extern STBox *spatialset_to_stbox(const Set *s); extern text *textset_end_value(const Set *s); extern text *textset_start_value(const Set *s); extern bool textset_value_n(const Set *s, int n, text **result); @@ -777,129 +787,57 @@ extern Set *bigintset_shift_scale(const Set *s, int64 shift, int64 width, bool h extern Span *bigintspan_shift_scale(const Span *s, int64 shift, int64 width, bool hasshift, bool haswidth); extern SpanSet *bigintspanset_shift_scale(const SpanSet *ss, int64 shift, int64 width, bool hasshift, bool haswidth); extern Set *dateset_shift_scale(const Set *s, int shift, int width, bool hasshift, bool haswidth); -extern Set *dateset_to_tstzset(const Set *s); extern Span *datespan_shift_scale(const Span *s, int shift, int width, bool hasshift, bool haswidth); -extern Span *datespan_to_tstzspan(const Span *s); extern SpanSet *datespanset_shift_scale(const SpanSet *ss, int shift, int width, bool hasshift, bool haswidth); -extern SpanSet *datespanset_to_tstzspanset(const SpanSet *ss); extern Set *floatset_round(const Set *s, int maxdd); extern Set *floatset_shift_scale(const Set *s, double shift, double width, bool hasshift, bool haswidth); -extern Set *floatset_to_intset(const Set *s); extern Span *floatspan_round(const Span *s, int maxdd); extern Span *floatspan_shift_scale(const Span *s, double shift, double width, bool hasshift, bool haswidth); -extern Span *floatspan_to_intspan(const Span *s); -extern SpanSet *floatspanset_to_intspanset(const SpanSet *ss); extern SpanSet *floatspanset_round(const SpanSet *ss, int maxdd); extern SpanSet *floatspanset_shift_scale(const SpanSet *ss, double shift, double width, bool hasshift, bool haswidth); extern Set *geoset_round(const Set *s, int maxdd); +extern Set *geoset_set_srid(const Set *s, int32 srid); extern Set *intset_shift_scale(const Set *s, int shift, int width, bool hasshift, bool haswidth); -extern Set *intset_to_floatset(const Set *s); extern Span *intspan_shift_scale(const Span *s, int shift, int width, bool hasshift, bool haswidth); -extern Span *intspan_to_floatspan(const Span *s); -extern SpanSet *intspanset_to_floatspanset(const SpanSet *ss); extern SpanSet *intspanset_shift_scale(const SpanSet *ss, int shift, int width, bool hasshift, bool haswidth); extern Set *textset_lower(const Set *s); extern Set *textset_upper(const Set *s); extern TimestampTz timestamptz_tprecision(TimestampTz t, const Interval *duration, TimestampTz torigin); extern Set *tstzset_shift_scale(const Set *s, const Interval *shift, const Interval *duration); -/* extern Span *datespan_shift_scale(const Span *s, int shift, int width, bool hasshift, bool haswidth); (repeated) */ +extern Set *tstzset_tprecision(const Set *s, const Interval *duration, TimestampTz torigin); extern Span *tstzspan_shift_scale(const Span *s, const Interval *shift, const Interval *duration); extern Span *tstzspan_tprecision(const Span *s, const Interval *duration, TimestampTz torigin); -extern Set *tstzset_to_dateset(const Set *s); -extern Span *tstzspan_to_datespan(const Span *s); -extern SpanSet *tstzspanset_to_datespanset(const SpanSet *ss); extern SpanSet *tstzspanset_shift_scale(const SpanSet *ss, const Interval *shift, const Interval *duration); extern SpanSet *tstzspanset_tprecision(const SpanSet *ss, const Interval *duration, TimestampTz torigin); -extern Set *intersection_set_bigint(const Set *s, int64 i); -extern Set *intersection_set_date(const Set *s, DateADT d); -extern Set *intersection_set_float(const Set *s, double d); -extern Set *intersection_set_geo(const Set *s, const GSERIALIZED *gs); -extern Set *intersection_set_int(const Set *s, int i); -extern Set *intersection_set_set(const Set *s1, const Set *s2); -extern Set *intersection_set_text(const Set *s, const text *txt); -extern Set *intersection_set_timestamptz(const Set *s, TimestampTz t); -extern Span *intersection_span_bigint(const Span *s, int64 i); -extern Span *intersection_span_date(const Span *s, DateADT d); -extern Span *intersection_span_float(const Span *s, double d); -extern Span *intersection_span_int(const Span *s, int i); -extern Span *intersection_span_timestamptz(const Span *s, TimestampTz t); -extern Span *intersection_span_span(const Span *s1, const Span *s2); -extern SpanSet *intersection_spanset_bigint(const SpanSet *ss, int64 i); -extern SpanSet *intersection_spanset_date(const SpanSet *ss, DateADT d); -extern SpanSet *intersection_spanset_float(const SpanSet *ss, double d); -extern SpanSet *intersection_spanset_int(const SpanSet *ss, int i); -extern SpanSet *intersection_spanset_span(const SpanSet *ss, const Span *s); -extern SpanSet *intersection_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); -extern SpanSet *intersection_spanset_timestamptz(const SpanSet *ss, TimestampTz t); -extern Set *minus_bigint_set(int64 i, const Set *s); -extern SpanSet *minus_bigint_span(int64 i, const Span *s); -extern SpanSet *minus_bigint_spanset(int64 i, const SpanSet *ss); -extern Set *minus_date_set(DateADT d, const Set *s); -extern SpanSet *minus_date_span(DateADT d, const Span *s); -extern SpanSet *minus_date_spanset(DateADT d, const SpanSet *ss); -extern Set *minus_float_set(double d, const Set *s); -extern SpanSet *minus_float_span(double d, const Span *s); -extern SpanSet *minus_float_spanset(double d, const SpanSet *ss); -extern Set *minus_geo_set(const GSERIALIZED *gs, const Set *s); -extern Set *minus_int_set(int i, const Set *s); -extern SpanSet *minus_int_span(int i, const Span *s); -extern SpanSet *minus_int_spanset(int i, const SpanSet *ss); - -extern Set *minus_set_bigint(const Set *s, int64 i); -extern Set *minus_set_date(const Set *s, DateADT d); -extern Set *minus_set_float(const Set *s, double d); -extern Set *minus_set_geo(const Set *s, const GSERIALIZED *gs); -extern Set *minus_set_int(const Set *s, int i); -extern Set *minus_set_set(const Set *s1, const Set *s2); -extern Set *minus_set_text(const Set *s, const text *txt); -extern Set *minus_set_timestamptz(const Set *s, TimestampTz t); -extern SpanSet *minus_span_bigint(const Span *s, int64 i); -extern SpanSet *minus_span_date(const Span *s, DateADT d); -extern SpanSet *minus_span_float(const Span *s, double d); -extern SpanSet *minus_span_int(const Span *s, int i); -extern SpanSet *minus_span_span(const Span *s1, const Span *s2); -extern SpanSet *minus_span_spanset(const Span *s, const SpanSet *ss); -extern SpanSet *minus_span_timestamptz(const Span *s, TimestampTz t); -extern SpanSet *minus_spanset_bigint(const SpanSet *ss, int64 i); -extern SpanSet *minus_spanset_date(const SpanSet *ss, DateADT d); -extern SpanSet *minus_spanset_float(const SpanSet *ss, double d); -extern SpanSet *minus_spanset_int(const SpanSet *ss, int i); -extern SpanSet *minus_spanset_span(const SpanSet *ss, const Span *s); -extern SpanSet *minus_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); -extern SpanSet *minus_spanset_timestamptz(const SpanSet *ss, TimestampTz t); -extern Set *minus_text_set(const text *txt, const Set *s); -extern SpanSet *minus_timestamptz_span(TimestampTz t, const Span *s); -extern SpanSet *minus_timestamptz_spanset(TimestampTz t, const SpanSet *ss); -extern Set *minus_timestamptz_set(TimestampTz t, const Set *s); -extern Span *super_union_span_span(const Span *s1, const Span *s2); -extern Set *union_set_bigint(const Set *s, int64 i); -extern Set *union_set_date(const Set *s, DateADT d); -extern Set *union_set_float(const Set *s, double d); -extern Set *union_set_geo(const Set *s, const GSERIALIZED *gs); -extern Set *union_set_int(const Set *s, int i); -extern Set *union_set_set(const Set *s1, const Set *s2); -extern Set *union_set_text(const Set *s, const text *txt); -extern Set *union_set_timestamptz(const Set *s, const TimestampTz t); -extern SpanSet *union_span_bigint(const Span *s, int64 i); -extern SpanSet *union_span_date(const Span *s, DateADT d); -extern SpanSet *union_span_float(const Span *s, double d); -extern SpanSet *union_span_int(const Span *s, int i); -extern SpanSet *union_span_span(const Span *s1, const Span *s2); -extern SpanSet *union_span_timestamptz(const Span *s, TimestampTz t); -extern SpanSet *union_spanset_bigint(const SpanSet *ss, int64 i); -extern SpanSet *union_spanset_date(const SpanSet *ss, DateADT d); -extern SpanSet *union_spanset_float(const SpanSet *ss, double d); -extern SpanSet *union_spanset_int(const SpanSet *ss, int i); -extern SpanSet *union_spanset_span(const SpanSet *ss, const Span *s); -extern SpanSet *union_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); -extern SpanSet *union_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern int set_cmp(const Set *s1, const Set *s2); +extern bool set_eq(const Set *s1, const Set *s2); +extern bool set_ge(const Set *s1, const Set *s2); +extern bool set_gt(const Set *s1, const Set *s2); +extern bool set_le(const Set *s1, const Set *s2); +extern bool set_lt(const Set *s1, const Set *s2); +extern bool set_ne(const Set *s1, const Set *s2); +extern int span_cmp(const Span *s1, const Span *s2); +extern bool span_eq(const Span *s1, const Span *s2); +extern bool span_ge(const Span *s1, const Span *s2); +extern bool span_gt(const Span *s1, const Span *s2); +extern bool span_le(const Span *s1, const Span *s2); +extern bool span_lt(const Span *s1, const Span *s2); +extern bool span_ne(const Span *s1, const Span *s2); +extern int spanset_cmp(const SpanSet *ss1, const SpanSet *ss2); +extern bool spanset_eq(const SpanSet *ss1, const SpanSet *ss2); +extern bool spanset_ge(const SpanSet *ss1, const SpanSet *ss2); +extern bool spanset_gt(const SpanSet *ss1, const SpanSet *ss2); +extern bool spanset_le(const SpanSet *ss1, const SpanSet *ss2); +extern bool spanset_lt(const SpanSet *ss1, const SpanSet *ss2); +extern bool spanset_ne(const SpanSet *ss1, const SpanSet *ss2); extern bool adjacent_span_bigint(const Span *s, int64 i); extern bool adjacent_span_date(const Span *s, DateADT d); extern bool adjacent_span_float(const Span *s, double d); extern bool adjacent_span_int(const Span *s, int i); extern bool adjacent_span_span(const Span *s1, const Span *s2); +extern bool adjacent_span_spanset(const Span *s, const SpanSet *ss); extern bool adjacent_span_timestamptz(const Span *s, TimestampTz t); extern bool adjacent_spanset_bigint(const SpanSet *ss, int64 i); extern bool adjacent_spanset_date(const SpanSet *ss, DateADT d); @@ -939,21 +877,22 @@ extern bool contains_set_set(const Set *s1, const Set *s2); extern bool contains_set_text(const Set *s, text *t); extern bool contains_set_timestamptz(const Set *s, TimestampTz t); extern bool contains_span_bigint(const Span *s, int64 i); +extern bool contains_span_date(const Span *s, DateADT d); extern bool contains_span_float(const Span *s, double d); extern bool contains_span_int(const Span *s, int i); extern bool contains_span_span(const Span *s1, const Span *s2); extern bool contains_span_spanset(const Span *s, const SpanSet *ss); extern bool contains_span_timestamptz(const Span *s, TimestampTz t); -extern bool contains_span_date(const Span *s, DateADT d); extern bool contains_spanset_bigint(const SpanSet *ss, int64 i); +extern bool contains_spanset_date(const SpanSet *ss, DateADT d); extern bool contains_spanset_float(const SpanSet *ss, double d); extern bool contains_spanset_int(const SpanSet *ss, int i); extern bool contains_spanset_span(const SpanSet *ss, const Span *s); extern bool contains_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); extern bool contains_spanset_timestamptz(const SpanSet *ss, TimestampTz t); -extern bool contains_spanset_date(const SpanSet *ss, DateADT d); extern bool overlaps_set_set(const Set *s1, const Set *s2); extern bool overlaps_span_span(const Span *s1, const Span *s2); +extern bool overlaps_span_spanset(const Span *s, const SpanSet *ss); extern bool overlaps_spanset_span(const SpanSet *ss, const Span *s); extern bool overlaps_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); @@ -1006,21 +945,27 @@ extern bool left_spanset_int(const SpanSet *ss, int i); extern bool left_spanset_span(const SpanSet *ss, const Span *s); extern bool left_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); extern bool left_text_set(text *txt, const Set *s); +extern bool overafter_date_set(DateADT d, const Set *s); +extern bool overafter_date_span(DateADT d, const Span *s); +extern bool overafter_date_spanset(DateADT d, const SpanSet *ss); extern bool overafter_set_date(const Set *s, DateADT d); extern bool overafter_set_timestamptz(const Set *s, TimestampTz t); -extern bool overafter_span_timestamptz(const Span *s, TimestampTz t); extern bool overafter_span_date(const Span *s, DateADT d); -extern bool overafter_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern bool overafter_span_timestamptz(const Span *s, TimestampTz t); extern bool overafter_spanset_date(const SpanSet *ss, DateADT d); +extern bool overafter_spanset_timestamptz(const SpanSet *ss, TimestampTz t); extern bool overafter_timestamptz_set(TimestampTz t, const Set *s); extern bool overafter_timestamptz_span(TimestampTz t, const Span *s); extern bool overafter_timestamptz_spanset(TimestampTz t, const SpanSet *ss); +extern bool overbefore_date_set(DateADT d, const Set *s); +extern bool overbefore_date_span(DateADT d, const Span *s); +extern bool overbefore_date_spanset(DateADT d, const SpanSet *ss); extern bool overbefore_set_date(const Set *s, DateADT d); extern bool overbefore_set_timestamptz(const Set *s, TimestampTz t); -extern bool overbefore_span_timestamptz(const Span *s, TimestampTz t); extern bool overbefore_span_date(const Span *s, DateADT d); -extern bool overbefore_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern bool overbefore_span_timestamptz(const Span *s, TimestampTz t); extern bool overbefore_spanset_date(const SpanSet *ss, DateADT d); +extern bool overbefore_spanset_timestamptz(const SpanSet *ss, TimestampTz t); extern bool overbefore_timestamptz_set(TimestampTz t, const Set *s); extern bool overbefore_timestamptz_span(TimestampTz t, const Span *s); extern bool overbefore_timestamptz_spanset(TimestampTz t, const SpanSet *ss); @@ -1100,69 +1045,169 @@ extern bool right_spanset_span(const SpanSet *ss, const Span *s); extern bool right_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); extern bool right_text_set(text *txt, const Set *s); -extern double distance_set_bigint(const Set *s, int64 i); +extern Set *intersection_bigint_set(int64 i, const Set *s); +extern Set *intersection_date_set(const DateADT d, const Set *s); +extern Set *intersection_float_set(double d, const Set *s); +extern Set *intersection_geo_set(const GSERIALIZED *gs, const Set *s); +extern Set *intersection_int_set(int i, const Set *s); +extern Set *intersection_set_bigint(const Set *s, int64 i); +extern Set *intersection_set_date(const Set *s, DateADT d); +extern Set *intersection_set_float(const Set *s, double d); +extern Set *intersection_set_geo(const Set *s, const GSERIALIZED *gs); +extern Set *intersection_set_int(const Set *s, int i); +extern Set *intersection_set_set(const Set *s1, const Set *s2); +extern Set *intersection_set_text(const Set *s, const text *txt); +extern Set *intersection_set_timestamptz(const Set *s, TimestampTz t); +extern Span *intersection_span_bigint(const Span *s, int64 i); +extern Span *intersection_span_date(const Span *s, DateADT d); +extern Span *intersection_span_float(const Span *s, double d); +extern Span *intersection_span_int(const Span *s, int i); +extern Span *intersection_span_span(const Span *s1, const Span *s2); +extern SpanSet *intersection_span_spanset(const Span *s, const SpanSet *ss); +extern Span *intersection_span_timestamptz(const Span *s, TimestampTz t); +extern SpanSet *intersection_spanset_bigint(const SpanSet *ss, int64 i); +extern SpanSet *intersection_spanset_date(const SpanSet *ss, DateADT d); +extern SpanSet *intersection_spanset_float(const SpanSet *ss, double d); +extern SpanSet *intersection_spanset_int(const SpanSet *ss, int i); +extern SpanSet *intersection_spanset_span(const SpanSet *ss, const Span *s); +extern SpanSet *intersection_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern SpanSet *intersection_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern Set *intersection_text_set(const text *txt, const Set *s); +extern Set *intersection_timestamptz_set(const TimestampTz t, const Set *s); +extern Set *minus_bigint_set(int64 i, const Set *s); +extern SpanSet *minus_bigint_span(int64 i, const Span *s); +extern SpanSet *minus_bigint_spanset(int64 i, const SpanSet *ss); +extern Set *minus_date_set(DateADT d, const Set *s); +extern SpanSet *minus_date_span(DateADT d, const Span *s); +extern SpanSet *minus_date_spanset(DateADT d, const SpanSet *ss); +extern Set *minus_float_set(double d, const Set *s); +extern SpanSet *minus_float_span(double d, const Span *s); +extern SpanSet *minus_float_spanset(double d, const SpanSet *ss); +extern Set *minus_geo_set(const GSERIALIZED *gs, const Set *s); +extern Set *minus_int_set(int i, const Set *s); +extern SpanSet *minus_int_span(int i, const Span *s); +extern SpanSet *minus_int_spanset(int i, const SpanSet *ss); +extern Set *minus_set_bigint(const Set *s, int64 i); +extern Set *minus_set_date(const Set *s, DateADT d); +extern Set *minus_set_float(const Set *s, double d); +extern Set *minus_set_geo(const Set *s, const GSERIALIZED *gs); +extern Set *minus_set_int(const Set *s, int i); +extern Set *minus_set_set(const Set *s1, const Set *s2); +extern Set *minus_set_text(const Set *s, const text *txt); +extern Set *minus_set_timestamptz(const Set *s, TimestampTz t); +extern SpanSet *minus_span_bigint(const Span *s, int64 i); +extern SpanSet *minus_span_date(const Span *s, DateADT d); +extern SpanSet *minus_span_float(const Span *s, double d); +extern SpanSet *minus_span_int(const Span *s, int i); +extern SpanSet *minus_span_span(const Span *s1, const Span *s2); +extern SpanSet *minus_span_spanset(const Span *s, const SpanSet *ss); +extern SpanSet *minus_span_timestamptz(const Span *s, TimestampTz t); +extern SpanSet *minus_spanset_bigint(const SpanSet *ss, int64 i); +extern SpanSet *minus_spanset_date(const SpanSet *ss, DateADT d); +extern SpanSet *minus_spanset_float(const SpanSet *ss, double d); +extern SpanSet *minus_spanset_int(const SpanSet *ss, int i); +extern SpanSet *minus_spanset_span(const SpanSet *ss, const Span *s); +extern SpanSet *minus_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern SpanSet *minus_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern Set *minus_text_set(const text *txt, const Set *s); +extern Set *minus_timestamptz_set(TimestampTz t, const Set *s); +extern SpanSet *minus_timestamptz_span(TimestampTz t, const Span *s); +extern SpanSet *minus_timestamptz_spanset(TimestampTz t, const SpanSet *ss); +extern Set *union_bigint_set(int64 i, const Set *s); +extern SpanSet *union_bigint_span(const Span *s, int64 i); +extern SpanSet *union_bigint_spanset(int64 i, SpanSet *ss); +extern Set *union_date_set(const DateADT d, const Set *s); +extern SpanSet *union_date_span(const Span *s, DateADT d); +extern SpanSet *union_date_spanset(DateADT d, SpanSet *ss); +extern Set *union_float_set(double d, const Set *s); +extern SpanSet *union_float_span(const Span *s, double d); +extern SpanSet *union_float_spanset(double d, SpanSet *ss); +extern Set *union_geo_set(const GSERIALIZED *gs, const Set *s); +extern Set *union_int_set(int i, const Set *s); +extern SpanSet *union_int_span(int i, const Span *s); +extern SpanSet *union_int_spanset(int i, SpanSet *ss); +extern Set *union_set_bigint(const Set *s, int64 i); +extern Set *union_set_date(const Set *s, DateADT d); +extern Set *union_set_float(const Set *s, double d); +extern Set *union_set_geo(const Set *s, const GSERIALIZED *gs); +extern Set *union_set_int(const Set *s, int i); +extern Set *union_set_set(const Set *s1, const Set *s2); +extern Set *union_set_text(const Set *s, const text *txt); +extern Set *union_set_timestamptz(const Set *s, const TimestampTz t); +extern SpanSet *union_span_bigint(const Span *s, int64 i); +extern SpanSet *union_span_date(const Span *s, DateADT d); +extern SpanSet *union_span_float(const Span *s, double d); +extern SpanSet *union_span_int(const Span *s, int i); +extern SpanSet *union_span_span(const Span *s1, const Span *s2); +extern SpanSet *union_span_spanset(const Span *s, const SpanSet *ss); +extern SpanSet *union_span_timestamptz(const Span *s, TimestampTz t); +extern SpanSet *union_spanset_bigint(const SpanSet *ss, int64 i); +extern SpanSet *union_spanset_date(const SpanSet *ss, DateADT d); +extern SpanSet *union_spanset_float(const SpanSet *ss, double d); +extern SpanSet *union_spanset_int(const SpanSet *ss, int i); +extern SpanSet *union_spanset_span(const SpanSet *ss, const Span *s); +extern SpanSet *union_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern SpanSet *union_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern Set *union_text_set(const text *txt, const Set *s); +extern Set *union_timestamptz_set(const TimestampTz t, const Set *s); +extern SpanSet *union_timestamptz_span(TimestampTz t, const Span *s); +extern SpanSet *union_timestamptz_spanset(TimestampTz t, SpanSet *ss); + +extern int64 distance_bigintset_bigintset(const Set *s1, const Set *s2); +extern int64 distance_bigintspan_bigintspan(const Span *s1, const Span *s2); +extern int64 distance_bigintspanset_bigintspan(const SpanSet *ss, const Span *s); +extern int64 distance_bigintspanset_bigintspanset(const SpanSet *ss1, const SpanSet *ss2); +extern int distance_dateset_dateset(const Set *s1, const Set *s2); +extern int distance_datespan_datespan(const Span *s1, const Span *s2); +extern int distance_datespanset_datespan(const SpanSet *ss, const Span *s); +extern int distance_datespanset_datespanset(const SpanSet *ss1, const SpanSet *ss2); +extern double distance_floatset_floatset(const Set *s1, const Set *s2); +extern double distance_floatspan_floatspan(const Span *s1, const Span *s2); +extern double distance_floatspanset_floatspan(const SpanSet *ss, const Span *s); +extern double distance_floatspanset_floatspanset(const SpanSet *ss1, const SpanSet *ss2); +extern int distance_intset_intset(const Set *s1, const Set *s2); +extern int distance_intspan_intspan(const Span *s1, const Span *s2); +extern int distance_intspanset_intspan(const SpanSet *ss, const Span *s); +extern int distance_intspanset_intspanset(const SpanSet *ss1, const SpanSet *ss2); +extern int64 distance_set_bigint(const Set *s, int64 i); +extern int distance_set_date(const Set *s, DateADT d); extern double distance_set_float(const Set *s, double d); -extern double distance_set_int(const Set *s, int i); -extern double distance_set_set(const Set *s1, const Set *s2); +extern int distance_set_int(const Set *s, int i); extern double distance_set_timestamptz(const Set *s, TimestampTz t); -extern double distance_set_date(const Set *s, DateADT d); -extern double distance_span_bigint(const Span *s, int64 i); +extern int64 distance_span_bigint(const Span *s, int64 i); +extern int distance_span_date(const Span *s, DateADT d); extern double distance_span_float(const Span *s, double d); -extern double distance_span_int(const Span *s, int i); -extern double distance_span_span(const Span *s1, const Span *s2); +extern int distance_span_int(const Span *s, int i); extern double distance_span_timestamptz(const Span *s, TimestampTz t); -extern double distance_span_date(const Span *s, DateADT d); -extern double distance_spanset_bigint(const SpanSet *ss, int64 i); +extern int64 distance_spanset_bigint(const SpanSet *ss, int64 i); +extern int distance_spanset_date(const SpanSet *ss, DateADT d); extern double distance_spanset_float(const SpanSet *ss, double d); -extern double distance_spanset_int(const SpanSet *ss, int i); +extern int distance_spanset_int(const SpanSet *ss, int i); extern double distance_spanset_timestamptz(const SpanSet *ss, TimestampTz t); -extern double distance_spanset_date(const SpanSet *ss, DateADT d); -extern double distance_spanset_span(const SpanSet *ss, const Span *s); -extern double distance_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); - -extern int set_cmp(const Set *s1, const Set *s2); -extern bool set_eq(const Set *s1, const Set *s2); -extern bool set_ge(const Set *s1, const Set *s2); -extern bool set_gt(const Set *s1, const Set *s2); -extern bool set_le(const Set *s1, const Set *s2); -extern bool set_lt(const Set *s1, const Set *s2); -extern bool set_ne(const Set *s1, const Set *s2); -extern int span_cmp(const Span *s1, const Span *s2); -extern bool span_eq(const Span *s1, const Span *s2); -extern bool span_ge(const Span *s1, const Span *s2); -extern bool span_gt(const Span *s1, const Span *s2); -extern bool span_le(const Span *s1, const Span *s2); -extern bool span_lt(const Span *s1, const Span *s2); -extern bool span_ne(const Span *s1, const Span *s2); -extern int spanset_cmp(const SpanSet *ss1, const SpanSet *ss2); -extern bool spanset_eq(const SpanSet *ss1, const SpanSet *ss2); -extern bool spanset_ge(const SpanSet *ss1, const SpanSet *ss2); -extern bool spanset_gt(const SpanSet *ss1, const SpanSet *ss2); -extern bool spanset_le(const SpanSet *ss1, const SpanSet *ss2); -extern bool spanset_lt(const SpanSet *ss1, const SpanSet *ss2); -extern bool spanset_ne(const SpanSet *ss1, const SpanSet *ss2); +extern double distance_tstzset_tstzset(const Set *s1, const Set *s2); +extern double distance_tstzspan_tstzspan(const Span *s1, const Span *s2); +extern double distance_tstzspanset_tstzspan(const SpanSet *ss, const Span *s); +extern double distance_tstzspanset_tstzspanset(const SpanSet *ss1, const SpanSet *ss2); -extern Span *bigint_extent_transfn(Span *s, int64 i); +extern Span *bigint_extent_transfn(Span *state, int64 i); extern Set *bigint_union_transfn(Set *state, int64 i); -extern Span *float_extent_transfn(Span *s, double d); +extern Span *date_extent_transfn(Span *state, DateADT d); +extern Set *date_union_transfn(Set *state, DateADT d); +extern Span *float_extent_transfn(Span *state, double d); extern Set *float_union_transfn(Set *state, double d); -extern Span *int_extent_transfn(Span *s, int i); -extern Set *int_union_transfn(Set *state, int i); -extern Span *set_extent_transfn(Span *span, const Set *set); +extern Span *int_extent_transfn(Span *state, int i); +extern Set *int_union_transfn(Set *state, int32 i); +extern Span *set_extent_transfn(Span *state, const Set *s); extern Set *set_union_finalfn(Set *state); -extern Set *set_union_transfn(Set *state, Set *set); -extern Span *span_extent_transfn(Span *s1, const Span *s2); -extern SpanSet *span_union_transfn(SpanSet *state, const Span *span); -extern Span *spanset_extent_transfn(Span *s, const SpanSet *ss); +extern Set *set_union_transfn(Set *state, Set *s); +extern Span *span_extent_transfn(Span *state, const Span *s); +extern SpanSet *span_union_transfn(SpanSet *state, const Span *s); +extern Span *spanset_extent_transfn(Span *state, const SpanSet *ss); extern SpanSet *spanset_union_finalfn(SpanSet *state); extern SpanSet *spanset_union_transfn(SpanSet *state, const SpanSet *ss); extern Set *text_union_transfn(Set *state, const text *txt); -extern Span *timestamptz_extent_transfn(Span *s, TimestampTz t); -extern SkipList *timestamptz_tcount_transfn(SkipList *state, TimestampTz t); +extern Span *timestamptz_extent_transfn(Span *state, TimestampTz t); extern Set *timestamptz_union_transfn(Set *state, TimestampTz t); -extern SkipList *tstzset_tcount_transfn(SkipList *state, const Set *s); -extern SkipList *tstzspan_tcount_transfn(SkipList *state, const Span *s); -extern SkipList *tstzspanset_tcount_transfn(SkipList *state, const SpanSet *ss); extern TBox *tbox_in(const char *str); extern char *tbox_out(const TBox *box, int maxdd); @@ -1190,29 +1235,26 @@ extern STBox *stbox_make(bool hasx, bool hasz, bool geodetic, int32 srid, double extern TBox *tbox_copy(const TBox *box); extern TBox *tbox_make(const Span *s, const Span *p); -extern STBox *box3d_to_stbox(const BOX3D *box); -extern STBox *gbox_to_stbox(const GBOX *box); extern TBox *float_to_tbox(double d); extern STBox *geo_to_stbox(const GSERIALIZED *gs); extern TBox *int_to_tbox(int i); -extern TBox *numset_to_tbox(const Set *s); -extern TBox *numspan_to_tbox(const Span *s); -extern TBox *numspanset_to_tbox(const SpanSet *ss); -extern STBox *tstzspan_to_stbox(const Span *s); -extern TBox *tstzspan_to_tbox(const Span *s); -extern STBox *tstzspanset_to_stbox(const SpanSet *ss); -extern TBox *tstzspanset_to_tbox(const SpanSet *ss); +extern TBox *set_to_tbox(const Set *s); +extern TBox *span_to_tbox(const Span *s); +extern TBox *spanset_to_tbox(const SpanSet *ss); +extern STBox *spatialset_to_stbox(const Set *s); extern GBOX *stbox_to_gbox(const STBox *box); extern BOX3D *stbox_to_box3d(const STBox *box); extern GSERIALIZED *stbox_to_geo(const STBox *box); extern Span *stbox_to_tstzspan(const STBox *box); +/* extern TBox *tstzspanset_to_tbox(const SpanSet *ss); (undefined) */ extern Span *tbox_to_intspan(const TBox *box); extern Span *tbox_to_floatspan(const TBox *box); extern Span *tbox_to_tstzspan(const TBox *box); extern STBox *timestamptz_to_stbox(TimestampTz t); extern TBox *timestamptz_to_tbox(TimestampTz t); extern STBox *tstzset_to_stbox(const Set *s); -extern TBox *tstzset_to_tbox(const Set *ss); +extern STBox *tstzspan_to_stbox(const Span *s); +extern STBox *tstzspanset_to_stbox(const SpanSet *ss); extern TBox *tnumber_to_tbox(const Temporal *temp); extern STBox *tpoint_to_stbox(const Temporal *temp); @@ -1247,12 +1289,13 @@ extern bool tboxint_xmax(const TBox *box, int *result); extern bool tboxint_xmin(const TBox *box, int *result); extern STBox *stbox_expand_space(const STBox *box, double d); -extern STBox *stbox_expand_time(const STBox *box, const Interval *interval); +extern STBox *stbox_expand_time(const STBox *box, const Interval *interv); extern STBox *stbox_get_space(const STBox *box); +extern STBox *stbox_quad_split(const STBox *box, int *count); extern STBox *stbox_round(const STBox *box, int maxdd); extern STBox *stbox_set_srid(const STBox *box, int32 srid); extern STBox *stbox_shift_scale_time(const STBox *box, const Interval *shift, const Interval *duration); -extern TBox *tbox_expand_time(const TBox *box, const Interval *interval); +extern TBox *tbox_expand_time(const TBox *box, const Interval *interv); extern TBox *tbox_expand_float(const TBox *box, const double d); extern TBox *tbox_expand_int(const TBox *box, const int i); extern TBox *tbox_round(const TBox *box, int maxdd); @@ -1261,22 +1304,20 @@ extern TBox *tbox_shift_scale_int(const TBox *box, int shift, int width, bool ha extern TBox *tbox_shift_scale_time(const TBox *box, const Interval *shift, const Interval *duration); extern TBox *union_tbox_tbox(const TBox *box1, const TBox *box2, bool strict); -extern bool inter_tbox_tbox(const TBox *box1, const TBox *box2, TBox *result); extern TBox *intersection_tbox_tbox(const TBox *box1, const TBox *box2); extern STBox *union_stbox_stbox(const STBox *box1, const STBox *box2, bool strict); -extern bool inter_stbox_stbox(const STBox *box1, const STBox *box2, STBox *result); extern STBox *intersection_stbox_stbox(const STBox *box1, const STBox *box2); -extern bool contains_tbox_tbox(const TBox *box1, const TBox *box2); -extern bool contained_tbox_tbox(const TBox *box1, const TBox *box2); -extern bool overlaps_tbox_tbox(const TBox *box1, const TBox *box2); -extern bool same_tbox_tbox(const TBox *box1, const TBox *box2); +extern bool adjacent_stbox_stbox(const STBox *box1, const STBox *box2); extern bool adjacent_tbox_tbox(const TBox *box1, const TBox *box2); -extern bool contains_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool contained_tbox_tbox(const TBox *box1, const TBox *box2); extern bool contained_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool contains_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool contains_tbox_tbox(const TBox *box1, const TBox *box2); +extern bool overlaps_tbox_tbox(const TBox *box1, const TBox *box2); extern bool overlaps_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool same_tbox_tbox(const TBox *box1, const TBox *box2); extern bool same_stbox_stbox(const STBox *box1, const STBox *box2); -extern bool adjacent_stbox_stbox(const STBox *box1, const STBox *box2); extern bool left_tbox_tbox(const TBox *box1, const TBox *box2); extern bool overleft_tbox_tbox(const TBox *box1, const TBox *box2); @@ -1303,8 +1344,6 @@ extern bool overbefore_stbox_stbox(const STBox *box1, const STBox *box2); extern bool after_stbox_stbox(const STBox *box1, const STBox *box2); extern bool overafter_stbox_stbox(const STBox *box1, const STBox *box2); -extern STBox *stbox_quad_split(const STBox *box, int *count); - extern bool tbox_eq(const TBox *box1, const TBox *box2); extern bool tbox_ne(const TBox *box1, const TBox *box2); extern int tbox_cmp(const TBox *box1, const TBox *box2); @@ -1340,7 +1379,6 @@ extern char *tpoint_out(const Temporal *temp, int maxdd); extern Temporal *ttext_in(const char *str); extern char *ttext_out(const Temporal *temp); -extern Temporal *temporal_cp(const Temporal *temp); extern Temporal *tbool_from_base_temp(bool b, const Temporal *temp); extern TInstant *tboolinst_make(bool b, TimestampTz t); extern TSequence *tboolseq_from_base_tstzset(bool b, const Set *s); @@ -1378,28 +1416,31 @@ extern Span *tnumber_to_span(const Temporal *temp); extern bool tbool_end_value(const Temporal *temp); extern bool tbool_start_value(const Temporal *temp); +extern bool tbool_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, bool *value); extern bool *tbool_values(const Temporal *temp, int *count); extern Interval *temporal_duration(const Temporal *temp, bool boundspan); -extern const TInstant *temporal_end_instant(const Temporal *temp); +extern TInstant *temporal_end_instant(const Temporal *temp); extern TSequence *temporal_end_sequence(const Temporal *temp); extern TimestampTz temporal_end_timestamptz(const Temporal *temp); extern uint32 temporal_hash(const Temporal *temp); -extern const TInstant *temporal_instant_n(const Temporal *temp, int n); -extern const TInstant **temporal_instants(const Temporal *temp, int *count); -extern char *temporal_interp(const Temporal *temp); -extern const TInstant *temporal_max_instant(const Temporal *temp); -extern const TInstant *temporal_min_instant(const Temporal *temp); +extern TInstant *temporal_instant_n(const Temporal *temp, int n); +extern TInstant **temporal_instants(const Temporal *temp, int *count); +extern const char *temporal_interp(const Temporal *temp); +extern TInstant *temporal_max_instant(const Temporal *temp); +extern TInstant *temporal_min_instant(const Temporal *temp); extern int temporal_num_instants(const Temporal *temp); extern int temporal_num_sequences(const Temporal *temp); extern int temporal_num_timestamps(const Temporal *temp); extern TSequence **temporal_segments(const Temporal *temp, int *count); extern TSequence *temporal_sequence_n(const Temporal *temp, int i); extern TSequence **temporal_sequences(const Temporal *temp, int *count); -extern const TInstant *temporal_start_instant(const Temporal *temp); +extern int temporal_lower_inc(const Temporal *temp); +extern int temporal_upper_inc(const Temporal *temp); +extern TInstant *temporal_start_instant(const Temporal *temp); extern TSequence *temporal_start_sequence(const Temporal *temp); extern TimestampTz temporal_start_timestamptz(const Temporal *temp); extern TSequenceSet *temporal_stops(const Temporal *temp, double maxdist, const Interval *minduration); -extern char *temporal_subtype(const Temporal *temp); +extern const char *temporal_subtype(const Temporal *temp); extern SpanSet *temporal_time(const Temporal *temp); extern bool temporal_timestamptz_n(const Temporal *temp, int n, TimestampTz *result); extern TimestampTz *temporal_timestamps(const Temporal *temp, int *count); @@ -1407,35 +1448,48 @@ extern double tfloat_end_value(const Temporal *temp); extern double tfloat_max_value(const Temporal *temp); extern double tfloat_min_value(const Temporal *temp); extern double tfloat_start_value(const Temporal *temp); +extern bool tfloat_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, double *value); extern double *tfloat_values(const Temporal *temp, int *count); extern int tint_end_value(const Temporal *temp); extern int tint_max_value(const Temporal *temp); extern int tint_min_value(const Temporal *temp); extern int tint_start_value(const Temporal *temp); +extern bool tint_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, int *value); extern int *tint_values(const Temporal *temp, int *count); +extern double tnumber_integral(const Temporal *temp); +extern double tnumber_twavg(const Temporal *temp); extern SpanSet *tnumber_valuespans(const Temporal *temp); extern GSERIALIZED *tpoint_end_value(const Temporal *temp); extern GSERIALIZED *tpoint_start_value(const Temporal *temp); +extern bool tpoint_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, GSERIALIZED **value); extern GSERIALIZED **tpoint_values(const Temporal *temp, int *count); extern text *ttext_end_value(const Temporal *temp); extern text *ttext_max_value(const Temporal *temp); extern text *ttext_min_value(const Temporal *temp); extern text *ttext_start_value(const Temporal *temp); +extern bool ttext_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, text **value); extern text **ttext_values(const Temporal *temp, int *count); +extern double float_degrees(double value, bool normalize); extern Temporal *temporal_scale_time(const Temporal *temp, const Interval *duration); extern Temporal *temporal_set_interp(const Temporal *temp, interpType interp); extern Temporal *temporal_shift_scale_time(const Temporal *temp, const Interval *shift, const Interval *duration); extern Temporal *temporal_shift_time(const Temporal *temp, const Interval *shift); extern TInstant *temporal_to_tinstant(const Temporal *temp); -extern TSequence *temporal_to_tsequence(const Temporal *temp, interpType interp); -extern TSequenceSet *temporal_to_tsequenceset(const Temporal *temp, interpType interp); +extern TSequence *temporal_to_tsequence(const Temporal *temp, char *interp_str); +extern TSequenceSet *temporal_to_tsequenceset(const Temporal *temp, char *interp_str); +extern Temporal *tfloat_degrees(const Temporal *temp, bool normalize); +extern Temporal *tfloat_radians(const Temporal *temp); +extern Temporal *tfloat_round(const Temporal *temp, int maxdd); extern Temporal *tfloat_scale_value(const Temporal *temp, double width); extern Temporal *tfloat_shift_scale_value(const Temporal *temp, double shift, double width); extern Temporal *tfloat_shift_value(const Temporal *temp, double shift); +extern Temporal **tfloatarr_round(const Temporal **temp, int count, int maxdd); extern Temporal *tint_scale_value(const Temporal *temp, int width); extern Temporal *tint_shift_scale_value(const Temporal *temp, int shift, int width); extern Temporal *tint_shift_value(const Temporal *temp, int shift); +extern Temporal *tpoint_round(const Temporal *temp, int maxdd); +extern Temporal **tpointarr_round(const Temporal **temp, int count, int maxdd); extern Temporal *temporal_append_tinstant(Temporal *temp, const TInstant *inst, double maxdist, Interval *maxt, bool expand); extern Temporal *temporal_append_tsequence(Temporal *temp, const TSequence *seq, bool expand); @@ -1450,7 +1504,6 @@ extern Temporal *temporal_update(const Temporal *temp1, const Temporal *temp2, b extern Temporal *tbool_at_value(const Temporal *temp, bool b); extern Temporal *tbool_minus_value(const Temporal *temp, bool b); -extern bool tbool_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, bool *value); extern Temporal *temporal_at_max(const Temporal *temp); extern Temporal *temporal_at_min(const Temporal *temp); extern Temporal *temporal_at_tstzspan(const Temporal *temp, const Span *s); @@ -1467,10 +1520,8 @@ extern Temporal *temporal_minus_tstzset(const Temporal *temp, const Set *s); extern Temporal *temporal_minus_values(const Temporal *temp, const Set *set); extern Temporal *tfloat_at_value(const Temporal *temp, double d); extern Temporal *tfloat_minus_value(const Temporal *temp, double d); -extern bool tfloat_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, double *value); extern Temporal *tint_at_value(const Temporal *temp, int i); extern Temporal *tint_minus_value(const Temporal *temp, int i); -extern bool tint_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, int *value); extern Temporal *tnumber_at_span(const Temporal *temp, const Span *span); extern Temporal *tnumber_at_spanset(const Temporal *temp, const SpanSet *ss); extern Temporal *tnumber_at_tbox(const Temporal *temp, const TBox *box); @@ -1483,10 +1534,8 @@ extern Temporal *tpoint_at_value(const Temporal *temp, GSERIALIZED *gs); extern Temporal *tpoint_minus_geom_time(const Temporal *temp, const GSERIALIZED *gs, const Span *zspan, const Span *period); extern Temporal *tpoint_minus_stbox(const Temporal *temp, const STBox *box, bool border_inc); extern Temporal *tpoint_minus_value(const Temporal *temp, GSERIALIZED *gs); -extern bool tpoint_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, GSERIALIZED **value); extern Temporal *ttext_at_value(const Temporal *temp, text *txt); extern Temporal *ttext_minus_value(const Temporal *temp, text *txt); -extern bool ttext_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, text **value); extern int temporal_cmp(const Temporal *temp1, const Temporal *temp2); extern bool temporal_eq(const Temporal *temp1, const Temporal *temp2); @@ -1496,77 +1545,161 @@ extern bool temporal_le(const Temporal *temp1, const Temporal *temp2); extern bool temporal_lt(const Temporal *temp1, const Temporal *temp2); extern bool temporal_ne(const Temporal *temp1, const Temporal *temp2); -extern bool tbool_always_eq(const Temporal *temp, bool b); -extern bool tbool_ever_eq(const Temporal *temp, bool b); -extern bool tfloat_always_eq(const Temporal *temp, double d); -extern bool tfloat_always_le(const Temporal *temp, double d); -extern bool tfloat_always_lt(const Temporal *temp, double d); -extern bool tfloat_ever_eq(const Temporal *temp, double d); -extern bool tfloat_ever_le(const Temporal *temp, double d); -extern bool tfloat_ever_lt(const Temporal *temp, double d); -extern bool tint_always_eq(const Temporal *temp, int i); -extern bool tint_always_le(const Temporal *temp, int i); -extern bool tint_always_lt(const Temporal *temp, int i); -extern bool tint_ever_eq(const Temporal *temp, int i); -extern bool tint_ever_le(const Temporal *temp, int i); -extern bool tint_ever_lt(const Temporal *temp, int i); -extern bool tpoint_always_eq(const Temporal *temp, const GSERIALIZED *gs);; -extern bool tpoint_ever_eq(const Temporal *temp, const GSERIALIZED *gs);; -extern bool ttext_always_eq(const Temporal *temp, text *txt); -extern bool ttext_always_le(const Temporal *temp, text *txt); -extern bool ttext_always_lt(const Temporal *temp, text *txt); -extern bool ttext_ever_eq(const Temporal *temp, text *txt); -extern bool ttext_ever_le(const Temporal *temp, text *txt); -extern bool ttext_ever_lt(const Temporal *temp, text *txt); - -/* extern Temporal *teq_bool_tbool(bool b, const Temporal *temp); (undefined) */ -/* extern Temporal *teq_float_tfloat(double d, const Temporal *temp); (undefined) */ -/* extern Temporal *teq_int_tint(int i, const Temporal *temp); (undefined) */ -/* extern Temporal *teq_point_tpoint(const GSERIALIZED *gs, const Temporal *temp); (undefined) */ +extern int always_eq_bool_tbool(bool b, const Temporal *temp); +extern int always_eq_float_tfloat(double d, const Temporal *temp); +extern int always_eq_int_tint(int i, const Temporal *temp); +extern int always_eq_point_tpoint(const GSERIALIZED *gs, const Temporal *temp); +extern int always_eq_tbool_bool(const Temporal *temp, bool b); +extern int always_eq_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int always_eq_text_ttext(const text *txt, const Temporal *temp); +extern int always_eq_tfloat_float(const Temporal *temp, double d); +extern int always_eq_tint_int(const Temporal *temp, int i); +extern int always_eq_tpoint_point(const Temporal *temp, const GSERIALIZED *gs); +extern int always_eq_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); +extern int always_eq_ttext_text(const Temporal *temp, const text *txt); +extern int always_ne_bool_tbool(bool b, const Temporal *temp); +extern int always_ne_float_tfloat(double d, const Temporal *temp); +extern int always_ne_int_tint(int i, const Temporal *temp); +extern int always_ne_point_tpoint(const GSERIALIZED *gs, const Temporal *temp); +extern int always_ne_tbool_bool(const Temporal *temp, bool b); +extern int always_ne_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int always_ne_text_ttext(const text *txt, const Temporal *temp); +extern int always_ne_tfloat_float(const Temporal *temp, double d); +extern int always_ne_tint_int(const Temporal *temp, int i); +extern int always_ne_tpoint_point(const Temporal *temp, const GSERIALIZED *gs); +extern int always_ne_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); +extern int always_ne_ttext_text(const Temporal *temp, const text *txt); +extern int always_ge_float_tfloat(double d, const Temporal *temp); +extern int always_ge_int_tint(int i, const Temporal *temp); +extern int always_ge_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int always_ge_text_ttext(const text *txt, const Temporal *temp); +extern int always_ge_tfloat_float(const Temporal *temp, double d); +extern int always_ge_tint_int(const Temporal *temp, int i); +extern int always_ge_ttext_text(const Temporal *temp, const text *txt); +extern int always_gt_float_tfloat(double d, const Temporal *temp); +extern int always_gt_int_tint(int i, const Temporal *temp); +extern int always_gt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int always_gt_text_ttext(const text *txt, const Temporal *temp); +extern int always_gt_tfloat_float(const Temporal *temp, double d); +extern int always_gt_tint_int(const Temporal *temp, int i); +extern int always_gt_ttext_text(const Temporal *temp, const text *txt); +extern int always_le_float_tfloat(double d, const Temporal *temp); +extern int always_le_int_tint(int i, const Temporal *temp); +extern int always_le_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int always_le_text_ttext(const text *txt, const Temporal *temp); +extern int always_le_tfloat_float(const Temporal *temp, double d); +extern int always_le_tint_int(const Temporal *temp, int i); +extern int always_le_ttext_text(const Temporal *temp, const text *txt); +extern int always_lt_float_tfloat(double d, const Temporal *temp); +extern int always_lt_int_tint(int i, const Temporal *temp); +extern int always_lt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int always_lt_text_ttext(const text *txt, const Temporal *temp); +extern int always_lt_tfloat_float(const Temporal *temp, double d); +extern int always_lt_tint_int(const Temporal *temp, int i); +extern int always_lt_ttext_text(const Temporal *temp, const text *txt); +extern int ever_eq_bool_tbool(bool b, const Temporal *temp); +extern int ever_eq_float_tfloat(double d, const Temporal *temp); +extern int ever_eq_int_tint(int i, const Temporal *temp); +extern int ever_eq_point_tpoint(const GSERIALIZED *gs, const Temporal *temp); +extern int ever_eq_tbool_bool(const Temporal *temp, bool b); +extern int ever_eq_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int ever_eq_text_ttext(const text *txt, const Temporal *temp); +extern int ever_eq_tfloat_float(const Temporal *temp, double d); +extern int ever_eq_tint_int(const Temporal *temp, int i); +extern int ever_eq_tpoint_point(const Temporal *temp, const GSERIALIZED *gs); +extern int ever_eq_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); +extern int ever_eq_ttext_text(const Temporal *temp, const text *txt); +extern int ever_ge_float_tfloat(double d, const Temporal *temp); +extern int ever_ge_int_tint(int i, const Temporal *temp); +extern int ever_ge_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int ever_ge_text_ttext(const text *txt, const Temporal *temp); +extern int ever_ge_tfloat_float(const Temporal *temp, double d); +extern int ever_ge_tint_int(const Temporal *temp, int i); +extern int ever_ge_ttext_text(const Temporal *temp, const text *txt); +extern int ever_gt_float_tfloat(double d, const Temporal *temp); +extern int ever_gt_int_tint(int i, const Temporal *temp); +extern int ever_gt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int ever_gt_text_ttext(const text *txt, const Temporal *temp); +extern int ever_gt_tfloat_float(const Temporal *temp, double d); +extern int ever_gt_tint_int(const Temporal *temp, int i); +extern int ever_gt_ttext_text(const Temporal *temp, const text *txt); +extern int ever_le_float_tfloat(double d, const Temporal *temp); +extern int ever_le_int_tint(int i, const Temporal *temp); +extern int ever_le_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int ever_le_text_ttext(const text *txt, const Temporal *temp); +extern int ever_le_tfloat_float(const Temporal *temp, double d); +extern int ever_le_tint_int(const Temporal *temp, int i); +extern int ever_le_ttext_text(const Temporal *temp, const text *txt); +extern int ever_lt_float_tfloat(double d, const Temporal *temp); +extern int ever_lt_int_tint(int i, const Temporal *temp); +extern int ever_lt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int ever_lt_text_ttext(const text *txt, const Temporal *temp); +extern int ever_lt_tfloat_float(const Temporal *temp, double d); +extern int ever_lt_tint_int(const Temporal *temp, int i); +extern int ever_lt_ttext_text(const Temporal *temp, const text *txt); +extern int ever_ne_bool_tbool(bool b, const Temporal *temp); +extern int ever_ne_float_tfloat(double d, const Temporal *temp); +extern int ever_ne_int_tint(int i, const Temporal *temp); +extern int ever_ne_point_tpoint(const GSERIALIZED *gs, const Temporal *temp); +extern int ever_ne_tbool_bool(const Temporal *temp, bool b); +extern int ever_ne_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int ever_ne_text_ttext(const text *txt, const Temporal *temp); +extern int ever_ne_tfloat_float(const Temporal *temp, double d); +extern int ever_ne_tint_int(const Temporal *temp, int i); +extern int ever_ne_tpoint_point(const Temporal *temp, const GSERIALIZED *gs); +extern int ever_ne_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); +extern int ever_ne_ttext_text(const Temporal *temp, const text *txt); + +extern Temporal *teq_bool_tbool(bool b, const Temporal *temp); +extern Temporal *teq_float_tfloat(double d, const Temporal *temp); +extern Temporal *teq_int_tint(int i, const Temporal *temp); +extern Temporal *teq_point_tpoint(const GSERIALIZED *gs, const Temporal *temp); extern Temporal *teq_tbool_bool(const Temporal *temp, bool b); -extern Temporal *teq_temporal_temporal(const Temporal *temp1, const Temporal *temp2); -/* extern Temporal *teq_text_ttext(const text *txt, const Temporal *temp); (undefined) */ +/* extern Temporal *teq_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ +extern Temporal *teq_text_ttext(const text *txt, const Temporal *temp); extern Temporal *teq_tfloat_float(const Temporal *temp, double d); extern Temporal *teq_tpoint_point(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *teq_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); extern Temporal *teq_tint_int(const Temporal *temp, int i); extern Temporal *teq_ttext_text(const Temporal *temp, const text *txt); extern Temporal *tge_float_tfloat(double d, const Temporal *temp); extern Temporal *tge_int_tint(int i, const Temporal *temp); -extern Temporal *tge_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +/* extern Temporal *tge_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ extern Temporal *tge_text_ttext(const text *txt, const Temporal *temp); extern Temporal *tge_tfloat_float(const Temporal *temp, double d); extern Temporal *tge_tint_int(const Temporal *temp, int i); extern Temporal *tge_ttext_text(const Temporal *temp, const text *txt); extern Temporal *tgt_float_tfloat(double d, const Temporal *temp); extern Temporal *tgt_int_tint(int i, const Temporal *temp); -extern Temporal *tgt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +/* extern Temporal *tgt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ extern Temporal *tgt_text_ttext(const text *txt, const Temporal *temp); extern Temporal *tgt_tfloat_float(const Temporal *temp, double d); extern Temporal *tgt_tint_int(const Temporal *temp, int i); extern Temporal *tgt_ttext_text(const Temporal *temp, const text *txt); extern Temporal *tle_float_tfloat(double d, const Temporal *temp); extern Temporal *tle_int_tint(int i, const Temporal *temp); -extern Temporal *tle_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +/* extern Temporal *tle_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ extern Temporal *tle_text_ttext(const text *txt, const Temporal *temp); extern Temporal *tle_tfloat_float(const Temporal *temp, double d); extern Temporal *tle_tint_int(const Temporal *temp, int i); extern Temporal *tle_ttext_text(const Temporal *temp, const text *txt); extern Temporal *tlt_float_tfloat(double d, const Temporal *temp); extern Temporal *tlt_int_tint(int i, const Temporal *temp); -extern Temporal *tlt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +/* extern Temporal *tlt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ extern Temporal *tlt_text_ttext(const text *txt, const Temporal *temp); extern Temporal *tlt_tfloat_float(const Temporal *temp, double d); extern Temporal *tlt_tint_int(const Temporal *temp, int i); extern Temporal *tlt_ttext_text(const Temporal *temp, const text *txt); -/* extern Temporal *tne_bool_tbool(bool b, const Temporal *temp); (undefined) */ -/* extern Temporal *tne_float_tfloat(double d, const Temporal *temp); (undefined) */ -/* extern Temporal *tne_int_tint(int i, const Temporal *temp); (undefined) */ -/* extern Temporal *tne_point_tpoint(const GSERIALIZED *gs, const Temporal *temp); (undefined) */ +extern Temporal *tne_bool_tbool(bool b, const Temporal *temp); +extern Temporal *tne_float_tfloat(double d, const Temporal *temp); +extern Temporal *tne_int_tint(int i, const Temporal *temp); +extern Temporal *tne_point_tpoint(const GSERIALIZED *gs, const Temporal *temp); extern Temporal *tne_tbool_bool(const Temporal *temp, bool b); -extern Temporal *tne_temporal_temporal(const Temporal *temp1, const Temporal *temp2); -/* extern Temporal *tne_text_ttext(const text *txt, const Temporal *temp); (undefined) */ +/* extern Temporal *tne_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ +extern Temporal *tne_text_ttext(const text *txt, const Temporal *temp); extern Temporal *tne_tfloat_float(const Temporal *temp, double d); extern Temporal *tne_tpoint_point(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tne_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); extern Temporal *tne_tint_int(const Temporal *temp, int i); extern Temporal *tne_ttext_text(const Temporal *temp, const text *txt); @@ -1738,7 +1871,6 @@ extern Temporal *div_int_tint(int i, const Temporal *tnumber); extern Temporal *div_tfloat_float(const Temporal *tnumber, double d); extern Temporal *div_tint_int(const Temporal *tnumber, int i); extern Temporal *div_tnumber_tnumber(const Temporal *tnumber1, const Temporal *tnumber2); -extern double float_degrees(double value, bool normalize); extern Temporal *mult_float_tfloat(double d, const Temporal *tnumber); extern Temporal *mult_int_tint(int i, const Temporal *tnumber); extern Temporal *mult_tfloat_float(const Temporal *tnumber, double d); @@ -1749,11 +1881,7 @@ extern Temporal *sub_int_tint(int i, const Temporal *tnumber); extern Temporal *sub_tfloat_float(const Temporal *tnumber, double d); extern Temporal *sub_tint_int(const Temporal *tnumber, int i); extern Temporal *sub_tnumber_tnumber(const Temporal *tnumber1, const Temporal *tnumber2); -extern Temporal *tfloat_round(const Temporal *temp, int maxdd); -extern Temporal **tfloatarr_round(const Temporal **temp, int count, int maxdd); -extern Temporal *tfloat_degrees(const Temporal *temp, bool normalize); extern Temporal *tfloat_derivative(const Temporal *temp); -extern Temporal *tfloat_radians(const Temporal *temp); extern Temporal *tnumber_abs(const Temporal *temp); extern Temporal *tnumber_angular_difference(const Temporal *temp); extern Temporal *tnumber_delta_value(const Temporal *temp); @@ -1782,8 +1910,8 @@ extern double nad_tpoint_stbox(const Temporal *temp, const STBox *box); extern double nad_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); extern TInstant *nai_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs); extern TInstant *nai_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); -extern bool shortestline_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs, GSERIALIZED **result); -extern bool shortestline_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2, GSERIALIZED **result); +extern GSERIALIZED *shortestline_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs); +extern GSERIALIZED *shortestline_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); extern bool bearing_point_point(const GSERIALIZED *gs1, const GSERIALIZED *gs2, double *result); extern Temporal *bearing_tpoint_point(const Temporal *temp, const GSERIALIZED *gs, bool invert); @@ -1802,6 +1930,7 @@ extern Temporal *tpoint_speed(const Temporal *temp); extern int tpoint_srid(const Temporal *temp); extern STBox *tpoint_stboxes(const Temporal *temp, int *count); extern GSERIALIZED *tpoint_trajectory(const Temporal *temp); +extern GSERIALIZED *tpoint_twcentroid(const Temporal *temp); extern STBox *geo_expand_space(const GSERIALIZED *gs, double d); extern Temporal *geomeas_to_tpoint(const GSERIALIZED *gs); @@ -1810,11 +1939,17 @@ extern Temporal *tgeompoint_to_tgeogpoint(const Temporal *temp); bool tpoint_AsMVTGeom(const Temporal *temp, const STBox *bounds, int32_t extent, int32_t buffer, bool clip_geom, GSERIALIZED **gsarr, int64 **timesarr, int *count); extern STBox *tpoint_expand_space(const Temporal *temp, double d); extern Temporal **tpoint_make_simple(const Temporal *temp, int *count); -extern Temporal *tpoint_round(const Temporal *temp, int maxdd); -extern Temporal **tpointarr_round(const Temporal **temp, int count, int maxdd); extern Temporal *tpoint_set_srid(const Temporal *temp, int32 srid); bool tpoint_tfloat_to_geomeas(const Temporal *tpoint, const Temporal *measure, bool segmentize, GSERIALIZED **result); +extern int acontains_geo_tpoint(const GSERIALIZED *gs, const Temporal *temp); +extern int adisjoint_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int adisjoint_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); +extern int adwithin_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs, double dist); +extern int adwithin_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2, double dist); +extern int aintersects_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int aintersects_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); +extern int atouches_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs); extern int econtains_geo_tpoint(const GSERIALIZED *gs, const Temporal *temp); extern int edisjoint_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs); extern int edisjoint_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); @@ -1826,9 +1961,11 @@ extern int etouches_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs); extern Temporal *tcontains_geo_tpoint(const GSERIALIZED *gs, const Temporal *temp, bool restr, bool atvalue); extern Temporal *tdisjoint_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs, bool restr, bool atvalue); +extern Temporal *tdisjoint_tpoint_tpoint (const Temporal *temp1, const Temporal *temp2, bool restr, bool atvalue); extern Temporal *tdwithin_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs, double dist, bool restr, bool atvalue); extern Temporal *tdwithin_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2, double dist, bool restr, bool atvalue); extern Temporal *tintersects_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs, bool restr, bool atvalue); +extern Temporal *tintersects_tpoint_tpoint (const Temporal *temp1, const Temporal *temp2, bool restr, bool atvalue); extern Temporal *ttouches_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs, bool restr, bool atvalue); extern SkipList *tbool_tand_transfn(SkipList *state, const Temporal *temp); @@ -1839,25 +1976,33 @@ extern SkipList *temporal_tcount_transfn(SkipList *state, const Temporal *temp); extern SkipList *tfloat_tmax_transfn(SkipList *state, const Temporal *temp); extern SkipList *tfloat_tmin_transfn(SkipList *state, const Temporal *temp); extern SkipList *tfloat_tsum_transfn(SkipList *state, const Temporal *temp); +extern SkipList *tfloat_wmax_transfn(SkipList *state, const Temporal *temp, const Interval *interv); +extern SkipList *tfloat_wmin_transfn(SkipList *state, const Temporal *temp, const Interval *interv); +extern SkipList *tfloat_wsum_transfn(SkipList *state, const Temporal *temp, const Interval *interv); +extern SkipList *timestamptz_tcount_transfn(SkipList *state, TimestampTz t); extern SkipList *tint_tmax_transfn(SkipList *state, const Temporal *temp); extern SkipList *tint_tmin_transfn(SkipList *state, const Temporal *temp); extern SkipList *tint_tsum_transfn(SkipList *state, const Temporal *temp); +extern SkipList *tint_wmax_transfn(SkipList *state, const Temporal *temp, const Interval *interv); +extern SkipList *tint_wmin_transfn(SkipList *state, const Temporal *temp, const Interval *interv); +extern SkipList *tint_wsum_transfn(SkipList *state, const Temporal *temp, const Interval *interv); extern TBox *tnumber_extent_transfn(TBox *box, const Temporal *temp); -extern double tnumber_integral(const Temporal *temp); extern Temporal *tnumber_tavg_finalfn(SkipList *state); extern SkipList *tnumber_tavg_transfn(SkipList *state, const Temporal *temp); -extern double tnumber_twavg(const Temporal *temp); +extern SkipList *tnumber_wavg_transfn(SkipList *state, const Temporal *temp, const Interval *interv); extern STBox *tpoint_extent_transfn(STBox *box, const Temporal *temp); extern Temporal *tpoint_tcentroid_finalfn(SkipList *state); extern SkipList *tpoint_tcentroid_transfn(SkipList *state, Temporal *temp); -extern GSERIALIZED *tpoint_twcentroid(const Temporal *temp); +extern SkipList *tstzset_tcount_transfn(SkipList *state, const Set *s); +extern SkipList *tstzspan_tcount_transfn(SkipList *state, const Span *s); +extern SkipList *tstzspanset_tcount_transfn(SkipList *state, const SpanSet *ss); extern SkipList *ttext_tmax_transfn(SkipList *state, const Temporal *temp); extern SkipList *ttext_tmin_transfn(SkipList *state, const Temporal *temp); -Temporal *temporal_simplify_min_dist(const Temporal *temp, double dist); -Temporal *temporal_simplify_min_tdelta(const Temporal *temp, const Interval *mint); Temporal *temporal_simplify_dp(const Temporal *temp, double eps_dist, bool synchronized); Temporal *temporal_simplify_max_dist(const Temporal *temp, double eps_dist, bool synchronized); +Temporal *temporal_simplify_min_dist(const Temporal *temp, double dist); +Temporal *temporal_simplify_min_tdelta(const Temporal *temp, const Interval *mint); extern Temporal *temporal_tprecision(const Temporal *temp, const Interval *duration, TimestampTz origin); extern Temporal *temporal_tsample(const Temporal *temp, const Interval *duration, TimestampTz origin); @@ -1872,19 +2017,20 @@ extern double float_bucket(double value, double size, double origin); extern Span *floatspan_bucket_list(const Span *bounds, double size, double origin, int *count); extern int int_bucket(int value, int size, int origin); extern Span *intspan_bucket_list(const Span *bounds, int size, int origin, int *count); -extern Span *tstzspan_bucket_list(const Span *bounds, const Interval *duration, TimestampTz origin, int *count); extern STBox *stbox_tile(GSERIALIZED *point, TimestampTz t, double xsize, double ysize, double zsize, Interval *duration, GSERIALIZED *sorigin, TimestampTz torigin, bool hast); extern STBox *stbox_tile_list(const STBox *bounds, double xsize, double ysize, double zsize, const Interval *duration, GSERIALIZED *sorigin, TimestampTz torigin, int *count); -extern TBox *tintbox_tile_list(const TBox *box, int xsize, const Interval *duration, int xorigin, TimestampTz torigin, int *count); -extern TBox *tfloatbox_tile_list(const TBox *box, double xsize, const Interval *duration, double xorigin, TimestampTz torigin, int *count); extern Temporal **temporal_time_split(Temporal *temp, Interval *duration, TimestampTz torigin, TimestampTz **time_buckets, int *count); extern Temporal **tfloat_value_split(Temporal *temp, double size, double origin, double **value_buckets, int *count); extern Temporal **tfloat_value_time_split(Temporal *temp, double size, Interval *duration, double vorigin, TimestampTz torigin, double **value_buckets, TimestampTz **time_buckets, int *count); +extern TBox *tfloatbox_tile(double value, TimestampTz t, double vsize, Interval *duration, double vorigin, TimestampTz torigin); +extern TBox *tfloatbox_tile_list(const TBox *box, double xsize, const Interval *duration, double xorigin, TimestampTz torigin, int *count); extern TimestampTz timestamptz_bucket(TimestampTz timestamp, const Interval *duration, TimestampTz origin); extern Temporal **tint_value_split(Temporal *temp, int size, int origin, int **value_buckets, int *count); extern Temporal **tint_value_time_split(Temporal *temp, int size, Interval *duration, int vorigin, TimestampTz torigin, int **value_buckets, TimestampTz **time_buckets, int *count); -extern Temporal **tpoint_space_split(Temporal *temp, float xsize, float ysize, float zsize, GSERIALIZED *sorigin, bool bitmatrix, GSERIALIZED ***space_buckets, int *count); +extern TBox *tintbox_tile(int value, TimestampTz t, int vsize, Interval *duration, int vorigin, TimestampTz torigin); +extern TBox *tintbox_tile_list(const TBox *box, int xsize, const Interval *duration, int xorigin, TimestampTz torigin, int *count); extern Temporal **tpoint_space_time_split(Temporal *temp, float xsize, float ysize, float zsize, Interval *duration, GSERIALIZED *sorigin, TimestampTz torigin, bool bitmatrix, GSERIALIZED ***space_buckets, TimestampTz **time_buckets, int *count); +extern Span *tstzspan_bucket_list(const Span *bounds, const Interval *duration, TimestampTz origin, int *count); //-------------------- meos_catalog.h -------------------- @@ -2041,7 +2187,6 @@ extern meosType spansettype_spantype(meosType type); extern meosType basetype_spantype(meosType type); extern meosType basetype_settype(meosType type); -extern bool meostype_internal(meosType type); /* extern bool meos_basetype(meosType type); (undefined) */ /* extern bool alpha_basetype(meosType type); (undefined) */ extern bool tnumber_basetype(meosType type); @@ -2108,6 +2253,8 @@ extern bool ensure_tnumber_tgeo_type(meosType type); //-------------------- meos_internal.h -------------------- +//#include + //#include //#include @@ -2118,6 +2265,8 @@ extern bool ensure_tnumber_tgeo_type(meosType type); extern uint32 datum_hash(Datum d, meosType basetype); extern uint64 datum_hash_extended(Datum d, meosType basetype, uint64 seed); + + extern Set *set_in(const char *str, meosType basetype); extern char *set_out(const Set *s, int maxdd); extern Span *span_in(const char *str, meosType spantype); @@ -2125,142 +2274,140 @@ extern char *span_out(const Span *s, int maxdd); extern SpanSet *spanset_in(const char *str, meosType spantype); extern char *spanset_out(const SpanSet *ss, int maxdd); -extern Set *set_compact(const Set *s); extern Set *set_cp(const Set *s); extern Set *set_make(const Datum *values, int count, meosType basetype, bool ordered); extern Set *set_make_exp(const Datum *values, int count, int maxcount, meosType basetype, bool ordered); extern Set *set_make_free(Datum *values, int count, meosType basetype, bool ordered); -/* extern char *set_out(const Set *s, int maxdd); (repeated) */ extern Span *span_cp(const Span *s); extern Span *span_make(Datum lower, Datum upper, bool lower_inc, bool upper_inc, meosType basetype); -/* extern char *span_out(const Span *s, int maxdd); (repeated) */ extern void span_set(Datum lower, Datum upper, bool lower_inc, bool upper_inc, meosType basetype, meosType spantype, Span *s); extern SpanSet *spanset_cp(const SpanSet *ss); -extern SpanSet *spanset_compact(SpanSet *ss); extern SpanSet *spanset_make_exp(Span *spans, int count, int maxcount, bool normalize, bool ordered); -extern SpanSet *spanset_make_free(Span *spans, int count, bool normalize); -/* extern char *spanset_out(const SpanSet *ss, int maxdd); (repeated) */ - +extern SpanSet *spanset_make_free(Span *spans, int count, bool normalize, bool ordered); + +extern Span *datespan_tstzspan(const Span *s); +extern SpanSet *datespanset_tstzspanset(const SpanSet *ss); +extern Span *intspan_floatspan(const Span *s); +extern SpanSet *intspanset_floatspanset(const SpanSet *ss); +extern Span *floatspan_intspan(const Span *s); +extern SpanSet *floatspanset_intspanset(const SpanSet *ss); +extern Span *set_span(const Set *s); +extern SpanSet *set_spanset(const Set *s); extern SpanSet *span_spanset(const Span *s); +extern Span *tstzspan_datespan(const Span *s); +extern SpanSet *tstzspanset_datespanset(const SpanSet *ss); +extern void value_set_span(Datum value, meosType basetype, Span *s); extern Set *value_to_set(Datum d, meosType basetype); extern Span *value_to_span(Datum d, meosType basetype); extern SpanSet *value_to_spanset(Datum d, meosType basetype); +extern Datum numspan_width(const Span *s); +extern Datum numspanset_width(const SpanSet *ss, bool boundspan); extern Datum set_end_value(const Set *s); extern int set_mem_size(const Set *s); extern void set_set_span(const Set *s, Span *sp); -extern Span *set_span(const Set *s); +/* extern Span *set_span(const Set *s); (repeated) */ extern Datum set_start_value(const Set *s); extern bool set_value_n(const Set *s, int n, Datum *result); +extern Datum *set_vals(const Set *s); extern Datum *set_values(const Set *s); extern Datum spanset_lower(const SpanSet *ss); extern int spanset_mem_size(const SpanSet *ss); +extern const Span **spanset_sps(const SpanSet *ss); extern Datum spanset_upper(const SpanSet *ss); -extern void spatialset_set_stbox(const Set *set, STBox *box); -extern void value_set_span(Datum d, meosType basetype, Span *s); extern void datespan_set_tstzspan(const Span *s1, Span *s2); extern void floatspan_rnd(const Span *span, Datum size, Span *result); extern void floatspan_set_intspan(const Span *s1, Span *s2); -/* extern void floatspan_set_numspan(const Span *s1, Span *s2, meosType basetype); (undefined) */ extern void intspan_set_floatspan(const Span *s1, Span *s2); extern Set *numset_shift_scale(const Set *s, Datum shift, Datum width, bool hasshift, bool haswidth); -/* extern void numspan_set_floatspan(const Span *s1, Span *s2); (undefined) */ extern Span *numspan_shift_scale(const Span *s, Datum shift, Datum width, bool hasshift, bool haswidth); extern SpanSet *numspanset_shift_scale(const SpanSet *ss, Datum shift, Datum width, bool hasshift, bool haswidth); -/* extern Set *set_compact(const Set *s); (repeated) */ +extern Set *set_compact(const Set *s); extern void span_expand(const Span *s1, Span *s2); -/* extern SpanSet *spanset_compact(SpanSet *ss); (repeated) */ +extern SpanSet *spanset_compact(SpanSet *ss); extern void tstzspan_set_datespan(const Span *s1, Span *s2); -extern int set_cmp1(const Set *s1, const Set *s2); -extern bool set_eq1(const Set *s1, const Set *s2); -extern int span_cmp1(const Span *s1, const Span *s2); -extern bool span_eq1(const Span *s1, const Span *s2); -extern int spanset_cmp1(const SpanSet *ss1, const SpanSet *ss2); -extern bool spanset_eq1(const SpanSet *ss1, const SpanSet *ss2); - -extern Span *spanbase_extent_transfn(Span *s, Datum d, meosType basetype); -extern Set *value_union_transfn(Set *state, Datum d, meosType basetype); - extern bool adj_span_span(const Span *s1, const Span *s2); -extern bool adjacent_span_value(const Span *s, Datum d, meosType basetype); -extern bool adjacent_spanset_value(const SpanSet *ss, Datum d, meosType basetype); +extern bool adjacent_span_value(const Span *s, Datum value); +extern bool adjacent_spanset_value(const SpanSet *ss, Datum value); +extern bool adjacent_value_spanset(Datum value, const SpanSet *ss); extern bool cont_span_span(const Span *s1, const Span *s2); -extern bool contains_span_value(const Span *s, Datum d, meosType basetype); -extern bool contains_spanset_value(const SpanSet *ss, Datum d, meosType basetype); -extern bool contains_set_value(const Set *s, Datum d, meosType basetype); -/* extern bool contains_set_set(const Set *s1, const Set *s2); (repeated) */ -extern bool contained_value_span(Datum d, meosType basetype, const Span *s); -extern bool contained_value_set(Datum d, meosType basetype, const Set *s); -/* extern bool contained_set_set(const Set *s1, const Set *s2); (repeated) */ -extern bool contained_value_spanset(Datum d, meosType basetype, const SpanSet *ss); +extern bool contained_value_set(Datum value, const Set *s); +extern bool contained_value_span(Datum value, const Span *s); +extern bool contained_value_spanset(Datum value, const SpanSet *ss); +extern bool contains_set_value(const Set *s, Datum value); +extern bool contains_span_value(const Span *s, Datum value); +extern bool contains_spanset_value(const SpanSet *ss, Datum value); +extern bool ovadj_span_span(const Span *s1, const Span *s2); extern bool over_span_span(const Span *s1, const Span *s2); -extern bool over_adj_span_span(const Span *s1, const Span *s2); -/* extern bool overlaps_value_span(Datum d, meosType basetype, const Span *s); (undefined) */ -/* extern bool overlaps_value_spanset(Datum d, meosType basetype, const SpanSet *ss); (undefined) */ -/* extern bool overlaps_span_value(const Span *s, Datum d, meosType basetype); (undefined) */ -/* extern bool overlaps_spanset_value(const SpanSet *ss, Datum d, meosType basetype); (undefined) */ -/* extern bool overlaps_set_set(const Set *s1, const Set *s2); (repeated) */ - -extern bool left_notadj_span_span(const Span *s1, const Span *s2); -/* extern bool left_set_set(const Set *s1, const Set *s2); (repeated) */ -extern bool left_set_value(const Set *s, Datum d, meosType basetype); -extern bool left_span_value(const Span *s, Datum d, meosType basetype); -extern bool left_spanset_value(const SpanSet *ss, Datum d, meosType basetype); -extern bool left_value_set(Datum d, meosType basetype, const Set *s); -extern bool left_value_span(Datum d, meosType basetype, const Span *s); -extern bool left_value_spanset(Datum d, meosType basetype, const SpanSet *ss); + +extern bool left_set_value(const Set *s, Datum value); +extern bool left_span_value(const Span *s, Datum value); +extern bool left_spanset_value(const SpanSet *ss, Datum value); +extern bool left_value_set(Datum value, const Set *s); +extern bool left_value_span(Datum value, const Span *s); +extern bool left_value_spanset(Datum value, const SpanSet *ss); extern bool lf_span_span(const Span *s1, const Span *s2); -extern bool ri_span_span(const Span *s1, const Span *s2); -extern bool right_value_set(Datum d, meosType basetype, const Set *s); -extern bool right_set_value(const Set *s, Datum d, meosType basetype); -/* extern bool right_set_set(const Set *s1, const Set *s2); (repeated) */ -extern bool right_value_span(Datum d, meosType basetype, const Span *s); -extern bool right_value_spanset(Datum d, meosType basetype, const SpanSet *ss); -extern bool right_span_value(const Span *s, Datum d, meosType basetype); -extern bool right_spanset_value(const SpanSet *ss, Datum d, meosType basetype); -extern bool overleft_value_set(Datum d, meosType basetype, const Set *s); -extern bool overleft_set_value(const Set *s, Datum d, meosType basetype); -/* extern bool overleft_set_set(const Set *s1, const Set *s2); (repeated) */ -extern bool overleft_value_span(Datum d, meosType basetype, const Span *s); -extern bool overleft_value_spanset(Datum d, meosType basetype, const SpanSet *ss); -extern bool overleft_span_value(const Span *s, Datum d, meosType basetype); -extern bool overleft_spanset_value(const SpanSet *ss, Datum d, meosType basetype); -extern bool overright_value_set(Datum d, meosType basetype, const Set *s); -extern bool overright_set_value(const Set *s, Datum d, meosType basetype); -/* extern bool overright_set_set(const Set *s1, const Set *s2); (repeated) */ -extern bool overright_value_span(Datum d, meosType basetype, const Span *s); -extern bool overright_value_spanset(Datum d, meosType basetype, const SpanSet *ss); -extern bool overright_span_value(const Span *s, Datum d, meosType basetype); -extern bool overright_spanset_value(const SpanSet *ss, Datum d, meosType basetype); +extern bool lfnadj_span_span(const Span *s1, const Span *s2); +extern bool overleft_set_value(const Set *s, Datum value); +extern bool overleft_span_value(const Span *s, Datum value); +extern bool overleft_spanset_value(const SpanSet *ss, Datum value); +extern bool overleft_value_set(Datum value, const Set *s); +extern bool overleft_value_span(Datum value, const Span *s); +extern bool overleft_value_spanset(Datum value, const SpanSet *ss); +extern bool overright_set_value(const Set *s, Datum value); +extern bool overright_span_value(const Span *s, Datum value); +extern bool overright_spanset_value(const SpanSet *ss, Datum value); +extern bool overright_value_set(Datum value, const Set *s); +extern bool overright_value_span(Datum value, const Span *s); +extern bool overright_value_spanset(Datum value, const SpanSet *ss); extern bool ovlf_span_span(const Span *s1, const Span *s2); extern bool ovri_span_span(const Span *s1, const Span *s2); +extern bool ri_span_span(const Span *s1, const Span *s2); +extern bool right_value_set(Datum value, const Set *s); +extern bool right_set_value(const Set *s, Datum value); +extern bool right_value_span(Datum value, const Span *s); +extern bool right_value_spanset(Datum value, const SpanSet *ss); +extern bool right_span_value(const Span *s, Datum value); +extern bool right_spanset_value(const SpanSet *ss, Datum value); +extern void bbox_union_span_span(const Span *s1, const Span *s2, Span *result); extern bool inter_span_span(const Span *s1, const Span *s2, Span *result); -extern Set *intersection_set_value(const Set *s, Datum d, meosType basetype); -extern Span *intersection_span_value(const Span *s, Datum d, meosType basetype); -extern SpanSet *intersection_spanset_value(const SpanSet *ss, Datum d, meosType basetype); -extern Set *minus_set_value(const Set *s, Datum d, meosType basetype); -extern SpanSet *minus_span_value(const Span *s, Datum d, meosType basetype); -extern SpanSet *minus_spanset_value(const SpanSet *ss, Datum d, meosType basetype); -extern Set *minus_value_set(Datum d, meosType basetype, const Set *s); -extern SpanSet *minus_value_span(Datum d, meosType basetype, const Span *s); -extern SpanSet *minus_value_spanset(Datum d, meosType basetype, const SpanSet *ss); -extern Set *union_set_value(const Set *s, const Datum d, meosType basetype); -extern SpanSet *union_span_value(const Span *s, Datum v, meosType basetype); -extern SpanSet *union_spanset_value(const SpanSet *ss, Datum d, meosType basetype); - -extern double dist_set_set(const Set *s1, const Set *s2); -extern double dist_span_span(const Span *s1, const Span *s2); -extern double distance_value_value(Datum l, Datum r, meosType basetype); -extern double distance_span_value(const Span *s, Datum d, meosType basetype); -extern double distance_spanset_value(const SpanSet *ss, Datum d, meosType basetype); -/* extern double distance_value_set(Datum d, meosType basetype, const Set *s); (undefined) */ -extern double distance_set_value(const Set *s, Datum d, meosType basetype); - -/* extern uint32 datum_hash(Datum d, meosType basetype); (repeated) */ -/* extern uint64 datum_hash_extended(Datum d, meosType basetype, uint64 seed); (repeated) */ +extern Set *intersection_set_value(const Set *s, Datum value); +extern Span *intersection_span_value(const Span *s, Datum value); +extern SpanSet *intersection_spanset_value(const SpanSet *ss, Datum value); +extern Set *intersection_value_set(Datum value, const Set *s); +extern Span *intersection_value_span(Datum value, const Span *s); +extern SpanSet *intersection_value_spanset(Datum value, const SpanSet *ss); +extern int mi_span_span(const Span *s1, const Span *s2, Span *result); +extern Set *minus_set_value(const Set *s, Datum value); +extern SpanSet *minus_span_value(const Span *s, Datum value); +extern SpanSet *minus_spanset_value(const SpanSet *ss, Datum value); +extern Set *minus_value_set(Datum value, const Set *s); +extern SpanSet *minus_value_span(Datum value, const Span *s); +extern SpanSet *minus_value_spanset(Datum value, const SpanSet *ss); +extern Span *super_union_span_span(const Span *s1, const Span *s2); +extern Set *union_set_value(const Set *s, const Datum value); +extern SpanSet *union_span_value(const Span *s, Datum value); +extern SpanSet *union_spanset_value(const SpanSet *ss, Datum value); +extern Set *union_value_set(const Datum value, const Set *s); +extern SpanSet *union_value_span(Datum value, const Span *s); +extern SpanSet *union_value_spanset(Datum value, const SpanSet *ss); + +extern Datum dist_set_set(const Set *s1, const Set *s2); +extern Datum dist_span_span(const Span *s1, const Span *s2); +extern Datum distance_set_set(const Set *s1, const Set *s2); +extern Datum distance_set_value(const Set *s, Datum value); +extern Datum distance_span_span(const Span *s1, const Span *s2); +extern Datum distance_span_value(const Span *s, Datum value); +extern Datum distance_spanset_span(const SpanSet *ss, const Span *s); +extern Datum distance_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern Datum distance_spanset_value(const SpanSet *ss, Datum value); +extern Datum distance_value_value(Datum l, Datum r, meosType basetype); + +extern Span *spanbase_extent_transfn(Span *state, Datum value, meosType basetype); +extern Set *value_union_transfn(Set *state, Datum value, meosType basetype); extern TBox *number_tstzspan_to_tbox(Datum d, meosType basetype, const Span *s); extern TBox *number_timestamptz_to_tbox(Datum d, meosType basetype, TimestampTz t); @@ -2269,7 +2416,10 @@ extern void stbox_set(bool hasx, bool hasz, bool geodetic, int32 srid, double xm extern TBox *tbox_cp(const TBox *box); extern void tbox_set(const Span *s, const Span *p, TBox *box); +extern STBox *box3d_to_stbox(const BOX3D *box); +extern STBox *gbox_to_stbox(const GBOX *box); extern void float_set_tbox(double d, TBox *box); +/* extern STBox *gbox_to_stbox(const GBOX *box); (repeated) */ extern bool geo_set_stbox(const GSERIALIZED *gs, STBox *box); extern void geoarr_set_stbox(const Datum *values, int count, STBox *box); extern void int_set_tbox(int i, TBox *box); @@ -2278,26 +2428,24 @@ extern TBox *number_to_tbox(Datum value, meosType basetype); extern void numset_set_tbox(const Set *s, TBox *box); extern void numspan_set_tbox(const Span *span, TBox *box); extern void numspanset_set_tbox(const SpanSet *ss, TBox *box); -extern void tstzspan_set_stbox(const Span *s, STBox *box); -extern void tstzspan_set_tbox(const Span *s, TBox *box); -extern void tstzspanset_set_stbox(const SpanSet *ss, STBox *box); -extern void tstzspanset_set_tbox(const SpanSet *ss, TBox *box); +extern void spatialset_set_stbox(const Set *set, STBox *box); extern void stbox_set_box3d(const STBox *box, BOX3D *box3d); extern void stbox_set_gbox(const STBox *box, GBOX *gbox); extern void timestamptz_set_stbox(TimestampTz t, STBox *box); extern void timestamptz_set_tbox(TimestampTz t, TBox *box); extern void tstzset_set_stbox(const Set *s, STBox *box); extern void tstzset_set_tbox(const Set *s, TBox *box); +extern void tstzspan_set_stbox(const Span *s, STBox *box); +extern void tstzspan_set_tbox(const Span *s, TBox *box); +extern void tstzspanset_set_stbox(const SpanSet *ss, STBox *box); +extern void tstzspanset_set_tbox(const SpanSet *ss, TBox *box); extern TBox *tbox_shift_scale_value(const TBox *box, Datum shift, Datum width, meosType basetype, bool hasshift, bool haswidth); extern void stbox_expand(const STBox *box1, STBox *box2); extern void tbox_expand(const TBox *box1, TBox *box2); -extern void bbox_union_span_span(const Span *s1, const Span *s2, Span *result); -/* extern bool inter_stbox_stbox(const STBox *box1, const STBox *box2, STBox *result); (repeated) */ -/* extern bool inter_tbox_tbox(const TBox *box1, const TBox *box2, TBox *result); (repeated) */ - - +extern bool inter_stbox_stbox(const STBox *box1, const STBox *box2, STBox *result); +extern bool inter_tbox_tbox(const TBox *box1, const TBox *box2, TBox *result); extern char **geoarr_as_text(const Datum *geoarr, int count, int maxdd, bool extended); extern char *tboolinst_as_mfjson(const TInstant *inst, bool with_bbox); @@ -2311,8 +2459,7 @@ extern char *tboolseqset_as_mfjson(const TSequenceSet *ss, bool with_bbox); extern TSequenceSet *tboolseqset_in(const char *str); extern Temporal *temporal_in(const char *str, meosType temptype); extern char *temporal_out(const Temporal *temp, int maxdd); -extern Datum *temporal_values(const Temporal *temp, int *count); -extern char **temporalarr_out(const Temporal **temparr, int count, int maxdd); +extern char **temparr_out(const Temporal **temparr, int count, int maxdd); extern char *tfloatinst_as_mfjson(const TInstant *inst, bool with_bbox, int precision); /* extern TInstant *tfloatinst_from_mfjson(json_object *mfjson); (undefined type json_object) */ extern TInstant *tfloatinst_in(const char *str); @@ -2369,26 +2516,21 @@ extern char *ttextseqset_as_mfjson(const TSequenceSet *ss, bool with_bbox); /* extern TSequenceSet *ttextseqset_from_mfjson(json_object *mfjson); (undefined type json_object) */ extern TSequenceSet *ttextseqset_in(const char *str); -/* extern Temporal *temporal_cp(const Temporal *temp); (repeated) */ +extern Temporal *temporal_cp(const Temporal *temp); extern Temporal *temporal_from_base_temp(Datum value, meosType temptype, const Temporal *temp); extern TInstant *tinstant_copy(const TInstant *inst); extern TInstant *tinstant_make(Datum value, meosType temptype, TimestampTz t); extern TSequence *tpointseq_make_coords(const double *xcoords, const double *ycoords, const double *zcoords, const TimestampTz *times, int count, int32 srid, bool geodetic, bool lower_inc, bool upper_inc, interpType interp, bool normalize); -extern TSequence *tsequence_from_base_tstzset(Datum value, meosType temptype, const Set *ss); -extern TSequence *tsequence_make_exp(const TInstant **instants, int count, int maxcount, bool lower_inc, bool upper_inc, interpType interp, bool normalize); -extern TSequence *tsequence_compact(const TSequence *seq); -extern void tsequence_restart(TSequence *seq, int last); -extern TSequence *tsequence_subseq(const TSequence *seq, int from, int to, bool lower_inc, bool upper_inc); extern TSequence *tsequence_copy(const TSequence *seq); +extern TSequence *tsequence_from_base_tstzset(Datum value, meosType temptype, const Set *ss); extern TSequence *tsequence_from_base_tstzspan(Datum value, meosType temptype, const Span *s, interpType interp); +extern TSequence *tsequence_make_exp(const TInstant **instants, int count, int maxcount, bool lower_inc, bool upper_inc, interpType interp, bool normalize); extern TSequence *tsequence_make_free(TInstant **instants, int count, bool lower_inc, bool upper_inc, interpType interp, bool normalize); -extern TSequenceSet *tsequenceset_make_exp(const TSequence **sequences, int count, int maxcount, bool normalize); -extern TSequenceSet *tsequenceset_compact(const TSequenceSet *ss); -extern TSequenceSet *tsequenceset_make_free(TSequence **sequences, int count, bool normalize); -extern void tsequenceset_restart(TSequenceSet *ss, int last); extern TSequenceSet *tsequenceset_copy(const TSequenceSet *ss); extern TSequenceSet *tseqsetarr_to_tseqset(TSequenceSet **seqsets, int count, int totalseqs); extern TSequenceSet *tsequenceset_from_base_tstzspanset(Datum value, meosType temptype, const SpanSet *ss, interpType interp); +extern TSequenceSet *tsequenceset_make_exp(const TSequence **sequences, int count, int maxcount, bool normalize); +extern TSequenceSet *tsequenceset_make_free(TSequence **sequences, int count, bool normalize); extern void temporal_set_tstzspan(const Temporal *temp, Span *s); extern void tinstant_set_tstzspan(const TInstant *inst, Span *s); @@ -2397,65 +2539,61 @@ extern void tsequence_set_tstzspan(const TSequence *seq, Span *s); extern void tsequenceset_set_tstzspan(const TSequenceSet *ss, Span *s); extern Datum temporal_end_value(const Temporal *temp); +extern const TInstant **temporal_insts(const Temporal *temp, int *count); extern Datum temporal_max_value(const Temporal *temp); extern size_t temporal_mem_size(const Temporal *temp); extern Datum temporal_min_value(const Temporal *temp); +extern const TSequence **temporal_seqs(const Temporal *temp, int *count); extern void temporal_set_bbox(const Temporal *temp, void *box); -extern TSequence *tfloatseq_derivative(const TSequence *seq); -extern TSequenceSet *tfloatseqset_derivative(const TSequenceSet *ss); -extern void tnumber_set_span(const Temporal *temp, Span *span); -extern Datum temporal_start_value(const Temporal *temp); -extern TInstant *tnumberinst_abs(const TInstant *inst); -extern TSequence *tnumberseq_abs(const TSequence *seq); -extern TSequenceSet *tnumberseqset_abs(const TSequenceSet *ss); -extern TSequence *tnumberseq_angular_difference(const TSequence *seq); -extern TSequence *tnumberseqset_angular_difference(const TSequenceSet *ss); -extern TSequence *tnumberseq_delta_value(const TSequence *seq); -extern TSequenceSet *tnumberseqset_delta_value(const TSequenceSet *ss); -extern SpanSet *tnumberinst_valuespans(const TInstant *inst); -extern SpanSet *tnumberseq_valuespans(const TSequence *seq); -extern SpanSet *tnumberseqset_valuespans(const TSequenceSet *ss); +/* extern void temporal_set_tstzspan(const Temporal *temp, Span *s); (repeated) */ +/* extern const TSequence **temporal_seqs(const Temporal *temp, int *count); (repeated) */ +extern Datum temporal_start_value (const Temporal *temp); +extern Datum *temporal_vals(const Temporal *temp, int *count); +extern Datum *temporal_values(const Temporal *temp, int *count); extern uint32 tinstant_hash(const TInstant *inst); -extern const TInstant **tinstant_instants(const TInstant *inst, int *count); +extern const TInstant **tinstant_insts(const TInstant *inst, int *count); extern void tinstant_set_bbox(const TInstant *inst, void *box); +/* extern void tinstant_set_tstzspan(const TInstant *inst, Span *s); (repeated) */ extern SpanSet *tinstant_time(const TInstant *inst); extern TimestampTz *tinstant_timestamps(const TInstant *inst, int *count); +extern Datum tinstant_val(const TInstant *inst); extern Datum tinstant_value(const TInstant *inst); extern bool tinstant_value_at_timestamptz(const TInstant *inst, TimestampTz t, Datum *result); -extern Datum tinstant_value_copy(const TInstant *inst); -extern Datum *tinstant_values(const TInstant *inst, int *count); +extern Datum *tinstant_vals(const TInstant *inst, int *count); +extern void tnumber_set_span(const Temporal *temp, Span *span); +extern SpanSet *tnumberinst_valuespans(const TInstant *inst); +extern SpanSet *tnumberseq_valuespans(const TSequence *seq); +extern SpanSet *tnumberseqset_valuespans(const TSequenceSet *ss); extern Interval *tsequence_duration(const TSequence *seq); extern TimestampTz tsequence_end_timestamptz(const TSequence *seq); extern uint32 tsequence_hash(const TSequence *seq); -extern const TInstant **tsequence_instants(const TSequence *seq); -extern const TInstant *tsequence_max_instant(const TSequence *seq); -extern Datum tsequence_max_value(const TSequence *seq); -extern const TInstant *tsequence_min_instant(const TSequence *seq); -extern Datum tsequence_min_value(const TSequence *seq); +extern const TInstant **tsequence_insts(const TSequence *seq); +extern const TInstant *tsequence_max_inst(const TSequence *seq); +extern Datum tsequence_max_val(const TSequence *seq); +extern const TInstant *tsequence_min_inst(const TSequence *seq); +extern Datum tsequence_min_val(const TSequence *seq); extern TSequence **tsequence_segments(const TSequence *seq, int *count); -extern TSequence **tsequence_sequences(const TSequence *seq, int *count); +extern const TSequence **tsequence_seqs(const TSequence *seq, int *count); extern void tsequence_set_bbox(const TSequence *seq, void *box); extern void tsequence_expand_bbox(TSequence *seq, const TInstant *inst); -extern void tsequenceset_expand_bbox(TSequenceSet *ss, const TSequence *seq); extern TimestampTz tsequence_start_timestamptz(const TSequence *seq); extern SpanSet *tsequence_time(const TSequence *seq); extern TimestampTz *tsequence_timestamps(const TSequence *seq, int *count); extern bool tsequence_value_at_timestamptz(const TSequence *seq, TimestampTz t, bool strict, Datum *result); -extern Datum *tsequence_values(const TSequence *seq, int *count); +extern Datum *tsequence_vals(const TSequence *seq, int *count); extern Interval *tsequenceset_duration(const TSequenceSet *ss, bool boundspan); extern TimestampTz tsequenceset_end_timestamptz(const TSequenceSet *ss); extern uint32 tsequenceset_hash(const TSequenceSet *ss); extern const TInstant *tsequenceset_inst_n(const TSequenceSet *ss, int n); -extern const TInstant **tsequenceset_instants(const TSequenceSet *ss); -extern const TInstant *tsequenceset_max_instant(const TSequenceSet *ss); -extern Datum tsequenceset_max_value(const TSequenceSet *ss); -extern const TInstant *tsequenceset_min_instant(const TSequenceSet *ss); -extern Datum tsequenceset_min_value(const TSequenceSet *ss); +extern const TInstant **tsequenceset_insts(const TSequenceSet *ss); +extern const TInstant *tsequenceset_max_inst(const TSequenceSet *ss); +extern Datum tsequenceset_max_val(const TSequenceSet *ss); +extern const TInstant *tsequenceset_min_inst(const TSequenceSet *ss); +extern Datum tsequenceset_min_val(const TSequenceSet *ss); extern int tsequenceset_num_instants(const TSequenceSet *ss); extern int tsequenceset_num_timestamps(const TSequenceSet *ss); extern TSequence **tsequenceset_segments(const TSequenceSet *ss, int *count); -extern TSequence **tsequenceset_sequences(const TSequenceSet *ss); -extern const TSequence **tsequenceset_sequences_p(const TSequenceSet *ss); +extern const TSequence **tsequenceset_seqs(const TSequenceSet *ss); extern void tsequenceset_set_bbox(const TSequenceSet *ss, void *box); extern TimestampTz tsequenceset_start_timestamptz(const TSequenceSet *ss); extern SpanSet *tsequenceset_time(const TSequenceSet *ss); @@ -2463,46 +2601,71 @@ extern SpanSet *tsequenceset_time(const TSequenceSet *ss); extern bool tsequenceset_timestamptz_n(const TSequenceSet *ss, int n, TimestampTz *result); extern TimestampTz *tsequenceset_timestamps(const TSequenceSet *ss, int *count); extern bool tsequenceset_value_at_timestamptz(const TSequenceSet *ss, TimestampTz t, bool strict, Datum *result); -extern Datum *tsequenceset_values(const TSequenceSet *ss, int *count); +extern Datum *tsequenceset_vals(const TSequenceSet *ss, int *count); -extern Temporal *tinstant_merge(const TInstant *inst1, const TInstant *inst2); -extern Temporal *tinstant_merge_array(const TInstant **instants, int count); -extern TInstant *tinstant_shift_time(const TInstant *inst, const Interval *interval); +extern Temporal *temporal_compact(const Temporal *temp); +extern void temporal_restart(Temporal *temp, int count); +extern TSequence *temporal_tsequence(const Temporal *temp, interpType interp); +extern TSequenceSet *temporal_tsequenceset(const Temporal *temp, interpType interp); +extern TInstant *tinstant_shift_time(const TInstant *inst, const Interval *interv); extern TSequence *tinstant_to_tsequence(const TInstant *inst, interpType interp); extern TSequenceSet *tinstant_to_tsequenceset(const TInstant *inst, interpType interp); extern Temporal *tnumber_shift_scale_value(const Temporal *temp, Datum shift, Datum width, bool hasshift, bool haswidth); -extern TInstant *tnuminst_shift_value(const TInstant *inst, Datum shift); +extern TInstant *tnumberinst_shift_value(const TInstant *inst, Datum shift); extern TSequence *tnumberseq_shift_scale_value(const TSequence *seq, Datum shift, Datum width, bool hasshift, bool haswidth); -extern Temporal *tsequence_append_tinstant(TSequence *seq, const TInstant *inst, double maxdist, const Interval *maxt, bool expand); -extern Temporal *tsequence_append_tsequence(TSequence *seq1, const TSequence *seq2, bool expand); -extern Temporal *tsequence_merge(const TSequence *seq1, const TSequence *seq2); -extern Temporal *tsequence_merge_array(const TSequence **sequences, int count); +extern TSequenceSet *tnumberseqset_shift_scale_value(const TSequenceSet *ss, Datum start, Datum width, bool hasshift, bool haswidth); +extern TSequence *tsequence_compact(const TSequence *seq); +extern void tsequence_restart(TSequence *seq, int count); extern Temporal *tsequence_set_interp(const TSequence *seq, interpType interp); extern TSequence *tsequence_shift_scale_time(const TSequence *seq, const Interval *shift, const Interval *duration); +extern TSequence *tsequence_subseq(const TSequence *seq, int from, int to, bool lower_inc, bool upper_inc); extern TInstant *tsequence_to_tinstant(const TSequence *seq); -/* extern TSequence *tsequence_to_tdiscseq(const TSequence *seq); (undefined) */ -/* extern TSequence *tsequence_to_tcontseq(const TSequence *seq, interpType interp); (undefined) */ extern TSequenceSet *tsequence_to_tsequenceset(const TSequence *seq); extern TSequenceSet *tsequence_to_tsequenceset_interp(const TSequence *seq, interpType interp); -extern TSequenceSet *tsequenceset_append_tinstant(TSequenceSet *ss, const TInstant *inst, double maxdist, const Interval *maxt, bool expand); -extern TSequenceSet *tsequenceset_append_tsequence(TSequenceSet *ss, const TSequence *seq, bool expand); -extern TSequenceSet *tsequenceset_merge(const TSequenceSet *ss1, const TSequenceSet *ss2); -extern TSequenceSet *tsequenceset_merge_array(const TSequenceSet **seqsets, int count); +extern TSequenceSet *tsequenceset_compact(const TSequenceSet *ss); +extern void tsequenceset_restart(TSequenceSet *ss, int count); extern Temporal *tsequenceset_set_interp(const TSequenceSet *ss, interpType interp); -extern TSequenceSet *tnumberseqset_shift_scale_value(const TSequenceSet *ss, Datum start, Datum width, bool hasshift, bool haswidth); extern TSequenceSet *tsequenceset_shift_scale_time(const TSequenceSet *ss, const Interval *start, const Interval *duration); -extern TInstant *tsequenceset_to_tinstant(const TSequenceSet *ss); extern TSequence *tsequenceset_to_discrete(const TSequenceSet *ss); -extern TSequenceSet *tsequenceset_to_step(const TSequenceSet *ss); extern TSequenceSet *tsequenceset_to_linear(const TSequenceSet *ss); +extern TSequenceSet *tsequenceset_to_step(const TSequenceSet *ss); +extern TInstant *tsequenceset_to_tinstant(const TSequenceSet *ss); extern TSequence *tsequenceset_to_tsequence(const TSequenceSet *ss); +extern Temporal *tinstant_merge(const TInstant *inst1, const TInstant *inst2); +extern Temporal *tinstant_merge_array(const TInstant **instants, int count); +extern Temporal *tsequence_append_tinstant(TSequence *seq, const TInstant *inst, double maxdist, const Interval *maxt, bool expand); +extern Temporal *tsequence_append_tsequence(TSequence *seq1, const TSequence *seq2, bool expand); +extern Temporal *tsequence_delete_timestamptz(const TSequence *seq, TimestampTz t, bool connect); +extern Temporal *tsequence_delete_tstzset(const TSequence *seq, const Set *s, bool connect); +extern Temporal *tsequence_delete_tstzspan(const TSequence *seq, const Span *s, bool connect); +extern Temporal *tsequence_delete_tstzspanset(const TSequence *seq, const SpanSet *ss, bool connect); +extern Temporal *tsequence_insert(const TSequence *seq1, const TSequence *seq2, bool connect); +extern Temporal *tsequence_merge(const TSequence *seq1, const TSequence *seq2); +extern Temporal *tsequence_merge_array(const TSequence **sequences, int count); +extern TSequenceSet *tsequenceset_append_tinstant(TSequenceSet *ss, const TInstant *inst, double maxdist, const Interval *maxt, bool expand); +extern TSequenceSet *tsequenceset_append_tsequence(TSequenceSet *ss, const TSequence *seq, bool expand); +extern TSequenceSet *tsequenceset_delete_timestamptz(const TSequenceSet *ss, TimestampTz t); +extern TSequenceSet *tsequenceset_delete_tstzset(const TSequenceSet *ss, const Set *s); +extern TSequenceSet *tsequenceset_delete_tstzspan(const TSequenceSet *ss, const Span *s); +extern TSequenceSet *tsequenceset_delete_tstzspanset(const TSequenceSet *ss, const SpanSet *ps); +extern TSequenceSet *tsequenceset_insert(const TSequenceSet *ss1, const TSequenceSet *ss2); +extern TSequenceSet *tsequenceset_merge(const TSequenceSet *ss1, const TSequenceSet *ss2); +extern TSequenceSet *tsequenceset_merge_array(const TSequenceSet **seqsets, int count); + +/* extern void tsequence_expand_bbox(TSequence *seq, const TInstant *inst); (repeated) */ +/* extern void tsequence_set_bbox(const TSequence *seq, void *box); (repeated) */ +extern void tsequenceset_expand_bbox(TSequenceSet *ss, const TSequence *seq); +/* extern void tsequenceset_set_bbox(const TSequenceSet *ss, void *box); (repeated) */ + +extern TSequence *tdiscseq_restrict_minmax(const TSequence *seq, bool min, bool atfunc); +extern TSequenceSet *tcontseq_restrict_minmax(const TSequence *seq, bool min, bool atfunc); extern bool temporal_bbox_restrict_set(const Temporal *temp, const Set *set); extern Temporal *temporal_restrict_minmax(const Temporal *temp, bool min, bool atfunc); -extern Temporal *temporal_restrict_tstzspan(const Temporal *temp, const Span *s, bool atfunc); -extern Temporal *temporal_restrict_tstzspanset(const Temporal *temp, const SpanSet *ss, bool atfunc); extern Temporal *temporal_restrict_timestamptz(const Temporal *temp, TimestampTz t, bool atfunc); extern Temporal *temporal_restrict_tstzset(const Temporal *temp, const Set *s, bool atfunc); +extern Temporal *temporal_restrict_tstzspan(const Temporal *temp, const Span *s, bool atfunc); +extern Temporal *temporal_restrict_tstzspanset(const Temporal *temp, const SpanSet *ss, bool atfunc); extern Temporal *temporal_restrict_value(const Temporal *temp, Datum value, bool atfunc); extern Temporal *temporal_restrict_values(const Temporal *temp, const Set *set, bool atfunc); extern bool temporal_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, Datum *result); @@ -2526,15 +2689,9 @@ extern Temporal *tpointseq_restrict_geom_time(const TSequence *seq, const GSERIA extern Temporal *tpointseq_restrict_stbox(const TSequence *seq, const STBox *box, bool border_inc, bool atfunc); extern TSequenceSet *tpointseqset_restrict_geom_time(const TSequenceSet *ss, const GSERIALIZED *gs, const Span *zspan, const Span *period, bool atfunc); extern TSequenceSet *tpointseqset_restrict_stbox(const TSequenceSet *ss, const STBox *box, bool border_inc, bool atfunc); -extern TSequence *tsequence_at_tstzspan(const TSequence *seq, const Span *s); extern TInstant *tsequence_at_timestamptz(const TSequence *seq, TimestampTz t); -/* extern TSequenceSet *tsequence_restrict_minmax(const TSequence *seq, bool min, bool atfunc); (undefined) */ extern Temporal *tsequence_restrict_tstzspan(const TSequence *seq, const Span *s, bool atfunc); extern Temporal *tsequence_restrict_tstzspanset(const TSequence *seq, const SpanSet *ss, bool atfunc); -/* extern TInstant *tsequence_restrict_timestamptz(const TSequence *seq, TimestampTz t, bool atfunc); (undefined) */ -/* extern TSequence *tsequence_restrict_tstzset(const TSequence *seq, const Set *s, bool atfunc); (undefined) */ -/* extern TSequenceSet *tsequence_restrict_value(const TSequence *seq, Datum value, bool atfunc); (undefined) */ -/* extern TSequenceSet *tsequence_restrict_values(const TSequence *seq, const Set *s, bool atfunc); (undefined) */ extern TSequenceSet *tsequenceset_restrict_minmax(const TSequenceSet *ss, bool min, bool atfunc); extern TSequenceSet *tsequenceset_restrict_tstzspan(const TSequenceSet *ss, const Span *s, bool atfunc); extern TSequenceSet *tsequenceset_restrict_tstzspanset(const TSequenceSet *ss, const SpanSet *ps, bool atfunc); @@ -2543,43 +2700,6 @@ extern Temporal *tsequenceset_restrict_tstzset(const TSequenceSet *ss, const Set extern TSequenceSet *tsequenceset_restrict_value(const TSequenceSet *ss, Datum value, bool atfunc); extern TSequenceSet *tsequenceset_restrict_values(const TSequenceSet *ss, const Set *s, bool atfunc); -/* extern TSequence *tnumberseq_derivative(const TSequence *seq); (undefined) */ -/* extern TSequenceSet *tnumberseqset_derivative(const TSequenceSet *ss); (undefined) */ - -extern Temporal *distance_tnumber_number(const Temporal *temp, Datum value, meosType valuetype, meosType restype); -extern double nad_tnumber_number(const Temporal *temp, Datum value, meosType basetype); - -extern bool temporal_always_eq(const Temporal *temp, Datum value); -extern bool temporal_always_le(const Temporal *temp, Datum value); -extern bool temporal_always_lt(const Temporal *temp, Datum value); -extern bool temporal_ever_eq(const Temporal *temp, Datum value); -extern bool temporal_ever_le(const Temporal *temp, Datum value); -extern bool temporal_ever_lt(const Temporal *temp, Datum value); -extern bool tinstant_always_eq(const TInstant *inst, Datum value); -extern bool tinstant_always_le(const TInstant *inst, Datum value); -extern bool tinstant_always_lt(const TInstant *inst, Datum value); -extern bool tinstant_ever_eq(const TInstant *inst, Datum value); -extern bool tinstant_ever_le(const TInstant *inst, Datum value); -extern bool tinstant_ever_lt(const TInstant *inst, Datum value); -extern bool tpointinst_always_eq(const TInstant *inst, Datum value); -extern bool tpointinst_ever_eq(const TInstant *inst, Datum value); -extern bool tpointseq_always_eq(const TSequence *seq, Datum value); -extern bool tpointseq_ever_eq(const TSequence *seq, Datum value); -extern bool tpointseqset_always_eq(const TSequenceSet *ss, Datum value); -extern bool tpointseqset_ever_eq(const TSequenceSet *ss, Datum value); -extern bool tsequence_always_eq(const TSequence *seq, Datum value); -extern bool tsequence_always_le(const TSequence *seq, Datum value); -extern bool tsequence_always_lt(const TSequence *seq, Datum value); -extern bool tsequence_ever_eq(const TSequence *seq, Datum value); -extern bool tsequence_ever_le(const TSequence *seq, Datum value); -extern bool tsequence_ever_lt(const TSequence *seq, Datum value); -extern bool tsequenceset_always_eq(const TSequenceSet *ss, Datum value); -extern bool tsequenceset_always_le(const TSequenceSet *ss, Datum value); -extern bool tsequenceset_always_lt(const TSequenceSet *ss, Datum value); -extern bool tsequenceset_ever_eq(const TSequenceSet *ss, Datum value); -extern bool tsequenceset_ever_le(const TSequenceSet *ss, Datum value); -extern bool tsequenceset_ever_lt(const TSequenceSet *ss, Datum value); - extern int tinstant_cmp(const TInstant *inst1, const TInstant *inst2); extern bool tinstant_eq(const TInstant *inst1, const TInstant *inst2); extern int tsequence_cmp(const TSequence *seq1, const TSequence *seq2); @@ -2587,6 +2707,89 @@ extern bool tsequence_eq(const TSequence *seq1, const TSequence *seq2); extern int tsequenceset_cmp(const TSequenceSet *ss1, const TSequenceSet *ss2); extern bool tsequenceset_eq(const TSequenceSet *ss1, const TSequenceSet *ss2); +extern int always_eq_base_temporal(Datum value, const Temporal *temp); +extern int always_eq_temporal_base(const Temporal *temp, Datum value); +/* extern int always_eq_tinstant_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int always_eq_tpointinst_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int always_eq_tpointseq_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int always_eq_tpointseqset_base(const TSequenceSet *ss, Datum value); (undefined) */ +/* extern int always_eq_tsequence_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int always_eq_tsequenceset_base(const TSequenceSet *ss, Datum value); (undefined) */ +extern int always_ne_base_temporal(Datum value, const Temporal *temp); +extern int always_ne_temporal_base(const Temporal *temp, Datum value); +/* extern int always_ne_tinstant_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int always_ne_tpointinst_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int always_ne_tpointseq_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int always_ne_tpointseqset_base(const TSequenceSet *ss, Datum value); (undefined) */ +/* extern int always_ne_tsequence_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int always_ne_tsequenceset_base(const TSequenceSet *ss, Datum value); (undefined) */ +extern int always_ge_base_temporal(Datum value, const Temporal *temp); +extern int always_ge_temporal_base(const Temporal *temp, Datum value); +/* extern int always_ge_tinstant_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int always_ge_tsequence_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int always_ge_tsequenceset_base(const TSequenceSet *ss, Datum value); (undefined) */ +extern int always_gt_base_temporal(Datum value, const Temporal *temp); +extern int always_gt_temporal_base(const Temporal *temp, Datum value); +/* extern int always_gt_tinstant_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int always_gt_tsequence_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int always_gt_tsequenceset_base(const TSequenceSet *ss, Datum value); (undefined) */ +extern int always_le_base_temporal(Datum value, const Temporal *temp); +extern int always_le_temporal_base(const Temporal *temp, Datum value); +/* extern int always_le_tinstant_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int always_le_tsequence_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int always_le_tsequenceset_base(const TSequenceSet *ss, Datum value); (undefined) */ +extern int always_lt_base_temporal(Datum value, const Temporal *temp); +extern int always_lt_temporal_base(const Temporal *temp, Datum value); +/* extern int always_lt_tinstant_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int always_lt_tsequence_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int always_lt_tsequenceset_base(const TSequenceSet *ss, Datum value); (undefined) */ +extern int ever_eq_base_temporal(Datum value, const Temporal *temp); +extern int ever_eq_temporal_base(const Temporal *temp, Datum value); +/* extern int ever_eq_tinstant_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int ever_eq_tpointinst_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int ever_eq_tpointseq_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int ever_eq_tpointseqset_base(const TSequenceSet *ss, Datum value); (undefined) */ +/* extern int ever_eq_tsequence_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int ever_eq_tsequenceset_base(const TSequenceSet *ss, Datum value); (undefined) */ +extern int ever_ne_base_temporal(Datum value, const Temporal *temp); +extern int ever_ne_temporal_base(const Temporal *temp, Datum value); +/* extern int ever_ne_tinstant_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int ever_ne_tpointinst_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int ever_ne_tpointseq_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int ever_ne_tpointseqset_base(const TSequenceSet *ss, Datum value); (undefined) */ +/* extern int ever_ne_tsequence_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int ever_ne_tsequenceset_base(const TSequenceSet *ss, Datum value); (undefined) */ +extern int ever_ge_base_temporal(Datum value, const Temporal *temp); +extern int ever_ge_temporal_base(const Temporal *temp, Datum value); +/* extern int ever_ge_tinstant_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int ever_ge_tsequence_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int ever_ge_tsequenceset_base(const TSequenceSet *ss, Datum value); (undefined) */ +extern int ever_gt_base_temporal(Datum value, const Temporal *temp); +extern int ever_gt_temporal_base(const Temporal *temp, Datum value); +/* extern int ever_gt_tinstant_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int ever_gt_tsequence_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int ever_gt_tsequenceset_base(const TSequenceSet *ss, Datum value); (undefined) */ +extern int ever_le_base_temporal(Datum value, const Temporal *temp); +extern int ever_le_temporal_base(const Temporal *temp, Datum value); +/* extern int ever_le_tinstant_base(const TInstant *inst, Datum value); (undefined) */ +/* extern int ever_le_tsequence_base(const TSequence *seq, Datum value); (undefined) */ +/* extern int ever_le_tsequenceset_base(const TSequenceSet *ss, Datum value); (undefined) */ +extern int ever_lt_base_temporal(Datum value, const Temporal *temp); +extern int ever_lt_temporal_base(const Temporal *temp, Datum value); + +extern TSequence *tfloatseq_derivative(const TSequence *seq); +extern TSequenceSet *tfloatseqset_derivative(const TSequenceSet *ss); +extern TInstant *tnumberinst_abs(const TInstant *inst); +extern TSequence *tnumberseq_abs(const TSequence *seq); +extern TSequence *tnumberseq_angular_difference(const TSequence *seq); +extern TSequence *tnumberseq_delta_value(const TSequence *seq); +extern TSequenceSet *tnumberseqset_abs(const TSequenceSet *ss); +extern TSequence *tnumberseqset_angular_difference(const TSequenceSet *ss); +extern TSequenceSet *tnumberseqset_delta_value(const TSequenceSet *ss); + +extern Temporal *distance_tnumber_number(const Temporal *temp, Datum value, meosType valuetype, meosType restype); +extern double nad_tnumber_number(const Temporal *temp, Datum value, meosType basetype); + extern int tpointinst_srid(const TInstant *inst); extern GSERIALIZED *tpointseq_trajectory(const TSequence *seq); extern TSequenceSet *tpointseq_azimuth(const TSequence *seq); @@ -2616,17 +2819,6 @@ extern TSequence *tpointseq_set_srid(const TSequence *seq, int32 srid); extern TSequence **tpointseqset_make_simple(const TSequenceSet *ss, int *count); extern TSequenceSet *tpointseqset_set_srid(const TSequenceSet *ss, int32 srid); -extern Temporal *tsequence_insert(const TSequence *seq1, const TSequence *seq2, bool connect); -extern TSequenceSet *tsequenceset_insert(const TSequenceSet *ss1, const TSequenceSet *ss2); -extern Temporal *tsequence_delete_timestamptz(const TSequence *seq, TimestampTz t, bool connect); -extern Temporal *tsequence_delete_tstzset(const TSequence *seq, const Set *s, bool connect); -extern Temporal *tsequence_delete_tstzspan(const TSequence *seq, const Span *s, bool connect); -extern Temporal *tsequence_delete_tstzspanset(const TSequence *seq, const SpanSet *ss, bool connect); -extern TSequenceSet *tsequenceset_delete_timestamptz(const TSequenceSet *ss, TimestampTz t); -extern TSequenceSet *tsequenceset_delete_tstzset(const TSequenceSet *ss, const Set *s); -extern TSequenceSet *tsequenceset_delete_tstzspan(const TSequenceSet *ss, const Span *s); -extern TSequenceSet *tsequenceset_delete_tstzspanset(const TSequenceSet *ss, const SpanSet *ps); - extern double tnumberseq_integral(const TSequence *seq); extern double tnumberseq_twavg(const TSequence *seq); extern double tnumberseqset_integral(const TSequenceSet *ss); @@ -2634,35 +2826,24 @@ extern double tnumberseqset_twavg(const TSequenceSet *ss); extern GSERIALIZED *tpointseq_twcentroid(const TSequence *seq); extern GSERIALIZED *tpointseqset_twcentroid(const TSequenceSet *ss); -extern Temporal *temporal_compact(const Temporal *temp); +/* extern Temporal *temporal_compact(const Temporal *temp); (repeated) */ /* extern TSequence *tsequence_compact(const TSequence *seq); (repeated) */ /* extern TSequenceSet *tsequenceset_compact(const TSequenceSet *ss); (repeated) */ -/* extern SkipList *tbool_tand_transfn(SkipList *state, const Temporal *temp); (repeated) */ -/* extern SkipList *tbool_tor_transfn(SkipList *state, const Temporal *temp); (repeated) */ -/* extern Temporal *temporal_tagg_finalfn(SkipList *state); (repeated) */ -/* extern SkipList *temporal_tcount_transfn(SkipList *state, const Temporal *temp); (repeated) */ -/* extern SkipList *tfloat_tmax_transfn(SkipList *state, const Temporal *temp); (repeated) */ -/* extern SkipList *tfloat_tmin_transfn(SkipList *state, const Temporal *temp); (repeated) */ -/* extern SkipList *tfloat_tsum_transfn(SkipList *state, const Temporal *temp); (repeated) */ -extern SkipList *tfloat_wmax_transfn(SkipList *state, const Temporal *temp, const Interval *interval); -extern SkipList *tfloat_wmin_transfn(SkipList *state, const Temporal *temp, const Interval *interval); -extern SkipList *tfloat_wsum_transfn(SkipList *state, const Temporal *temp, const Interval *interval); -/* extern SkipList *tint_tmin_transfn(SkipList *state, const Temporal *temp); (repeated) */ -/* extern SkipList *tint_tmax_transfn(SkipList *state, const Temporal *temp); (repeated) */ -/* extern SkipList *tint_tsum_transfn(SkipList *state, const Temporal *temp); (repeated) */ -extern SkipList *tint_wmax_transfn(SkipList *state, const Temporal *temp, const Interval *interval); -extern SkipList *tint_wmin_transfn(SkipList *state, const Temporal *temp, const Interval *interval); -extern SkipList *tint_wsum_transfn(SkipList *state, const Temporal *temp, const Interval *interval); -/* extern Temporal *tnumber_tavg_finalfn(SkipList *state); (repeated) */ -/* extern SkipList *tnumber_tavg_transfn(SkipList *state, const Temporal *temp); (repeated) */ -extern SkipList *tnumber_wavg_transfn(SkipList *state, const Temporal *temp, const Interval *interval); -/* extern SkipList *ttext_tmin_transfn(SkipList *state, const Temporal *temp); (repeated) */ -/* extern SkipList *ttext_tmax_transfn(SkipList *state, const Temporal *temp); (repeated) */ - -extern Temporal **tnumber_value_split(const Temporal *temp, Datum size, - Datum origin, Datum **buckets, int *count); +extern void skiplist_free(SkipList *list); +extern Temporal *temporal_app_tinst_transfn(Temporal *state, const TInstant *inst, double maxdist, Interval *maxt); +extern Temporal *temporal_app_tseq_transfn(Temporal *state, const TSequence *seq); +/* extern double tnumberseq_integral(const TSequence *seq); (repeated) */ +/* extern double tnumberseq_twavg(const TSequence *seq); (repeated) */ +/* extern double tnumberseqset_integral(const TSequenceSet *ss); (repeated) */ +/* extern double tnumberseqset_twavg(const TSequenceSet *ss); (repeated) */ +/* extern GSERIALIZED *tpointseq_twcentroid(const TSequence *seq); (repeated) */ +/* extern GSERIALIZED *tpointseqset_twcentroid(const TSequenceSet *ss); (repeated) */ + +extern Temporal **tnumber_value_split(const Temporal *temp, Datum size, Datum origin, Datum **buckets, int *count); +extern TBox *tbox_tile(Datum value, TimestampTz t, Datum vsize, Interval *duration, Datum vorigin, TimestampTz torigin, meosType basetype); + extern "Python" void py_error_handler(int, int, char*); \ No newline at end of file diff --git a/pymeos_cffi/pymeos_cffi/builder/templates/functions.py b/pymeos_cffi/pymeos_cffi/builder/templates/functions.py index 20e61107..9e2cbef2 100644 --- a/pymeos_cffi/pymeos_cffi/builder/templates/functions.py +++ b/pymeos_cffi/pymeos_cffi/builder/templates/functions.py @@ -108,7 +108,7 @@ def geography_to_gserialized(geom: BaseGeometry) -> "GSERIALIZED *": def gserialized_to_shapely_point( geom: "const GSERIALIZED *", precision: int = 15 ) -> spg.Point: - text = gserialized_as_text(geom, precision) + text = geo_as_text(geom, precision) geometry = wkt.loads(text) srid = lwgeom_get_srid(geom) if srid > 0: @@ -119,7 +119,7 @@ def gserialized_to_shapely_point( def gserialized_to_shapely_geometry( geom: "const GSERIALIZED *", precision: int = 15 ) -> BaseGeometry: - text = gserialized_as_text(geom, precision) + text = geo_as_text(geom, precision) geometry = wkt.loads(text) srid = lwgeom_get_srid(geom) if srid > 0: diff --git a/pymeos_cffi/pymeos_cffi/functions.py b/pymeos_cffi/pymeos_cffi/functions.py index 548a1cb0..4434204f 100644 --- a/pymeos_cffi/pymeos_cffi/functions.py +++ b/pymeos_cffi/pymeos_cffi/functions.py @@ -108,7 +108,7 @@ def geography_to_gserialized(geom: BaseGeometry) -> "GSERIALIZED *": def gserialized_to_shapely_point( geom: "const GSERIALIZED *", precision: int = 15 ) -> spg.Point: - text = gserialized_as_text(geom, precision) + text = geo_as_text(geom, precision) geometry = wkt.loads(text) srid = lwgeom_get_srid(geom) if srid > 0: @@ -119,7 +119,7 @@ def gserialized_to_shapely_point( def gserialized_to_shapely_geometry( geom: "const GSERIALIZED *", precision: int = 15 ) -> BaseGeometry: - text = gserialized_as_text(geom, precision) + text = geo_as_text(geom, precision) geometry = wkt.loads(text) srid = lwgeom_get_srid(geom) if srid > 0: @@ -142,112 +142,114 @@ def as_tsequenceset(temporal: "Temporal *") -> "TSequenceSet *": # ----------------------------------------------------------------------------- # ----------------------End of manually-defined functions---------------------- # ----------------------------------------------------------------------------- -def lwpoint_make(srid: 'int32_t', hasz: int, hasm: int, p: 'const POINT4D *') -> 'LWPOINT *': - srid_converted = _ffi.cast('int32_t', srid) - p_converted = _ffi.cast('const POINT4D *', p) +def lwpoint_make( + srid: "int32_t", hasz: int, hasm: int, p: "const POINT4D *" +) -> "LWPOINT *": + srid_converted = _ffi.cast("int32_t", srid) + p_converted = _ffi.cast("const POINT4D *", p) result = _lib.lwpoint_make(srid_converted, hasz, hasm, p_converted) _check_error() return result if result != _ffi.NULL else None -def lwgeom_from_gserialized(g: 'const GSERIALIZED *') -> 'LWGEOM *': - g_converted = _ffi.cast('const GSERIALIZED *', g) +def lwgeom_from_gserialized(g: "const GSERIALIZED *") -> "LWGEOM *": + g_converted = _ffi.cast("const GSERIALIZED *", g) result = _lib.lwgeom_from_gserialized(g_converted) _check_error() return result if result != _ffi.NULL else None -def gserialized_from_lwgeom(geom: 'LWGEOM *') -> 'GSERIALIZED *': - geom_converted = _ffi.cast('LWGEOM *', geom) +def geo_from_lwgeom(geom: "LWGEOM *") -> "GSERIALIZED *": + geom_converted = _ffi.cast("LWGEOM *", geom) size_converted = _ffi.NULL - result = _lib.gserialized_from_lwgeom(geom_converted, size_converted) + result = _lib.geo_from_lwgeom(geom_converted, size_converted) _check_error() return result if result != _ffi.NULL else None -def lwgeom_get_srid(geom: 'const LWGEOM *') -> 'int32_t': - geom_converted = _ffi.cast('const LWGEOM *', geom) +def lwgeom_get_srid(geom: "const LWGEOM *") -> "int32_t": + geom_converted = _ffi.cast("const LWGEOM *", geom) result = _lib.lwgeom_get_srid(geom_converted) _check_error() return result if result != _ffi.NULL else None -def lwpoint_get_x(point: 'const LWPOINT *') -> 'double': - point_converted = _ffi.cast('const LWPOINT *', point) +def lwpoint_get_x(point: "const LWPOINT *") -> "double": + point_converted = _ffi.cast("const LWPOINT *", point) result = _lib.lwpoint_get_x(point_converted) _check_error() return result if result != _ffi.NULL else None -def lwpoint_get_y(point: 'const LWPOINT *') -> 'double': - point_converted = _ffi.cast('const LWPOINT *', point) +def lwpoint_get_y(point: "const LWPOINT *") -> "double": + point_converted = _ffi.cast("const LWPOINT *", point) result = _lib.lwpoint_get_y(point_converted) _check_error() return result if result != _ffi.NULL else None -def lwpoint_get_z(point: 'const LWPOINT *') -> 'double': - point_converted = _ffi.cast('const LWPOINT *', point) +def lwpoint_get_z(point: "const LWPOINT *") -> "double": + point_converted = _ffi.cast("const LWPOINT *", point) result = _lib.lwpoint_get_z(point_converted) _check_error() return result if result != _ffi.NULL else None -def lwpoint_get_m(point: 'const LWPOINT *') -> 'double': - point_converted = _ffi.cast('const LWPOINT *', point) +def lwpoint_get_m(point: "const LWPOINT *") -> "double": + point_converted = _ffi.cast("const LWPOINT *", point) result = _lib.lwpoint_get_m(point_converted) _check_error() return result if result != _ffi.NULL else None -def lwgeom_has_z(geom: 'const LWGEOM *') -> 'int': - geom_converted = _ffi.cast('const LWGEOM *', geom) +def lwgeom_has_z(geom: "const LWGEOM *") -> "int": + geom_converted = _ffi.cast("const LWGEOM *", geom) result = _lib.lwgeom_has_z(geom_converted) _check_error() return result if result != _ffi.NULL else None -def lwgeom_has_m(geom: 'const LWGEOM *') -> 'int': - geom_converted = _ffi.cast('const LWGEOM *', geom) +def lwgeom_has_m(geom: "const LWGEOM *") -> "int": + geom_converted = _ffi.cast("const LWGEOM *", geom) result = _lib.lwgeom_has_m(geom_converted) _check_error() return result if result != _ffi.NULL else None -def meos_errno() -> 'int': +def meos_errno() -> "int": result = _lib.meos_errno() _check_error() return result if result != _ffi.NULL else None -def meos_errno_set(err: int) -> 'int': +def meos_errno_set(err: int) -> "int": result = _lib.meos_errno_set(err) _check_error() return result if result != _ffi.NULL else None -def meos_errno_restore(err: int) -> 'int': +def meos_errno_restore(err: int) -> "int": result = _lib.meos_errno_restore(err) _check_error() return result if result != _ffi.NULL else None -def meos_errno_reset() -> 'int': +def meos_errno_reset() -> "int": result = _lib.meos_errno_reset() _check_error() return result if result != _ffi.NULL else None -def meos_set_datestyle(newval: str, extra: 'void *') -> 'bool': - newval_converted = newval.encode('utf-8') - extra_converted = _ffi.cast('void *', extra) +def meos_set_datestyle(newval: str, extra: "void *") -> "bool": + newval_converted = newval.encode("utf-8") + extra_converted = _ffi.cast("void *", extra) result = _lib.meos_set_datestyle(newval_converted, extra_converted) _check_error() return result if result != _ffi.NULL else None -def meos_set_intervalstyle(newval: str, extra: 'Optional[int]') -> 'bool': - newval_converted = newval.encode('utf-8') +def meos_set_intervalstyle(newval: str, extra: "Optional[int]") -> "bool": + newval_converted = newval.encode("utf-8") extra_converted = extra if extra is not None else _ffi.NULL result = _lib.meos_set_intervalstyle(newval_converted, extra_converted) _check_error() @@ -257,19 +259,19 @@ def meos_set_intervalstyle(newval: str, extra: 'Optional[int]') -> 'bool': def meos_get_datestyle() -> str: result = _lib.meos_get_datestyle() _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None def meos_get_intervalstyle() -> str: result = _lib.meos_get_intervalstyle() _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None def meos_initialize(tz_str: "Optional[str]") -> None: - tz_str_converted = tz_str.encode('utf-8') if tz_str is not None else _ffi.NULL + tz_str_converted = tz_str.encode("utf-8") if tz_str is not None else _ffi.NULL _lib.meos_initialize(tz_str_converted, _lib.py_error_handler) @@ -278,1015 +280,1093 @@ def meos_finalize() -> None: _check_error() -def bool_in(in_str: str) -> 'bool': - in_str_converted = in_str.encode('utf-8') - result = _lib.bool_in(in_str_converted) +def add_date_int(d: "DateADT", days: int) -> "DateADT": + d_converted = _ffi.cast("DateADT", d) + days_converted = _ffi.cast("int32", days) + result = _lib.add_date_int(d_converted, days_converted) _check_error() return result if result != _ffi.NULL else None -def bool_out(b: bool) -> str: - result = _lib.bool_out(b) - _check_error() - result = _ffi.string(result).decode('utf-8') - return result if result != _ffi.NULL else None - - -def cstring2text(cstring: str) -> 'text *': - cstring_converted = cstring.encode('utf-8') - result = _lib.cstring2text(cstring_converted) - return result - - -def pg_date_in(string: str) -> 'DateADT': - string_converted = string.encode('utf-8') - result = _lib.pg_date_in(string_converted) +def add_interval_interval( + interv1: "const Interval *", interv2: "const Interval *" +) -> "Interval *": + interv1_converted = _ffi.cast("const Interval *", interv1) + interv2_converted = _ffi.cast("const Interval *", interv2) + result = _lib.add_interval_interval(interv1_converted, interv2_converted) _check_error() return result if result != _ffi.NULL else None -def pg_date_out(d: 'DateADT') -> str: - d_converted = _ffi.cast('DateADT', d) - result = _lib.pg_date_out(d_converted) +def add_timestamptz_interval(t: int, interv: "const Interval *") -> "TimestampTz": + t_converted = _ffi.cast("TimestampTz", t) + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.add_timestamptz_interval(t_converted, interv_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def pg_date_mi(d1: 'DateADT', d2: 'DateADT') -> 'Interval *': - d1_converted = _ffi.cast('DateADT', d1) - d2_converted = _ffi.cast('DateADT', d2) - result = _lib.pg_date_mi(d1_converted, d2_converted) +def bool_in(string: str) -> "bool": + string_converted = string.encode("utf-8") + result = _lib.bool_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def pg_date_mi_int(d: 'DateADT', days: int) -> 'DateADT': - d_converted = _ffi.cast('DateADT', d) - days_converted = _ffi.cast('int32', days) - result = _lib.pg_date_mi_int(d_converted, days_converted) +def bool_out(b: bool) -> str: + result = _lib.bool_out(b) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def pg_date_pl_int(d: 'DateADT', days: int) -> 'DateADT': - d_converted = _ffi.cast('DateADT', d) - days_converted = _ffi.cast('int32', days) - result = _lib.pg_date_pl_int(d_converted, days_converted) - _check_error() - return result if result != _ffi.NULL else None +def cstring2text(cstring: str) -> "text *": + cstring_converted = cstring.encode("utf-8") + result = _lib.cstring2text(cstring_converted) + return result -def pg_date_timestamptz(d: 'DateADT') -> 'TimestampTz': - d_converted = _ffi.cast('DateADT', d) - result = _lib.pg_date_timestamptz(d_converted) +def date_to_timestamptz(d: "DateADT") -> "TimestampTz": + d_converted = _ffi.cast("DateADT", d) + result = _lib.date_to_timestamptz(d_converted) _check_error() return result if result != _ffi.NULL else None -def pg_interval_cmp(interval1: 'const Interval *', interval2: 'const Interval *') -> 'int': - interval1_converted = _ffi.cast('const Interval *', interval1) - interval2_converted = _ffi.cast('const Interval *', interval2) - result = _lib.pg_interval_cmp(interval1_converted, interval2_converted) +def minus_date_date(d1: "DateADT", d2: "DateADT") -> "Interval *": + d1_converted = _ffi.cast("DateADT", d1) + d2_converted = _ffi.cast("DateADT", d2) + result = _lib.minus_date_date(d1_converted, d2_converted) _check_error() return result if result != _ffi.NULL else None -def pg_interval_in(string: str, typmod: int) -> 'Interval *': - string_converted = string.encode('utf-8') - typmod_converted = _ffi.cast('int32', typmod) - result = _lib.pg_interval_in(string_converted, typmod_converted) +def minus_date_int(d: "DateADT", days: int) -> "DateADT": + d_converted = _ffi.cast("DateADT", d) + days_converted = _ffi.cast("int32", days) + result = _lib.minus_date_int(d_converted, days_converted) _check_error() return result if result != _ffi.NULL else None -def pg_interval_make(years: int, months: int, weeks: int, days: int, hours: int, mins: int, secs: float) -> 'Interval *': - years_converted = _ffi.cast('int32', years) - months_converted = _ffi.cast('int32', months) - weeks_converted = _ffi.cast('int32', weeks) - days_converted = _ffi.cast('int32', days) - hours_converted = _ffi.cast('int32', hours) - mins_converted = _ffi.cast('int32', mins) - result = _lib.pg_interval_make(years_converted, months_converted, weeks_converted, days_converted, hours_converted, mins_converted, secs) +def minus_timestamptz_interval(t: int, interv: "const Interval *") -> "TimestampTz": + t_converted = _ffi.cast("TimestampTz", t) + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.minus_timestamptz_interval(t_converted, interv_converted) _check_error() return result if result != _ffi.NULL else None -def pg_interval_mul(span: 'const Interval *', factor: float) -> 'Interval *': - span_converted = _ffi.cast('const Interval *', span) - result = _lib.pg_interval_mul(span_converted, factor) +def minus_timestamptz_timestamptz(t1: int, t2: int) -> "Interval *": + t1_converted = _ffi.cast("TimestampTz", t1) + t2_converted = _ffi.cast("TimestampTz", t2) + result = _lib.minus_timestamptz_timestamptz(t1_converted, t2_converted) _check_error() return result if result != _ffi.NULL else None -def pg_interval_out(span: 'const Interval *') -> str: - span_converted = _ffi.cast('const Interval *', span) - result = _lib.pg_interval_out(span_converted) +def mult_interval_double(interv: "const Interval *", factor: float) -> "Interval *": + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.mult_interval_double(interv_converted, factor) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def pg_interval_to_char(it: 'Interval *', fmt: str) -> str: - it_converted = _ffi.cast('Interval *', it) - fmt_converted = cstring2text(fmt) - result = _lib.pg_interval_to_char(it_converted, fmt_converted) +def pg_date_in(string: str) -> "DateADT": + string_converted = string.encode("utf-8") + result = _lib.pg_date_in(string_converted) _check_error() - result = text2cstring(result) return result if result != _ffi.NULL else None -def pg_interval_pl(span1: 'const Interval *', span2: 'const Interval *') -> 'Interval *': - span1_converted = _ffi.cast('const Interval *', span1) - span2_converted = _ffi.cast('const Interval *', span2) - result = _lib.pg_interval_pl(span1_converted, span2_converted) +def pg_date_out(d: "DateADT") -> str: + d_converted = _ffi.cast("DateADT", d) + result = _lib.pg_date_out(d_converted) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def pg_time_in(string: str, typmod: int) -> 'TimeADT': - string_converted = string.encode('utf-8') - typmod_converted = _ffi.cast('int32', typmod) - result = _lib.pg_time_in(string_converted, typmod_converted) +def pg_interval_cmp(interv1: "const Interval *", interv2: "const Interval *") -> "int": + interv1_converted = _ffi.cast("const Interval *", interv1) + interv2_converted = _ffi.cast("const Interval *", interv2) + result = _lib.pg_interval_cmp(interv1_converted, interv2_converted) _check_error() return result if result != _ffi.NULL else None -def pg_time_out(time: 'TimeADT') -> str: - time_converted = _ffi.cast('TimeADT', time) - result = _lib.pg_time_out(time_converted) +def pg_interval_in(string: str, typmod: int) -> "Interval *": + string_converted = string.encode("utf-8") + typmod_converted = _ffi.cast("int32", typmod) + result = _lib.pg_interval_in(string_converted, typmod_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def pg_timestamp_in(string: str, typmod: int) -> 'Timestamp': - string_converted = string.encode('utf-8') - typmod_converted = _ffi.cast('int32', typmod) - result = _lib.pg_timestamp_in(string_converted, typmod_converted) +def pg_interval_make( + years: int, months: int, weeks: int, days: int, hours: int, mins: int, secs: float +) -> "Interval *": + years_converted = _ffi.cast("int32", years) + months_converted = _ffi.cast("int32", months) + weeks_converted = _ffi.cast("int32", weeks) + days_converted = _ffi.cast("int32", days) + hours_converted = _ffi.cast("int32", hours) + mins_converted = _ffi.cast("int32", mins) + result = _lib.pg_interval_make( + years_converted, + months_converted, + weeks_converted, + days_converted, + hours_converted, + mins_converted, + secs, + ) _check_error() return result if result != _ffi.NULL else None -def pg_timestamp_mi(dt1: int, dt2: int) -> 'Interval *': - dt1_converted = _ffi.cast('TimestampTz', dt1) - dt2_converted = _ffi.cast('TimestampTz', dt2) - result = _lib.pg_timestamp_mi(dt1_converted, dt2_converted) +def pg_interval_out(interv: "const Interval *") -> str: + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.pg_interval_out(interv_converted) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def pg_timestamp_mi_interval(timestamp: int, span: 'const Interval *') -> 'TimestampTz': - timestamp_converted = _ffi.cast('TimestampTz', timestamp) - span_converted = _ffi.cast('const Interval *', span) - result = _lib.pg_timestamp_mi_interval(timestamp_converted, span_converted) +def pg_time_in(string: str, typmod: int) -> "TimeADT": + string_converted = string.encode("utf-8") + typmod_converted = _ffi.cast("int32", typmod) + result = _lib.pg_time_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def pg_timestamp_out(dt: int) -> str: - dt_converted = _ffi.cast('Timestamp', dt) - result = _lib.pg_timestamp_out(dt_converted) +def pg_time_out(t: "TimeADT") -> str: + t_converted = _ffi.cast("TimeADT", t) + result = _lib.pg_time_out(t_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def pg_timestamp_pl_interval(timestamp: int, span: 'const Interval *') -> 'TimestampTz': - timestamp_converted = _ffi.cast('TimestampTz', timestamp) - span_converted = _ffi.cast('const Interval *', span) - result = _lib.pg_timestamp_pl_interval(timestamp_converted, span_converted) +def pg_timestamp_in(string: str, typmod: int) -> "Timestamp": + string_converted = string.encode("utf-8") + typmod_converted = _ffi.cast("int32", typmod) + result = _lib.pg_timestamp_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def pg_timestamp_to_char(dt: int, fmt: str) -> str: - dt_converted = _ffi.cast('Timestamp', dt) - fmt_converted = cstring2text(fmt) - result = _lib.pg_timestamp_to_char(dt_converted, fmt_converted) +def pg_timestamp_out(t: int) -> str: + t_converted = _ffi.cast("Timestamp", t) + result = _lib.pg_timestamp_out(t_converted) _check_error() - result = text2cstring(result) + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def pg_timestamptz_in(string: str, typmod: int) -> 'TimestampTz': - string_converted = string.encode('utf-8') - typmod_converted = _ffi.cast('int32', typmod) +def pg_timestamptz_in(string: str, typmod: int) -> "TimestampTz": + string_converted = string.encode("utf-8") + typmod_converted = _ffi.cast("int32", typmod) result = _lib.pg_timestamptz_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def pg_timestamptz_date(t: int) -> 'DateADT': - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.pg_timestamptz_date(t_converted) +def pg_timestamptz_out(t: int) -> str: + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.pg_timestamptz_out(t_converted) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def pg_timestamptz_out(dt: int) -> str: - dt_converted = _ffi.cast('TimestampTz', dt) - result = _lib.pg_timestamptz_out(dt_converted) - _check_error() - result = _ffi.string(result).decode('utf-8') - return result if result != _ffi.NULL else None +def text2cstring(textptr: "text *") -> str: + result = _lib.text2cstring(textptr) + result = _ffi.string(result).decode("utf-8") + return result -def pg_timestamptz_to_char(dt: int, fmt: str) -> str: - dt_converted = _ffi.cast('TimestampTz', dt) - fmt_converted = cstring2text(fmt) - result = _lib.pg_timestamptz_to_char(dt_converted, fmt_converted) +def text_cmp(txt1: str, txt2: str) -> "int": + txt1_converted = cstring2text(txt1) + txt2_converted = cstring2text(txt2) + result = _lib.text_cmp(txt1_converted, txt2_converted) _check_error() - result = text2cstring(result) return result if result != _ffi.NULL else None -def pg_to_date(date_txt: str, fmt: str) -> 'DateADT': - date_txt_converted = cstring2text(date_txt) - fmt_converted = cstring2text(fmt) - result = _lib.pg_to_date(date_txt_converted, fmt_converted) +def text_copy(txt: str) -> str: + txt_converted = cstring2text(txt) + result = _lib.text_copy(txt_converted) _check_error() + result = text2cstring(result) return result if result != _ffi.NULL else None -def pg_to_timestamptz(date_txt: str, fmt: str) -> 'TimestampTz': - date_txt_converted = cstring2text(date_txt) - fmt_converted = cstring2text(fmt) - result = _lib.pg_to_timestamptz(date_txt_converted, fmt_converted) +def text_out(txt: str) -> str: + txt_converted = cstring2text(txt) + result = _lib.text_out(txt_converted) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def text2cstring(textptr: 'text *') -> str: - result = _lib.text2cstring(textptr) - result = _ffi.string(result).decode('utf-8') - return result - - -def text_out(txt: str) -> str: - txt_converted = cstring2text(txt) - result = _lib.text_out(txt_converted) +def timestamptz_to_date(t: int) -> "DateADT": + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.timestamptz_to_date(t_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def geography_from_hexewkb(wkt: str) -> 'GSERIALIZED *': - wkt_converted = wkt.encode('utf-8') - result = _lib.geography_from_hexewkb(wkt_converted) +def geo_as_ewkb(gs: "const GSERIALIZED *", endian: str) -> "bytea *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + endian_converted = endian.encode("utf-8") + result = _lib.geo_as_ewkb(gs_converted, endian_converted) _check_error() return result if result != _ffi.NULL else None -def geography_from_text(wkt: str, srid: int) -> 'GSERIALIZED *': - wkt_converted = wkt.encode('utf-8') - result = _lib.geography_from_text(wkt_converted, srid) +def geo_as_ewkt(gs: "const GSERIALIZED *", precision: int) -> str: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.geo_as_ewkt(gs_converted, precision) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def geometry_from_hexewkb(wkt: str) -> 'GSERIALIZED *': - wkt_converted = wkt.encode('utf-8') - result = _lib.geometry_from_hexewkb(wkt_converted) +def geo_as_geojson( + gs: "const GSERIALIZED *", option: int, precision: int, srs: "Optional[str]" +) -> str: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + srs_converted = srs.encode("utf-8") if srs is not None else _ffi.NULL + result = _lib.geo_as_geojson(gs_converted, option, precision, srs_converted) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def geometry_from_text(wkt: str, srid: int) -> 'GSERIALIZED *': - wkt_converted = wkt.encode('utf-8') - result = _lib.geometry_from_text(wkt_converted, srid) +def geo_as_hexewkb(gs: "const GSERIALIZED *", endian: str) -> str: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + endian_converted = endian.encode("utf-8") + result = _lib.geo_as_hexewkb(gs_converted, endian_converted) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def gserialized_as_ewkb(gs: 'const GSERIALIZED *', type: str) -> 'bytea *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - type_converted = type.encode('utf-8') - result = _lib.gserialized_as_ewkb(gs_converted, type_converted) +def geo_as_text(gs: "const GSERIALIZED *", precision: int) -> str: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.geo_as_text(gs_converted, precision) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def gserialized_as_ewkt(gs: 'const GSERIALIZED *', precision: int) -> str: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.gserialized_as_ewkt(gs_converted, precision) +def geo_from_ewkb(bytea_wkb: "const bytea *", srid: int) -> "GSERIALIZED *": + bytea_wkb_converted = _ffi.cast("const bytea *", bytea_wkb) + srid_converted = _ffi.cast("int32", srid) + result = _lib.geo_from_ewkb(bytea_wkb_converted, srid_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def gserialized_as_geojson(gs: 'const GSERIALIZED *', option: int, precision: int, srs: "Optional[str]") -> str: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - srs_converted = srs.encode('utf-8') if srs is not None else _ffi.NULL - result = _lib.gserialized_as_geojson(gs_converted, option, precision, srs_converted) +def geo_from_geojson(geojson: str) -> "GSERIALIZED *": + geojson_converted = geojson.encode("utf-8") + result = _lib.geo_from_geojson(geojson_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def gserialized_as_hexewkb(gs: 'const GSERIALIZED *', type: str) -> str: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - type_converted = type.encode('utf-8') - result = _lib.gserialized_as_hexewkb(gs_converted, type_converted) +def geo_out(gs: "const GSERIALIZED *") -> str: + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.geo_out(gs_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def gserialized_as_text(gs: 'const GSERIALIZED *', precision: int) -> str: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.gserialized_as_text(gs_converted, precision) +def geo_same(gs1: "const GSERIALIZED *", gs2: "const GSERIALIZED *") -> "bool": + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) + result = _lib.geo_same(gs1_converted, gs2_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def gserialized_from_ewkb(bytea_wkb: 'const bytea *', srid: int) -> 'GSERIALIZED *': - bytea_wkb_converted = _ffi.cast('const bytea *', bytea_wkb) - srid_converted = _ffi.cast('int32', srid) - result = _lib.gserialized_from_ewkb(bytea_wkb_converted, srid_converted) +def geography_from_hexewkb(wkt: str) -> "GSERIALIZED *": + wkt_converted = wkt.encode("utf-8") + result = _lib.geography_from_hexewkb(wkt_converted) _check_error() return result if result != _ffi.NULL else None -def gserialized_from_geojson(geojson: str) -> 'GSERIALIZED *': - geojson_converted = geojson.encode('utf-8') - result = _lib.gserialized_from_geojson(geojson_converted) +def geography_from_text(wkt: str, srid: int) -> "GSERIALIZED *": + wkt_converted = wkt.encode("utf-8") + result = _lib.geography_from_text(wkt_converted, srid) _check_error() return result if result != _ffi.NULL else None -def gserialized_out(gs: 'const GSERIALIZED *') -> str: - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.gserialized_out(gs_converted) +def geometry_from_hexewkb(wkt: str) -> "GSERIALIZED *": + wkt_converted = wkt.encode("utf-8") + result = _lib.geometry_from_hexewkb(wkt_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def pgis_geography_in(input: str, geom_typmod: int) -> 'GSERIALIZED *': - input_converted = input.encode('utf-8') - geom_typmod_converted = _ffi.cast('int32', geom_typmod) - result = _lib.pgis_geography_in(input_converted, geom_typmod_converted) +def geometry_from_text(wkt: str, srid: int) -> "GSERIALIZED *": + wkt_converted = wkt.encode("utf-8") + result = _lib.geometry_from_text(wkt_converted, srid) _check_error() return result if result != _ffi.NULL else None -def pgis_geometry_in(input: str, geom_typmod: int) -> 'GSERIALIZED *': - input_converted = input.encode('utf-8') - geom_typmod_converted = _ffi.cast('int32', geom_typmod) - result = _lib.pgis_geometry_in(input_converted, geom_typmod_converted) +def pgis_geography_in(string: str, geog_typmod: int) -> "GSERIALIZED *": + string_converted = string.encode("utf-8") + geog_typmod_converted = _ffi.cast("int32", geog_typmod) + result = _lib.pgis_geography_in(string_converted, geog_typmod_converted) _check_error() return result if result != _ffi.NULL else None -def pgis_gserialized_same(gs1: 'const GSERIALIZED *', gs2: 'const GSERIALIZED *') -> 'bool': - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) - result = _lib.pgis_gserialized_same(gs1_converted, gs2_converted) +def pgis_geometry_in(string: str, typmod: int) -> "GSERIALIZED *": + string_converted = string.encode("utf-8") + typmod_converted = _ffi.cast("int32", typmod) + result = _lib.pgis_geometry_in(string_converted, typmod_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_in(string: str) -> 'Set *': - string_converted = string.encode('utf-8') +def bigintset_in(string: str) -> "Set *": + string_converted = string.encode("utf-8") result = _lib.bigintset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_out(set: 'const Set *') -> str: - set_converted = _ffi.cast('const Set *', set) +def bigintset_out(set: "const Set *") -> str: + set_converted = _ffi.cast("const Set *", set) result = _lib.bigintset_out(set_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def bigintspan_in(string: str) -> 'Span *': - string_converted = string.encode('utf-8') +def bigintspan_in(string: str) -> "Span *": + string_converted = string.encode("utf-8") result = _lib.bigintspan_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspan_out(s: 'const Span *') -> str: - s_converted = _ffi.cast('const Span *', s) +def bigintspan_out(s: "const Span *") -> str: + s_converted = _ffi.cast("const Span *", s) result = _lib.bigintspan_out(s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def bigintspanset_in(string: str) -> 'SpanSet *': - string_converted = string.encode('utf-8') +def bigintspanset_in(string: str) -> "SpanSet *": + string_converted = string.encode("utf-8") result = _lib.bigintspanset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspanset_out(ss: 'const SpanSet *') -> str: - ss_converted = _ffi.cast('const SpanSet *', ss) +def bigintspanset_out(ss: "const SpanSet *") -> str: + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.bigintspanset_out(ss_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def dateset_in(string: str) -> 'Set *': - string_converted = string.encode('utf-8') +def dateset_in(string: str) -> "Set *": + string_converted = string.encode("utf-8") result = _lib.dateset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def dateset_out(s: 'const Set *') -> str: - s_converted = _ffi.cast('const Set *', s) +def dateset_out(s: "const Set *") -> str: + s_converted = _ffi.cast("const Set *", s) result = _lib.dateset_out(s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def datespan_in(string: str) -> 'Span *': - string_converted = string.encode('utf-8') +def datespan_in(string: str) -> "Span *": + string_converted = string.encode("utf-8") result = _lib.datespan_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def datespan_out(s: 'const Span *') -> str: - s_converted = _ffi.cast('const Span *', s) +def datespan_out(s: "const Span *") -> str: + s_converted = _ffi.cast("const Span *", s) result = _lib.datespan_out(s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def datespanset_in(string: str) -> 'SpanSet *': - string_converted = string.encode('utf-8') +def datespanset_in(string: str) -> "SpanSet *": + string_converted = string.encode("utf-8") result = _lib.datespanset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def datespanset_out(ss: 'const SpanSet *') -> str: - ss_converted = _ffi.cast('const SpanSet *', ss) +def datespanset_out(ss: "const SpanSet *") -> str: + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.datespanset_out(ss_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def floatset_in(string: str) -> 'Set *': - string_converted = string.encode('utf-8') +def floatset_in(string: str) -> "Set *": + string_converted = string.encode("utf-8") result = _lib.floatset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def floatset_out(set: 'const Set *', maxdd: int) -> str: - set_converted = _ffi.cast('const Set *', set) +def floatset_out(set: "const Set *", maxdd: int) -> str: + set_converted = _ffi.cast("const Set *", set) result = _lib.floatset_out(set_converted, maxdd) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def floatspan_in(string: str) -> 'Span *': - string_converted = string.encode('utf-8') +def floatspan_in(string: str) -> "Span *": + string_converted = string.encode("utf-8") result = _lib.floatspan_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_out(s: 'const Span *', maxdd: int) -> str: - s_converted = _ffi.cast('const Span *', s) +def floatspan_out(s: "const Span *", maxdd: int) -> str: + s_converted = _ffi.cast("const Span *", s) result = _lib.floatspan_out(s_converted, maxdd) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def floatspanset_in(string: str) -> 'SpanSet *': - string_converted = string.encode('utf-8') +def floatspanset_in(string: str) -> "SpanSet *": + string_converted = string.encode("utf-8") result = _lib.floatspanset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_out(ss: 'const SpanSet *', maxdd: int) -> str: - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspanset_out(ss: "const SpanSet *", maxdd: int) -> str: + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.floatspanset_out(ss_converted, maxdd) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def geogset_in(string: str) -> 'Set *': - string_converted = string.encode('utf-8') +def geogset_in(string: str) -> "Set *": + string_converted = string.encode("utf-8") result = _lib.geogset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def geomset_in(string: str) -> 'Set *': - string_converted = string.encode('utf-8') +def geomset_in(string: str) -> "Set *": + string_converted = string.encode("utf-8") result = _lib.geomset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_as_ewkt(set: 'const Set *', maxdd: int) -> str: - set_converted = _ffi.cast('const Set *', set) +def geoset_as_ewkt(set: "const Set *", maxdd: int) -> str: + set_converted = _ffi.cast("const Set *", set) result = _lib.geoset_as_ewkt(set_converted, maxdd) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def geoset_as_text(set: 'const Set *', maxdd: int) -> str: - set_converted = _ffi.cast('const Set *', set) +def geoset_as_text(set: "const Set *", maxdd: int) -> str: + set_converted = _ffi.cast("const Set *", set) result = _lib.geoset_as_text(set_converted, maxdd) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def geoset_out(set: 'const Set *', maxdd: int) -> str: - set_converted = _ffi.cast('const Set *', set) +def geoset_out(set: "const Set *", maxdd: int) -> str: + set_converted = _ffi.cast("const Set *", set) result = _lib.geoset_out(set_converted, maxdd) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def intset_in(string: str) -> 'Set *': - string_converted = string.encode('utf-8') +def intset_in(string: str) -> "Set *": + string_converted = string.encode("utf-8") result = _lib.intset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def intset_out(set: 'const Set *') -> str: - set_converted = _ffi.cast('const Set *', set) +def intset_out(set: "const Set *") -> str: + set_converted = _ffi.cast("const Set *", set) result = _lib.intset_out(set_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def intspan_in(string: str) -> 'Span *': - string_converted = string.encode('utf-8') +def intspan_in(string: str) -> "Span *": + string_converted = string.encode("utf-8") result = _lib.intspan_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def intspan_out(s: 'const Span *') -> str: - s_converted = _ffi.cast('const Span *', s) +def intspan_out(s: "const Span *") -> str: + s_converted = _ffi.cast("const Span *", s) result = _lib.intspan_out(s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def intspanset_in(string: str) -> 'SpanSet *': - string_converted = string.encode('utf-8') +def intspanset_in(string: str) -> "SpanSet *": + string_converted = string.encode("utf-8") result = _lib.intspanset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def intspanset_out(ss: 'const SpanSet *') -> str: - ss_converted = _ffi.cast('const SpanSet *', ss) +def intspanset_out(ss: "const SpanSet *") -> str: + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.intspanset_out(ss_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def set_as_hexwkb(s: 'const Set *', variant: int) -> "Tuple[str, 'size_t *']": - s_converted = _ffi.cast('const Set *', s) - variant_converted = _ffi.cast('uint8_t', variant) - size_out = _ffi.new('size_t *') +def set_as_hexwkb(s: "const Set *", variant: int) -> "Tuple[str, 'size_t *']": + s_converted = _ffi.cast("const Set *", s) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") result = _lib.set_as_hexwkb(s_converted, variant_converted, size_out) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None, size_out[0] -def set_as_wkb(s: 'const Set *', variant: int) -> bytes: - s_converted = _ffi.cast('const Set *', s) - variant_converted = _ffi.cast('uint8_t', variant) - size_out = _ffi.new('size_t *') +def set_as_wkb(s: "const Set *", variant: int) -> bytes: + s_converted = _ffi.cast("const Set *", s) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") result = _lib.set_as_wkb(s_converted, variant_converted, size_out) _check_error() - result_converted = bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None + result_converted = ( + bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None + ) return result_converted -def set_from_hexwkb(hexwkb: str) -> 'Set *': - hexwkb_converted = hexwkb.encode('utf-8') +def set_from_hexwkb(hexwkb: str) -> "Set *": + hexwkb_converted = hexwkb.encode("utf-8") result = _lib.set_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def set_from_wkb(wkb: bytes) -> 'Set *': - wkb_converted = _ffi.new('uint8_t []', wkb) +def set_from_wkb(wkb: bytes) -> "Set *": + wkb_converted = _ffi.new("uint8_t []", wkb) result = _lib.set_from_wkb(wkb_converted, len(wkb)) return result if result != _ffi.NULL else None -def span_as_hexwkb(s: 'const Span *', variant: int) -> "Tuple[str, 'size_t *']": - s_converted = _ffi.cast('const Span *', s) - variant_converted = _ffi.cast('uint8_t', variant) - size_out = _ffi.new('size_t *') +def span_as_hexwkb(s: "const Span *", variant: int) -> "Tuple[str, 'size_t *']": + s_converted = _ffi.cast("const Span *", s) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") result = _lib.span_as_hexwkb(s_converted, variant_converted, size_out) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None, size_out[0] -def span_as_wkb(s: 'const Span *', variant: int) -> bytes: - s_converted = _ffi.cast('const Span *', s) - variant_converted = _ffi.cast('uint8_t', variant) - size_out = _ffi.new('size_t *') +def span_as_wkb(s: "const Span *", variant: int) -> bytes: + s_converted = _ffi.cast("const Span *", s) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") result = _lib.span_as_wkb(s_converted, variant_converted, size_out) _check_error() - result_converted = bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None + result_converted = ( + bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None + ) return result_converted -def span_from_hexwkb(hexwkb: str) -> 'Span *': - hexwkb_converted = hexwkb.encode('utf-8') +def span_from_hexwkb(hexwkb: str) -> "Span *": + hexwkb_converted = hexwkb.encode("utf-8") result = _lib.span_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def span_from_wkb(wkb: bytes) -> 'Span *': - wkb_converted = _ffi.new('uint8_t []', wkb) +def span_from_wkb(wkb: bytes) -> "Span *": + wkb_converted = _ffi.new("uint8_t []", wkb) result = _lib.span_from_wkb(wkb_converted, len(wkb)) return result if result != _ffi.NULL else None -def spanset_as_hexwkb(ss: 'const SpanSet *', variant: int) -> "Tuple[str, 'size_t *']": - ss_converted = _ffi.cast('const SpanSet *', ss) - variant_converted = _ffi.cast('uint8_t', variant) - size_out = _ffi.new('size_t *') +def spanset_as_hexwkb(ss: "const SpanSet *", variant: int) -> "Tuple[str, 'size_t *']": + ss_converted = _ffi.cast("const SpanSet *", ss) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") result = _lib.spanset_as_hexwkb(ss_converted, variant_converted, size_out) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None, size_out[0] -def spanset_as_wkb(ss: 'const SpanSet *', variant: int) -> bytes: - ss_converted = _ffi.cast('const SpanSet *', ss) - variant_converted = _ffi.cast('uint8_t', variant) - size_out = _ffi.new('size_t *') +def spanset_as_wkb(ss: "const SpanSet *", variant: int) -> bytes: + ss_converted = _ffi.cast("const SpanSet *", ss) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") result = _lib.spanset_as_wkb(ss_converted, variant_converted, size_out) _check_error() - result_converted = bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None + result_converted = ( + bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None + ) return result_converted -def spanset_from_hexwkb(hexwkb: str) -> 'SpanSet *': - hexwkb_converted = hexwkb.encode('utf-8') +def spanset_from_hexwkb(hexwkb: str) -> "SpanSet *": + hexwkb_converted = hexwkb.encode("utf-8") result = _lib.spanset_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_from_wkb(wkb: bytes) -> 'SpanSet *': - wkb_converted = _ffi.new('uint8_t []', wkb) +def spanset_from_wkb(wkb: bytes) -> "SpanSet *": + wkb_converted = _ffi.new("uint8_t []", wkb) result = _lib.spanset_from_wkb(wkb_converted, len(wkb)) return result if result != _ffi.NULL else None -def textset_in(string: str) -> 'Set *': - string_converted = string.encode('utf-8') +def textset_in(string: str) -> "Set *": + string_converted = string.encode("utf-8") result = _lib.textset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def textset_out(set: 'const Set *') -> str: - set_converted = _ffi.cast('const Set *', set) +def textset_out(set: "const Set *") -> str: + set_converted = _ffi.cast("const Set *", set) result = _lib.textset_out(set_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tstzset_in(string: str) -> 'Set *': - string_converted = string.encode('utf-8') +def tstzset_in(string: str) -> "Set *": + string_converted = string.encode("utf-8") result = _lib.tstzset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_out(set: 'const Set *') -> str: - set_converted = _ffi.cast('const Set *', set) +def tstzset_out(set: "const Set *") -> str: + set_converted = _ffi.cast("const Set *", set) result = _lib.tstzset_out(set_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tstzspan_in(string: str) -> 'Span *': - string_converted = string.encode('utf-8') +def tstzspan_in(string: str) -> "Span *": + string_converted = string.encode("utf-8") result = _lib.tstzspan_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_out(s: 'const Span *') -> str: - s_converted = _ffi.cast('const Span *', s) +def tstzspan_out(s: "const Span *") -> str: + s_converted = _ffi.cast("const Span *", s) result = _lib.tstzspan_out(s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tstzspanset_in(string: str) -> 'SpanSet *': - string_converted = string.encode('utf-8') +def tstzspanset_in(string: str) -> "SpanSet *": + string_converted = string.encode("utf-8") result = _lib.tstzspanset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_out(ss: 'const SpanSet *') -> str: - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_out(ss: "const SpanSet *") -> str: + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tstzspanset_out(ss_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def bigintset_make(values: 'List[const int64]') -> 'Set *': - values_converted = _ffi.new('const int64 []', values) +def bigintset_make(values: "List[const int64]") -> "Set *": + values_converted = _ffi.new("const int64 []", values) result = _lib.bigintset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None -def bigintspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> 'Span *': - lower_converted = _ffi.cast('int64', lower) - upper_converted = _ffi.cast('int64', upper) - result = _lib.bigintspan_make(lower_converted, upper_converted, lower_inc, upper_inc) +def bigintspan_make( + lower: int, upper: int, lower_inc: bool, upper_inc: bool +) -> "Span *": + lower_converted = _ffi.cast("int64", lower) + upper_converted = _ffi.cast("int64", upper) + result = _lib.bigintspan_make( + lower_converted, upper_converted, lower_inc, upper_inc + ) _check_error() return result if result != _ffi.NULL else None -def dateset_make(values: 'List[const DateADT]') -> 'Set *': - values_converted = _ffi.new('const DateADT []', values) +def dateset_make(values: "List[const DateADT]") -> "Set *": + values_converted = _ffi.new("const DateADT []", values) result = _lib.dateset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None -def datespan_make(lower: 'DateADT', upper: 'DateADT', lower_inc: bool, upper_inc: bool) -> 'Span *': - lower_converted = _ffi.cast('DateADT', lower) - upper_converted = _ffi.cast('DateADT', upper) +def datespan_make( + lower: "DateADT", upper: "DateADT", lower_inc: bool, upper_inc: bool +) -> "Span *": + lower_converted = _ffi.cast("DateADT", lower) + upper_converted = _ffi.cast("DateADT", upper) result = _lib.datespan_make(lower_converted, upper_converted, lower_inc, upper_inc) _check_error() return result if result != _ffi.NULL else None -def floatset_make(values: 'List[const double]') -> 'Set *': - values_converted = _ffi.new('const double []', values) +def floatset_make(values: "List[const double]") -> "Set *": + values_converted = _ffi.new("const double []", values) result = _lib.floatset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None -def floatspan_make(lower: float, upper: float, lower_inc: bool, upper_inc: bool) -> 'Span *': +def floatspan_make( + lower: float, upper: float, lower_inc: bool, upper_inc: bool +) -> "Span *": result = _lib.floatspan_make(lower, upper, lower_inc, upper_inc) _check_error() return result if result != _ffi.NULL else None -def geoset_make(values: 'const GSERIALIZED **') -> 'Set *': - values_converted = [_ffi.cast('const GSERIALIZED *', x) for x in values] +def geoset_make(values: "const GSERIALIZED **") -> "Set *": + values_converted = [_ffi.cast("const GSERIALIZED *", x) for x in values] result = _lib.geoset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None -def intset_make(values: 'List[const int]') -> 'Set *': - values_converted = _ffi.new('const int []', values) +def intset_make(values: "List[const int]") -> "Set *": + values_converted = _ffi.new("const int []", values) result = _lib.intset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None -def intspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> 'Span *': +def intspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> "Span *": result = _lib.intspan_make(lower, upper, lower_inc, upper_inc) _check_error() return result if result != _ffi.NULL else None -def set_copy(s: 'const Set *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) +def set_copy(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) result = _lib.set_copy(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_copy(s: 'const Span *') -> 'Span *': - s_converted = _ffi.cast('const Span *', s) +def span_copy(s: "const Span *") -> "Span *": + s_converted = _ffi.cast("const Span *", s) result = _lib.span_copy(s_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_copy(ss: 'const SpanSet *') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_copy(ss: "const SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.spanset_copy(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_make(spans: 'List[Span *]', normalize: bool) -> 'SpanSet *': - spans_converted = _ffi.new('Span []', spans) - result = _lib.spanset_make(spans_converted, len(spans), normalize) +def spanset_make(spans: "List[Span *]", normalize: bool, ordered: bool) -> "SpanSet *": + spans_converted = _ffi.new("Span []", spans) + result = _lib.spanset_make(spans_converted, len(spans), normalize, ordered) _check_error() return result if result != _ffi.NULL else None -def textset_make(values: List[str]) -> 'Set *': +def textset_make(values: List[str]) -> "Set *": values_converted = [cstring2text(x) for x in values] result = _lib.textset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None -def tstzset_make(values: List[int]) -> 'Set *': - values_converted = [_ffi.cast('const TimestampTz', x) for x in values] +def tstzset_make(values: List[int]) -> "Set *": + values_converted = [_ffi.cast("const TimestampTz", x) for x in values] result = _lib.tstzset_make(values_converted, len(values)) _check_error() return result if result != _ffi.NULL else None -def tstzspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> 'Span *': - lower_converted = _ffi.cast('TimestampTz', lower) - upper_converted = _ffi.cast('TimestampTz', upper) +def tstzspan_make(lower: int, upper: int, lower_inc: bool, upper_inc: bool) -> "Span *": + lower_converted = _ffi.cast("TimestampTz", lower) + upper_converted = _ffi.cast("TimestampTz", upper) result = _lib.tstzspan_make(lower_converted, upper_converted, lower_inc, upper_inc) _check_error() return result if result != _ffi.NULL else None -def bigint_to_set(i: int) -> 'Set *': - i_converted = _ffi.cast('int64', i) +def bigint_to_set(i: int) -> "Set *": + i_converted = _ffi.cast("int64", i) result = _lib.bigint_to_set(i_converted) _check_error() return result if result != _ffi.NULL else None -def bigint_to_span(i: int) -> 'Span *': +def bigint_to_span(i: int) -> "Span *": result = _lib.bigint_to_span(i) _check_error() return result if result != _ffi.NULL else None -def bigint_to_spanset(i: int) -> 'SpanSet *': +def bigint_to_spanset(i: int) -> "SpanSet *": result = _lib.bigint_to_spanset(i) _check_error() return result if result != _ffi.NULL else None -def date_to_set(d: 'DateADT') -> 'Set *': - d_converted = _ffi.cast('DateADT', d) +def date_to_set(d: "DateADT") -> "Set *": + d_converted = _ffi.cast("DateADT", d) result = _lib.date_to_set(d_converted) _check_error() return result if result != _ffi.NULL else None -def date_to_span(d: 'DateADT') -> 'Span *': - d_converted = _ffi.cast('DateADT', d) +def date_to_span(d: "DateADT") -> "Span *": + d_converted = _ffi.cast("DateADT", d) result = _lib.date_to_span(d_converted) _check_error() return result if result != _ffi.NULL else None -def date_to_spanset(d: 'DateADT') -> 'SpanSet *': - d_converted = _ffi.cast('DateADT', d) +def date_to_spanset(d: "DateADT") -> "SpanSet *": + d_converted = _ffi.cast("DateADT", d) result = _lib.date_to_spanset(d_converted) _check_error() return result if result != _ffi.NULL else None -def date_to_tstzspan(d: 'DateADT') -> 'Span *': - d_converted = _ffi.cast('DateADT', d) - result = _lib.date_to_tstzspan(d_converted) +def dateset_to_tstzset(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.dateset_to_tstzset(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def datespan_to_tstzspan(s: "const Span *") -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.datespan_to_tstzspan(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def datespanset_to_tstzspanset(ss: "const SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.datespanset_to_tstzspanset(ss_converted) _check_error() return result if result != _ffi.NULL else None -def float_to_set(d: float) -> 'Set *': +def float_to_set(d: float) -> "Set *": result = _lib.float_to_set(d) _check_error() return result if result != _ffi.NULL else None -def float_to_span(d: float) -> 'Span *': +def float_to_span(d: float) -> "Span *": result = _lib.float_to_span(d) _check_error() return result if result != _ffi.NULL else None -def float_to_spanset(d: float) -> 'SpanSet *': +def float_to_spanset(d: float) -> "SpanSet *": result = _lib.float_to_spanset(d) _check_error() return result if result != _ffi.NULL else None -def geo_to_set(gs: 'GSERIALIZED *') -> 'Set *': - gs_converted = _ffi.cast('GSERIALIZED *', gs) +def floatset_to_intset(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.floatset_to_intset(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def floatspan_to_intspan(s: "const Span *") -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.floatspan_to_intspan(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def floatspanset_to_intspanset(ss: "const SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.floatspanset_to_intspanset(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def geo_to_set(gs: "GSERIALIZED *") -> "Set *": + gs_converted = _ffi.cast("GSERIALIZED *", gs) result = _lib.geo_to_set(gs_converted) _check_error() return result if result != _ffi.NULL else None -def int_to_set(i: int) -> 'Set *': +def int_to_set(i: int) -> "Set *": result = _lib.int_to_set(i) _check_error() return result if result != _ffi.NULL else None -def int_to_span(i: int) -> 'Span *': +def int_to_span(i: int) -> "Span *": result = _lib.int_to_span(i) _check_error() return result if result != _ffi.NULL else None -def int_to_spanset(i: int) -> 'SpanSet *': +def int_to_spanset(i: int) -> "SpanSet *": result = _lib.int_to_spanset(i) _check_error() return result if result != _ffi.NULL else None -def set_to_spanset(s: 'const Set *') -> 'SpanSet *': - s_converted = _ffi.cast('const Set *', s) +def intset_to_floatset(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.intset_to_floatset(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def intspan_to_floatspan(s: "const Span *") -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.intspan_to_floatspan(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def intspanset_to_floatspanset(ss: "const SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.intspanset_to_floatspanset(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def set_to_spanset(s: "const Set *") -> "SpanSet *": + s_converted = _ffi.cast("const Set *", s) result = _lib.set_to_spanset(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_to_spanset(s: 'const Span *') -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) +def span_to_spanset(s: "const Span *") -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) result = _lib.span_to_spanset(s_converted) _check_error() return result if result != _ffi.NULL else None -def text_to_set(txt: str) -> 'Set *': +def text_to_set(txt: str) -> "Set *": txt_converted = cstring2text(txt) result = _lib.text_to_set(txt_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_to_set(t: int) -> 'Set *': - t_converted = _ffi.cast('TimestampTz', t) +def timestamptz_to_set(t: int) -> "Set *": + t_converted = _ffi.cast("TimestampTz", t) result = _lib.timestamptz_to_set(t_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_to_span(t: int) -> 'Span *': - t_converted = _ffi.cast('TimestampTz', t) +def timestamptz_to_span(t: int) -> "Span *": + t_converted = _ffi.cast("TimestampTz", t) result = _lib.timestamptz_to_span(t_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_to_spanset(t: int) -> 'SpanSet *': - t_converted = _ffi.cast('TimestampTz', t) +def timestamptz_to_spanset(t: int) -> "SpanSet *": + t_converted = _ffi.cast("TimestampTz", t) result = _lib.timestamptz_to_spanset(t_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_end_value(s: 'const Set *') -> 'int64': - s_converted = _ffi.cast('const Set *', s) +def tstzset_to_dateset(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.tstzset_to_dateset(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tstzspan_to_datespan(s: "const Span *") -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.tstzspan_to_datespan(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tstzspanset_to_datespanset(ss: "const SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.tstzspanset_to_datespanset(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def bigintset_end_value(s: "const Set *") -> "int64": + s_converted = _ffi.cast("const Set *", s) result = _lib.bigintset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_start_value(s: 'const Set *') -> 'int64': - s_converted = _ffi.cast('const Set *', s) +def bigintset_start_value(s: "const Set *") -> "int64": + s_converted = _ffi.cast("const Set *", s) result = _lib.bigintset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_value_n(s: 'const Set *', n: int) -> 'int64': - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('int64 *') +def bigintset_value_n(s: "const Set *", n: int) -> "int64": + s_converted = _ffi.cast("const Set *", s) + out_result = _ffi.new("int64 *") result = _lib.bigintset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1294,58 +1374,72 @@ def bigintset_value_n(s: 'const Set *', n: int) -> 'int64': return None -def bigintset_values(s: 'const Set *') -> 'int64 *': - s_converted = _ffi.cast('const Set *', s) +def bigintset_values(s: "const Set *") -> "int64 *": + s_converted = _ffi.cast("const Set *", s) result = _lib.bigintset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspan_lower(s: 'const Span *') -> 'int64': - s_converted = _ffi.cast('const Span *', s) +def bigintspan_lower(s: "const Span *") -> "int64": + s_converted = _ffi.cast("const Span *", s) result = _lib.bigintspan_lower(s_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspan_upper(s: 'const Span *') -> 'int64': - s_converted = _ffi.cast('const Span *', s) +def bigintspan_upper(s: "const Span *") -> "int64": + s_converted = _ffi.cast("const Span *", s) result = _lib.bigintspan_upper(s_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspanset_lower(ss: 'const SpanSet *') -> 'int64': - ss_converted = _ffi.cast('const SpanSet *', ss) +def bigintspan_width(s: "const Span *") -> "int64": + s_converted = _ffi.cast("const Span *", s) + result = _lib.bigintspan_width(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def bigintspanset_lower(ss: "const SpanSet *") -> "int64": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.bigintspanset_lower(ss_converted) _check_error() return result if result != _ffi.NULL else None -def bigintspanset_upper(ss: 'const SpanSet *') -> 'int64': - ss_converted = _ffi.cast('const SpanSet *', ss) +def bigintspanset_upper(ss: "const SpanSet *") -> "int64": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.bigintspanset_upper(ss_converted) _check_error() return result if result != _ffi.NULL else None -def dateset_end_value(s: 'const Set *') -> 'DateADT': - s_converted = _ffi.cast('const Set *', s) +def bigintspanset_width(ss: "const SpanSet *", boundspan: bool) -> "int64": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.bigintspanset_width(ss_converted, boundspan) + _check_error() + return result if result != _ffi.NULL else None + + +def dateset_end_value(s: "const Set *") -> "DateADT": + s_converted = _ffi.cast("const Set *", s) result = _lib.dateset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def dateset_start_value(s: 'const Set *') -> 'DateADT': - s_converted = _ffi.cast('const Set *', s) +def dateset_start_value(s: "const Set *") -> "DateADT": + s_converted = _ffi.cast("const Set *", s) result = _lib.dateset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def dateset_value_n(s: 'const Set *', n: int) -> 'DateADT *': - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('DateADT *') +def dateset_value_n(s: "const Set *", n: int) -> "DateADT *": + s_converted = _ffi.cast("const Set *", s) + out_result = _ffi.new("DateADT *") result = _lib.dateset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1353,97 +1447,97 @@ def dateset_value_n(s: 'const Set *', n: int) -> 'DateADT *': return None -def dateset_values(s: 'const Set *') -> 'DateADT *': - s_converted = _ffi.cast('const Set *', s) +def dateset_values(s: "const Set *") -> "DateADT *": + s_converted = _ffi.cast("const Set *", s) result = _lib.dateset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def datespan_duration(s: 'const Span *') -> 'Interval *': - s_converted = _ffi.cast('const Span *', s) +def datespan_duration(s: "const Span *") -> "Interval *": + s_converted = _ffi.cast("const Span *", s) result = _lib.datespan_duration(s_converted) _check_error() return result if result != _ffi.NULL else None -def datespan_lower(s: 'const Span *') -> 'DateADT': - s_converted = _ffi.cast('const Span *', s) +def datespan_lower(s: "const Span *") -> "DateADT": + s_converted = _ffi.cast("const Span *", s) result = _lib.datespan_lower(s_converted) _check_error() return result if result != _ffi.NULL else None -def datespan_upper(s: 'const Span *') -> 'DateADT': - s_converted = _ffi.cast('const Span *', s) +def datespan_upper(s: "const Span *") -> "DateADT": + s_converted = _ffi.cast("const Span *", s) result = _lib.datespan_upper(s_converted) _check_error() return result if result != _ffi.NULL else None -def datespanset_duration(ss: 'const SpanSet *', boundspan: bool) -> 'Interval *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.datespanset_duration(ss_converted, boundspan) +def datespanset_date_n(ss: "const SpanSet *", n: int) -> "DateADT *": + ss_converted = _ffi.cast("const SpanSet *", ss) + out_result = _ffi.new("DateADT *") + result = _lib.datespanset_date_n(ss_converted, n, out_result) _check_error() - return result if result != _ffi.NULL else None + if result: + return out_result if out_result != _ffi.NULL else None + return None -def datespanset_end_date(ss: 'const SpanSet *') -> 'DateADT': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.datespanset_end_date(ss_converted) +def datespanset_dates(ss: "const SpanSet *") -> "Tuple['DateADT *', 'int']": + ss_converted = _ffi.cast("const SpanSet *", ss) + count = _ffi.new("int *") + result = _lib.datespanset_dates(ss_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def datespanset_num_dates(ss: 'const SpanSet *') -> 'int': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.datespanset_num_dates(ss_converted) +def datespanset_duration(ss: "const SpanSet *", boundspan: bool) -> "Interval *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.datespanset_duration(ss_converted, boundspan) _check_error() return result if result != _ffi.NULL else None -def datespanset_start_date(ss: 'const SpanSet *') -> 'DateADT': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.datespanset_start_date(ss_converted) +def datespanset_end_date(ss: "const SpanSet *") -> "DateADT": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.datespanset_end_date(ss_converted) _check_error() return result if result != _ffi.NULL else None -def datespanset_date_n(ss: 'const SpanSet *', n: int) -> 'DateADT *': - ss_converted = _ffi.cast('const SpanSet *', ss) - out_result = _ffi.new('DateADT *') - result = _lib.datespanset_date_n(ss_converted, n, out_result) +def datespanset_num_dates(ss: "const SpanSet *") -> "int": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.datespanset_num_dates(ss_converted) _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None + return result if result != _ffi.NULL else None -def datespanset_dates(ss: 'const SpanSet *') -> "Tuple['DateADT *', 'int']": - ss_converted = _ffi.cast('const SpanSet *', ss) - count = _ffi.new('int *') - result = _lib.datespanset_dates(ss_converted, count) +def datespanset_start_date(ss: "const SpanSet *") -> "DateADT": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.datespanset_start_date(ss_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def floatset_end_value(s: 'const Set *') -> 'double': - s_converted = _ffi.cast('const Set *', s) +def floatset_end_value(s: "const Set *") -> "double": + s_converted = _ffi.cast("const Set *", s) result = _lib.floatset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatset_start_value(s: 'const Set *') -> 'double': - s_converted = _ffi.cast('const Set *', s) +def floatset_start_value(s: "const Set *") -> "double": + s_converted = _ffi.cast("const Set *", s) result = _lib.floatset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatset_value_n(s: 'const Set *', n: int) -> 'double': - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('double *') +def floatset_value_n(s: "const Set *", n: int) -> "double": + s_converted = _ffi.cast("const Set *", s) + out_result = _ffi.new("double *") result = _lib.floatset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1451,73 +1545,79 @@ def floatset_value_n(s: 'const Set *', n: int) -> 'double': return None -def floatset_values(s: 'const Set *') -> 'double *': - s_converted = _ffi.cast('const Set *', s) +def floatset_values(s: "const Set *") -> "double *": + s_converted = _ffi.cast("const Set *", s) result = _lib.floatset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_lower(s: 'const Span *') -> 'double': - s_converted = _ffi.cast('const Span *', s) +def floatspan_lower(s: "const Span *") -> "double": + s_converted = _ffi.cast("const Span *", s) result = _lib.floatspan_lower(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_upper(s: 'const Span *') -> 'double': - s_converted = _ffi.cast('const Span *', s) +def floatspan_upper(s: "const Span *") -> "double": + s_converted = _ffi.cast("const Span *", s) result = _lib.floatspan_upper(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_lower(ss: 'const SpanSet *') -> 'double': - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspan_width(s: "const Span *") -> "double": + s_converted = _ffi.cast("const Span *", s) + result = _lib.floatspan_width(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def floatspanset_lower(ss: "const SpanSet *") -> "double": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.floatspanset_lower(ss_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_upper(ss: 'const SpanSet *') -> 'double': - ss_converted = _ffi.cast('const SpanSet *', ss) +def floatspanset_upper(ss: "const SpanSet *") -> "double": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.floatspanset_upper(ss_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_end_value(s: 'const Set *') -> 'GSERIALIZED *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.geoset_end_value(s_converted) +def floatspanset_width(ss: "const SpanSet *", boundspan: bool) -> "double": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.floatspanset_width(ss_converted, boundspan) _check_error() return result if result != _ffi.NULL else None -def geoset_srid(s: 'const Set *') -> 'int': - s_converted = _ffi.cast('const Set *', s) - result = _lib.geoset_srid(s_converted) +def geoset_end_value(s: "const Set *") -> "GSERIALIZED *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.geoset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_set_srid(s: 'const Set *', srid: int) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - srid_converted = _ffi.cast('int32', srid) - result = _lib.geoset_set_srid(s_converted, srid_converted) +def geoset_srid(s: "const Set *") -> "int": + s_converted = _ffi.cast("const Set *", s) + result = _lib.geoset_srid(s_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_start_value(s: 'const Set *') -> 'GSERIALIZED *': - s_converted = _ffi.cast('const Set *', s) +def geoset_start_value(s: "const Set *") -> "GSERIALIZED *": + s_converted = _ffi.cast("const Set *", s) result = _lib.geoset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_value_n(s: 'const Set *', n: int) -> 'GSERIALIZED **': - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('GSERIALIZED **') +def geoset_value_n(s: "const Set *", n: int) -> "GSERIALIZED **": + s_converted = _ffi.cast("const Set *", s) + out_result = _ffi.new("GSERIALIZED **") result = _lib.geoset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1525,30 +1625,30 @@ def geoset_value_n(s: 'const Set *', n: int) -> 'GSERIALIZED **': return None -def geoset_values(s: 'const Set *') -> 'GSERIALIZED **': - s_converted = _ffi.cast('const Set *', s) +def geoset_values(s: "const Set *") -> "GSERIALIZED **": + s_converted = _ffi.cast("const Set *", s) result = _lib.geoset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def intset_end_value(s: 'const Set *') -> 'int': - s_converted = _ffi.cast('const Set *', s) +def intset_end_value(s: "const Set *") -> "int": + s_converted = _ffi.cast("const Set *", s) result = _lib.intset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def intset_start_value(s: 'const Set *') -> 'int': - s_converted = _ffi.cast('const Set *', s) +def intset_start_value(s: "const Set *") -> "int": + s_converted = _ffi.cast("const Set *", s) result = _lib.intset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def intset_value_n(s: 'const Set *', n: int) -> 'int': - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('int *') +def intset_value_n(s: "const Set *", n: int) -> "int": + s_converted = _ffi.cast("const Set *", s) + out_result = _ffi.new("int *") result = _lib.intset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1556,210 +1656,203 @@ def intset_value_n(s: 'const Set *', n: int) -> 'int': return None -def intset_values(s: 'const Set *') -> 'int *': - s_converted = _ffi.cast('const Set *', s) +def intset_values(s: "const Set *") -> "int *": + s_converted = _ffi.cast("const Set *", s) result = _lib.intset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def intspan_lower(s: 'const Span *') -> 'int': - s_converted = _ffi.cast('const Span *', s) +def intspan_lower(s: "const Span *") -> "int": + s_converted = _ffi.cast("const Span *", s) result = _lib.intspan_lower(s_converted) _check_error() return result if result != _ffi.NULL else None -def intspan_upper(s: 'const Span *') -> 'int': - s_converted = _ffi.cast('const Span *', s) +def intspan_upper(s: "const Span *") -> "int": + s_converted = _ffi.cast("const Span *", s) result = _lib.intspan_upper(s_converted) _check_error() return result if result != _ffi.NULL else None -def intspanset_lower(ss: 'const SpanSet *') -> 'int': - ss_converted = _ffi.cast('const SpanSet *', ss) +def intspan_width(s: "const Span *") -> "int": + s_converted = _ffi.cast("const Span *", s) + result = _lib.intspan_width(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def intspanset_lower(ss: "const SpanSet *") -> "int": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.intspanset_lower(ss_converted) _check_error() return result if result != _ffi.NULL else None -def intspanset_upper(ss: 'const SpanSet *') -> 'int': - ss_converted = _ffi.cast('const SpanSet *', ss) +def intspanset_upper(ss: "const SpanSet *") -> "int": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.intspanset_upper(ss_converted) _check_error() return result if result != _ffi.NULL else None -def set_hash(s: 'const Set *') -> 'uint32': - s_converted = _ffi.cast('const Set *', s) +def intspanset_width(ss: "const SpanSet *", boundspan: bool) -> "int": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.intspanset_width(ss_converted, boundspan) + _check_error() + return result if result != _ffi.NULL else None + + +def set_hash(s: "const Set *") -> "uint32": + s_converted = _ffi.cast("const Set *", s) result = _lib.set_hash(s_converted) _check_error() return result if result != _ffi.NULL else None -def set_hash_extended(s: 'const Set *', seed: int) -> 'uint64': - s_converted = _ffi.cast('const Set *', s) - seed_converted = _ffi.cast('uint64', seed) +def set_hash_extended(s: "const Set *", seed: int) -> "uint64": + s_converted = _ffi.cast("const Set *", s) + seed_converted = _ffi.cast("uint64", seed) result = _lib.set_hash_extended(s_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def set_num_values(s: 'const Set *') -> 'int': - s_converted = _ffi.cast('const Set *', s) +def set_num_values(s: "const Set *") -> "int": + s_converted = _ffi.cast("const Set *", s) result = _lib.set_num_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def set_to_span(s: 'const Set *') -> 'Span *': - s_converted = _ffi.cast('const Set *', s) +def set_to_span(s: "const Set *") -> "Span *": + s_converted = _ffi.cast("const Set *", s) result = _lib.set_to_span(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_hash(s: 'const Span *') -> 'uint32': - s_converted = _ffi.cast('const Span *', s) +def span_hash(s: "const Span *") -> "uint32": + s_converted = _ffi.cast("const Span *", s) result = _lib.span_hash(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_hash_extended(s: 'const Span *', seed: int) -> 'uint64': - s_converted = _ffi.cast('const Span *', s) - seed_converted = _ffi.cast('uint64', seed) +def span_hash_extended(s: "const Span *", seed: int) -> "uint64": + s_converted = _ffi.cast("const Span *", s) + seed_converted = _ffi.cast("uint64", seed) result = _lib.span_hash_extended(s_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def span_lower_inc(s: 'const Span *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) +def span_lower_inc(s: "const Span *") -> "bool": + s_converted = _ffi.cast("const Span *", s) result = _lib.span_lower_inc(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_upper_inc(s: 'const Span *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) +def span_upper_inc(s: "const Span *") -> "bool": + s_converted = _ffi.cast("const Span *", s) result = _lib.span_upper_inc(s_converted) _check_error() return result if result != _ffi.NULL else None -def span_width(s: 'const Span *') -> 'double': - s_converted = _ffi.cast('const Span *', s) - result = _lib.span_width(s_converted) - _check_error() - return result if result != _ffi.NULL else None - - -def spanset_end_span(ss: 'const SpanSet *') -> 'const Span *': - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_end_span(ss: "const SpanSet *") -> "Span *": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.spanset_end_span(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_hash(ss: 'const SpanSet *') -> 'uint32': - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_hash(ss: "const SpanSet *") -> "uint32": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.spanset_hash(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_hash_extended(ss: 'const SpanSet *', seed: int) -> 'uint64': - ss_converted = _ffi.cast('const SpanSet *', ss) - seed_converted = _ffi.cast('uint64', seed) +def spanset_hash_extended(ss: "const SpanSet *", seed: int) -> "uint64": + ss_converted = _ffi.cast("const SpanSet *", ss) + seed_converted = _ffi.cast("uint64", seed) result = _lib.spanset_hash_extended(ss_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_lower_inc(ss: 'const SpanSet *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_lower_inc(ss: "const SpanSet *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.spanset_lower_inc(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_num_spans(ss: 'const SpanSet *') -> 'int': - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_num_spans(ss: "const SpanSet *") -> "int": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.spanset_num_spans(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_span(ss: 'const SpanSet *') -> 'Span *': - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_span(ss: "const SpanSet *") -> "Span *": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.spanset_span(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_span_n(ss: 'const SpanSet *', i: int) -> 'const Span *': - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_span_n(ss: "const SpanSet *", i: int) -> "Span *": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.spanset_span_n(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def spanset_spans(ss: 'const SpanSet *') -> 'const Span **': - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_spans(ss: "const SpanSet *") -> "Span **": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.spanset_spans(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_start_span(ss: 'const SpanSet *') -> 'const Span *': - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_start_span(ss: "const SpanSet *") -> "Span *": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.spanset_start_span(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_upper_inc(ss: 'const SpanSet *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) +def spanset_upper_inc(ss: "const SpanSet *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.spanset_upper_inc(ss_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_width(ss: 'const SpanSet *', boundspan: bool) -> 'double': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.spanset_width(ss_converted, boundspan) - _check_error() - return result if result != _ffi.NULL else None - - -def spatialset_to_stbox(s: 'const Set *') -> 'STBox *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.spatialset_to_stbox(s_converted) - _check_error() - return result if result != _ffi.NULL else None - - -def textset_end_value(s: 'const Set *') -> str: - s_converted = _ffi.cast('const Set *', s) +def textset_end_value(s: "const Set *") -> str: + s_converted = _ffi.cast("const Set *", s) result = _lib.textset_end_value(s_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def textset_start_value(s: 'const Set *') -> str: - s_converted = _ffi.cast('const Set *', s) +def textset_start_value(s: "const Set *") -> str: + s_converted = _ffi.cast("const Set *", s) result = _lib.textset_start_value(s_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def textset_value_n(s: 'const Set *', n: int) -> 'text **': - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('text **') +def textset_value_n(s: "const Set *", n: int) -> "text **": + s_converted = _ffi.cast("const Set *", s) + out_result = _ffi.new("text **") result = _lib.textset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1767,30 +1860,30 @@ def textset_value_n(s: 'const Set *', n: int) -> 'text **': return None -def textset_values(s: 'const Set *') -> 'text **': - s_converted = _ffi.cast('const Set *', s) +def textset_values(s: "const Set *") -> "text **": + s_converted = _ffi.cast("const Set *", s) result = _lib.textset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_end_value(s: 'const Set *') -> 'TimestampTz': - s_converted = _ffi.cast('const Set *', s) +def tstzset_end_value(s: "const Set *") -> "TimestampTz": + s_converted = _ffi.cast("const Set *", s) result = _lib.tstzset_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_start_value(s: 'const Set *') -> 'TimestampTz': - s_converted = _ffi.cast('const Set *', s) +def tstzset_start_value(s: "const Set *") -> "TimestampTz": + s_converted = _ffi.cast("const Set *", s) result = _lib.tstzset_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_value_n(s: 'const Set *', n: int) -> int: - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('TimestampTz *') +def tstzset_value_n(s: "const Set *", n: int) -> int: + s_converted = _ffi.cast("const Set *", s) + out_result = _ffi.new("TimestampTz *") result = _lib.tstzset_value_n(s_converted, n, out_result) _check_error() if result: @@ -1798,72 +1891,72 @@ def tstzset_value_n(s: 'const Set *', n: int) -> int: return None -def tstzset_values(s: 'const Set *') -> 'TimestampTz *': - s_converted = _ffi.cast('const Set *', s) +def tstzset_values(s: "const Set *") -> "TimestampTz *": + s_converted = _ffi.cast("const Set *", s) result = _lib.tstzset_values(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_duration(s: 'const Span *') -> 'Interval *': - s_converted = _ffi.cast('const Span *', s) +def tstzspan_duration(s: "const Span *") -> "Interval *": + s_converted = _ffi.cast("const Span *", s) result = _lib.tstzspan_duration(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_lower(s: 'const Span *') -> 'TimestampTz': - s_converted = _ffi.cast('const Span *', s) +def tstzspan_lower(s: "const Span *") -> "TimestampTz": + s_converted = _ffi.cast("const Span *", s) result = _lib.tstzspan_lower(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_upper(s: 'const Span *') -> 'TimestampTz': - s_converted = _ffi.cast('const Span *', s) +def tstzspan_upper(s: "const Span *") -> "TimestampTz": + s_converted = _ffi.cast("const Span *", s) result = _lib.tstzspan_upper(s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_duration(ss: 'const SpanSet *', boundspan: bool) -> 'Interval *': - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_duration(ss: "const SpanSet *", boundspan: bool) -> "Interval *": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tstzspanset_duration(ss_converted, boundspan) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_end_timestamptz(ss: 'const SpanSet *') -> 'TimestampTz': - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_end_timestamptz(ss: "const SpanSet *") -> "TimestampTz": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tstzspanset_end_timestamptz(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_lower(ss: 'const SpanSet *') -> 'TimestampTz': - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_lower(ss: "const SpanSet *") -> "TimestampTz": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tstzspanset_lower(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_num_timestamps(ss: 'const SpanSet *') -> 'int': - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_num_timestamps(ss: "const SpanSet *") -> "int": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tstzspanset_num_timestamps(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_start_timestamptz(ss: 'const SpanSet *') -> 'TimestampTz': - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_start_timestamptz(ss: "const SpanSet *") -> "TimestampTz": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tstzspanset_start_timestamptz(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_timestamptz_n(ss: 'const SpanSet *', n: int) -> int: - ss_converted = _ffi.cast('const SpanSet *', ss) - out_result = _ffi.new('TimestampTz *') +def tstzspanset_timestamptz_n(ss: "const SpanSet *", n: int) -> int: + ss_converted = _ffi.cast("const SpanSet *", ss) + out_result = _ffi.new("TimestampTz *") result = _lib.tstzspanset_timestamptz_n(ss_converted, n, out_result) _check_error() if result: @@ -1871,3383 +1964,3779 @@ def tstzspanset_timestamptz_n(ss: 'const SpanSet *', n: int) -> int: return None -def tstzspanset_timestamps(ss: 'const SpanSet *') -> "Tuple['TimestampTz *', 'int']": - ss_converted = _ffi.cast('const SpanSet *', ss) - count = _ffi.new('int *') +def tstzspanset_timestamps(ss: "const SpanSet *") -> "Tuple['TimestampTz *', 'int']": + ss_converted = _ffi.cast("const SpanSet *", ss) + count = _ffi.new("int *") result = _lib.tstzspanset_timestamps(ss_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tstzspanset_upper(ss: 'const SpanSet *') -> 'TimestampTz': - ss_converted = _ffi.cast('const SpanSet *', ss) +def tstzspanset_upper(ss: "const SpanSet *") -> "TimestampTz": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tstzspanset_upper(ss_converted) _check_error() return result if result != _ffi.NULL else None -def bigintset_shift_scale(s: 'const Set *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - shift_converted = _ffi.cast('int64', shift) - width_converted = _ffi.cast('int64', width) - result = _lib.bigintset_shift_scale(s_converted, shift_converted, width_converted, hasshift, haswidth) +def bigintset_shift_scale( + s: "const Set *", shift: int, width: int, hasshift: bool, haswidth: bool +) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + shift_converted = _ffi.cast("int64", shift) + width_converted = _ffi.cast("int64", width) + result = _lib.bigintset_shift_scale( + s_converted, shift_converted, width_converted, hasshift, haswidth + ) _check_error() return result if result != _ffi.NULL else None -def bigintspan_shift_scale(s: 'const Span *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - shift_converted = _ffi.cast('int64', shift) - width_converted = _ffi.cast('int64', width) - result = _lib.bigintspan_shift_scale(s_converted, shift_converted, width_converted, hasshift, haswidth) +def bigintspan_shift_scale( + s: "const Span *", shift: int, width: int, hasshift: bool, haswidth: bool +) -> "Span *": + s_converted = _ffi.cast("const Span *", s) + shift_converted = _ffi.cast("int64", shift) + width_converted = _ffi.cast("int64", width) + result = _lib.bigintspan_shift_scale( + s_converted, shift_converted, width_converted, hasshift, haswidth + ) _check_error() return result if result != _ffi.NULL else None -def bigintspanset_shift_scale(ss: 'const SpanSet *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - shift_converted = _ffi.cast('int64', shift) - width_converted = _ffi.cast('int64', width) - result = _lib.bigintspanset_shift_scale(ss_converted, shift_converted, width_converted, hasshift, haswidth) +def bigintspanset_shift_scale( + ss: "const SpanSet *", shift: int, width: int, hasshift: bool, haswidth: bool +) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + shift_converted = _ffi.cast("int64", shift) + width_converted = _ffi.cast("int64", width) + result = _lib.bigintspanset_shift_scale( + ss_converted, shift_converted, width_converted, hasshift, haswidth + ) _check_error() return result if result != _ffi.NULL else None -def dateset_shift_scale(s: 'const Set *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) +def dateset_shift_scale( + s: "const Set *", shift: int, width: int, hasshift: bool, haswidth: bool +) -> "Set *": + s_converted = _ffi.cast("const Set *", s) result = _lib.dateset_shift_scale(s_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def dateset_to_tstzset(s: 'const Set *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.dateset_to_tstzset(s_converted) +def datespan_shift_scale( + s: "const Span *", shift: int, width: int, hasshift: bool, haswidth: bool +) -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.datespan_shift_scale(s_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def datespan_shift_scale(s: 'const Span *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.datespan_shift_scale(s_converted, shift, width, hasshift, haswidth) +def datespanset_shift_scale( + ss: "const SpanSet *", shift: int, width: int, hasshift: bool, haswidth: bool +) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.datespanset_shift_scale( + ss_converted, shift, width, hasshift, haswidth + ) _check_error() return result if result != _ffi.NULL else None -def datespan_to_tstzspan(s: 'const Span *') -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.datespan_to_tstzspan(s_converted) +def floatset_round(s: "const Set *", maxdd: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.floatset_round(s_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def datespanset_shift_scale(ss: 'const SpanSet *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.datespanset_shift_scale(ss_converted, shift, width, hasshift, haswidth) +def floatset_shift_scale( + s: "const Set *", shift: float, width: float, hasshift: bool, haswidth: bool +) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.floatset_shift_scale(s_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def datespanset_to_tstzspanset(ss: 'const SpanSet *') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.datespanset_to_tstzspanset(ss_converted) +def floatspan_round(s: "const Span *", maxdd: int) -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.floatspan_round(s_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def floatset_round(s: 'const Set *', maxdd: int) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.floatset_round(s_converted, maxdd) +def floatspan_shift_scale( + s: "const Span *", shift: float, width: float, hasshift: bool, haswidth: bool +) -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.floatspan_shift_scale(s_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def floatset_shift_scale(s: 'const Set *', shift: float, width: float, hasshift: bool, haswidth: bool) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.floatset_shift_scale(s_converted, shift, width, hasshift, haswidth) +def floatspanset_round(ss: "const SpanSet *", maxdd: int) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.floatspanset_round(ss_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def floatset_to_intset(s: 'const Set *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.floatset_to_intset(s_converted) +def floatspanset_shift_scale( + ss: "const SpanSet *", shift: float, width: float, hasshift: bool, haswidth: bool +) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.floatspanset_shift_scale( + ss_converted, shift, width, hasshift, haswidth + ) _check_error() return result if result != _ffi.NULL else None -def floatspan_round(s: 'const Span *', maxdd: int) -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.floatspan_round(s_converted, maxdd) +def geoset_round(s: "const Set *", maxdd: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.geoset_round(s_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def floatspan_shift_scale(s: 'const Span *', shift: float, width: float, hasshift: bool, haswidth: bool) -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.floatspan_shift_scale(s_converted, shift, width, hasshift, haswidth) +def geoset_set_srid(s: "const Set *", srid: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + srid_converted = _ffi.cast("int32", srid) + result = _lib.geoset_set_srid(s_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_to_intspan(s: 'const Span *') -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.floatspan_to_intspan(s_converted) +def intset_shift_scale( + s: "const Set *", shift: int, width: int, hasshift: bool, haswidth: bool +) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.intset_shift_scale(s_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def floatspanset_to_intspanset(ss: 'const SpanSet *') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.floatspanset_to_intspanset(ss_converted) +def intspan_shift_scale( + s: "const Span *", shift: int, width: int, hasshift: bool, haswidth: bool +) -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.intspan_shift_scale(s_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def floatspanset_round(ss: 'const SpanSet *', maxdd: int) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.floatspanset_round(ss_converted, maxdd) +def intspanset_shift_scale( + ss: "const SpanSet *", shift: int, width: int, hasshift: bool, haswidth: bool +) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.intspanset_shift_scale(ss_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def floatspanset_shift_scale(ss: 'const SpanSet *', shift: float, width: float, hasshift: bool, haswidth: bool) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.floatspanset_shift_scale(ss_converted, shift, width, hasshift, haswidth) +def textset_lower(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.textset_lower(s_converted) _check_error() return result if result != _ffi.NULL else None -def geoset_round(s: 'const Set *', maxdd: int) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.geoset_round(s_converted, maxdd) +def textset_upper(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.textset_upper(s_converted) _check_error() return result if result != _ffi.NULL else None -def intset_shift_scale(s: 'const Set *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.intset_shift_scale(s_converted, shift, width, hasshift, haswidth) +def timestamptz_tprecision( + t: int, duration: "const Interval *", torigin: int +) -> "TimestampTz": + t_converted = _ffi.cast("TimestampTz", t) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + result = _lib.timestamptz_tprecision( + t_converted, duration_converted, torigin_converted + ) _check_error() return result if result != _ffi.NULL else None -def intset_to_floatset(s: 'const Set *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.intset_to_floatset(s_converted) +def tstzset_shift_scale( + s: "const Set *", + shift: "Optional['const Interval *']", + duration: "Optional['const Interval *']", +) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + shift_converted = ( + _ffi.cast("const Interval *", shift) if shift is not None else _ffi.NULL + ) + duration_converted = ( + _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL + ) + result = _lib.tstzset_shift_scale(s_converted, shift_converted, duration_converted) _check_error() return result if result != _ffi.NULL else None -def intspan_shift_scale(s: 'const Span *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.intspan_shift_scale(s_converted, shift, width, hasshift, haswidth) +def tstzset_tprecision( + s: "const Set *", duration: "const Interval *", torigin: int +) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + result = _lib.tstzset_tprecision(s_converted, duration_converted, torigin_converted) _check_error() return result if result != _ffi.NULL else None -def intspan_to_floatspan(s: 'const Span *') -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.intspan_to_floatspan(s_converted) +def tstzspan_shift_scale( + s: "const Span *", + shift: "Optional['const Interval *']", + duration: "Optional['const Interval *']", +) -> "Span *": + s_converted = _ffi.cast("const Span *", s) + shift_converted = ( + _ffi.cast("const Interval *", shift) if shift is not None else _ffi.NULL + ) + duration_converted = ( + _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL + ) + result = _lib.tstzspan_shift_scale(s_converted, shift_converted, duration_converted) _check_error() return result if result != _ffi.NULL else None -def intspanset_to_floatspanset(ss: 'const SpanSet *') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.intspanset_to_floatspanset(ss_converted) +def tstzspan_tprecision( + s: "const Span *", duration: "const Interval *", torigin: int +) -> "Span *": + s_converted = _ffi.cast("const Span *", s) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + result = _lib.tstzspan_tprecision( + s_converted, duration_converted, torigin_converted + ) _check_error() return result if result != _ffi.NULL else None -def intspanset_shift_scale(ss: 'const SpanSet *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.intspanset_shift_scale(ss_converted, shift, width, hasshift, haswidth) +def tstzspanset_shift_scale( + ss: "const SpanSet *", + shift: "Optional['const Interval *']", + duration: "Optional['const Interval *']", +) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + shift_converted = ( + _ffi.cast("const Interval *", shift) if shift is not None else _ffi.NULL + ) + duration_converted = ( + _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL + ) + result = _lib.tstzspanset_shift_scale( + ss_converted, shift_converted, duration_converted + ) _check_error() return result if result != _ffi.NULL else None -def textset_lower(s: 'const Set *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.textset_lower(s_converted) +def tstzspanset_tprecision( + ss: "const SpanSet *", duration: "const Interval *", torigin: int +) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + duration_converted = _ffi.cast("const Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + result = _lib.tstzspanset_tprecision( + ss_converted, duration_converted, torigin_converted + ) _check_error() return result if result != _ffi.NULL else None -def textset_upper(s: 'const Set *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.textset_upper(s_converted) +def set_cmp(s1: "const Set *", s2: "const Set *") -> "int": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.set_cmp(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_tprecision(t: int, duration: 'const Interval *', torigin: int) -> 'TimestampTz': - t_converted = _ffi.cast('TimestampTz', t) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - result = _lib.timestamptz_tprecision(t_converted, duration_converted, torigin_converted) +def set_eq(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.set_eq(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_shift_scale(s: 'const Set *', shift: "Optional['const Interval *']", duration: "Optional['const Interval *']") -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - shift_converted = _ffi.cast('const Interval *', shift) if shift is not None else _ffi.NULL - duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL - result = _lib.tstzset_shift_scale(s_converted, shift_converted, duration_converted) +def set_ge(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.set_ge(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def datespan_shift_scale(s: 'const Span *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.datespan_shift_scale(s_converted, shift, width, hasshift, haswidth) +def set_gt(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.set_gt(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_shift_scale(s: 'const Span *', shift: "Optional['const Interval *']", duration: "Optional['const Interval *']") -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - shift_converted = _ffi.cast('const Interval *', shift) if shift is not None else _ffi.NULL - duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL - result = _lib.tstzspan_shift_scale(s_converted, shift_converted, duration_converted) +def set_le(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.set_le(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_tprecision(s: 'const Span *', duration: 'const Interval *', torigin: int) -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - result = _lib.tstzspan_tprecision(s_converted, duration_converted, torigin_converted) +def set_lt(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.set_lt(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_to_dateset(s: 'const Set *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.tstzset_to_dateset(s_converted) +def set_ne(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.set_ne(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_to_datespan(s: 'const Span *') -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.tstzspan_to_datespan(s_converted) +def span_cmp(s1: "const Span *", s2: "const Span *") -> "int": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.span_cmp(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_to_datespanset(ss: 'const SpanSet *') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.tstzspanset_to_datespanset(ss_converted) +def span_eq(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.span_eq(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_shift_scale(ss: 'const SpanSet *', shift: "Optional['const Interval *']", duration: "Optional['const Interval *']") -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - shift_converted = _ffi.cast('const Interval *', shift) if shift is not None else _ffi.NULL - duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL - result = _lib.tstzspanset_shift_scale(ss_converted, shift_converted, duration_converted) +def span_ge(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.span_ge(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_tprecision(ss: 'const SpanSet *', duration: 'const Interval *', torigin: int) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - duration_converted = _ffi.cast('const Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - result = _lib.tstzspanset_tprecision(ss_converted, duration_converted, torigin_converted) +def span_gt(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.span_gt(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_bigint(s: 'const Set *', i: int) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.intersection_set_bigint(s_converted, i_converted) +def span_le(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.span_le(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_date(s: 'const Set *', d: 'DateADT') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.intersection_set_date(s_converted, d_converted) +def span_lt(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.span_lt(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_float(s: 'const Set *', d: float) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.intersection_set_float(s_converted, d) +def span_ne(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.span_ne(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_geo(s: 'const Set *', gs: 'const GSERIALIZED *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.intersection_set_geo(s_converted, gs_converted) +def spanset_cmp(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "int": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.spanset_cmp(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_int(s: 'const Set *', i: int) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.intersection_set_int(s_converted, i) +def spanset_eq(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.spanset_eq(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_set(s1: 'const Set *', s2: 'const Set *') -> 'Set *': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.intersection_set_set(s1_converted, s2_converted) +def spanset_ge(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.spanset_ge(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_text(s: 'const Set *', txt: str) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - txt_converted = cstring2text(txt) - result = _lib.intersection_set_text(s_converted, txt_converted) +def spanset_gt(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.spanset_gt(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_set_timestamptz(s: 'const Set *', t: int) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.intersection_set_timestamptz(s_converted, t_converted) +def spanset_le(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.spanset_le(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_span_bigint(s: 'const Span *', i: int) -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.intersection_span_bigint(s_converted, i_converted) +def spanset_lt(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.spanset_lt(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_span_date(s: 'const Span *', d: 'DateADT') -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.intersection_span_date(s_converted, d_converted) +def spanset_ne(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.spanset_ne(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_span_float(s: 'const Span *', d: float) -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.intersection_span_float(s_converted, d) +def adjacent_span_bigint(s: "const Span *", i: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.adjacent_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_span_int(s: 'const Span *', i: int) -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.intersection_span_int(s_converted, i) +def adjacent_span_date(s: "const Span *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.adjacent_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_span_timestamptz(s: 'const Span *', t: int) -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.intersection_span_timestamptz(s_converted, t_converted) +def adjacent_span_float(s: "const Span *", d: float) -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.adjacent_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def intersection_span_span(s1: 'const Span *', s2: 'const Span *') -> 'Span *': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.intersection_span_span(s1_converted, s2_converted) +def adjacent_span_int(s: "const Span *", i: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.adjacent_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) - result = _lib.intersection_spanset_bigint(ss_converted, i_converted) +def adjacent_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.adjacent_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) - result = _lib.intersection_spanset_date(ss_converted, d_converted) +def adjacent_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.adjacent_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_float(ss: 'const SpanSet *', d: float) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.intersection_spanset_float(ss_converted, d) +def adjacent_span_timestamptz(s: "const Span *", t: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.adjacent_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_int(ss: 'const SpanSet *', i: int) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.intersection_spanset_int(ss_converted, i) +def adjacent_spanset_bigint(ss: "const SpanSet *", i: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + i_converted = _ffi.cast("int64", i) + result = _lib.adjacent_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.intersection_spanset_span(ss_converted, s_converted) +def adjacent_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.adjacent_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'SpanSet *': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.intersection_spanset_spanset(ss1_converted, ss2_converted) +def adjacent_spanset_float(ss: "const SpanSet *", d: float) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.adjacent_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.intersection_spanset_timestamptz(ss_converted, t_converted) +def adjacent_spanset_int(ss: "const SpanSet *", i: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.adjacent_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def minus_bigint_set(i: int, s: 'const Set *') -> 'Set *': - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) - result = _lib.minus_bigint_set(i_converted, s_converted) +def adjacent_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.adjacent_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def minus_bigint_span(i: int, s: 'const Span *') -> 'SpanSet *': - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Span *', s) - result = _lib.minus_bigint_span(i_converted, s_converted) +def adjacent_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.adjacent_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_bigint_spanset(i: int, ss: 'const SpanSet *') -> 'SpanSet *': - i_converted = _ffi.cast('int64', i) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.minus_bigint_spanset(i_converted, ss_converted) +def adjacent_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.adjacent_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def minus_date_set(d: 'DateADT', s: 'const Set *') -> 'Set *': - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Set *', s) - result = _lib.minus_date_set(d_converted, s_converted) +def contained_bigint_set(i: int, s: "const Set *") -> "bool": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Set *", s) + result = _lib.contained_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_date_span(d: 'DateADT', s: 'const Span *') -> 'SpanSet *': - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Span *', s) - result = _lib.minus_date_span(d_converted, s_converted) +def contained_bigint_span(i: int, s: "const Span *") -> "bool": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Span *", s) + result = _lib.contained_bigint_span(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_date_spanset(d: 'DateADT', ss: 'const SpanSet *') -> 'SpanSet *': - d_converted = _ffi.cast('DateADT', d) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.minus_date_spanset(d_converted, ss_converted) +def contained_bigint_spanset(i: int, ss: "const SpanSet *") -> "bool": + i_converted = _ffi.cast("int64", i) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.contained_bigint_spanset(i_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_float_set(d: float, s: 'const Set *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.minus_float_set(d, s_converted) +def contained_date_set(d: "DateADT", s: "const Set *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + s_converted = _ffi.cast("const Set *", s) + result = _lib.contained_date_set(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_float_span(d: float, s: 'const Span *') -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.minus_float_span(d, s_converted) +def contained_date_span(d: "DateADT", s: "const Span *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + s_converted = _ffi.cast("const Span *", s) + result = _lib.contained_date_span(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_float_spanset(d: float, ss: 'const SpanSet *') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.minus_float_spanset(d, ss_converted) +def contained_date_spanset(d: "DateADT", ss: "const SpanSet *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.contained_date_spanset(d_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_geo_set(gs: 'const GSERIALIZED *', s: 'const Set *') -> 'Set *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - s_converted = _ffi.cast('const Set *', s) - result = _lib.minus_geo_set(gs_converted, s_converted) +def contained_float_set(d: float, s: "const Set *") -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.contained_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_int_set(i: int, s: 'const Set *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.minus_int_set(i, s_converted) +def contained_float_span(d: float, s: "const Span *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.contained_float_span(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_int_span(i: int, s: 'const Span *') -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.minus_int_span(i, s_converted) +def contained_float_spanset(d: float, ss: "const SpanSet *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.contained_float_spanset(d, ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_int_spanset(i: int, ss: 'const SpanSet *') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.minus_int_spanset(i, ss_converted) +def contained_geo_set(gs: "GSERIALIZED *", s: "const Set *") -> "bool": + gs_converted = _ffi.cast("GSERIALIZED *", gs) + s_converted = _ffi.cast("const Set *", s) + result = _lib.contained_geo_set(gs_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_bigint(s: 'const Set *', i: int) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.minus_set_bigint(s_converted, i_converted) +def contained_int_set(i: int, s: "const Set *") -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.contained_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_date(s: 'const Set *', d: 'DateADT') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.minus_set_date(s_converted, d_converted) +def contained_int_span(i: int, s: "const Span *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.contained_int_span(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_float(s: 'const Set *', d: float) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.minus_set_float(s_converted, d) +def contained_int_spanset(i: int, ss: "const SpanSet *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.contained_int_spanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_geo(s: 'const Set *', gs: 'const GSERIALIZED *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.minus_set_geo(s_converted, gs_converted) +def contained_set_set(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.contained_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_int(s: 'const Set *', i: int) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.minus_set_int(s_converted, i) +def contained_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.contained_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_set(s1: 'const Set *', s2: 'const Set *') -> 'Set *': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.minus_set_set(s1_converted, s2_converted) +def contained_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.contained_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_text(s: 'const Set *', txt: str) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - txt_converted = cstring2text(txt) - result = _lib.minus_set_text(s_converted, txt_converted) +def contained_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.contained_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_timestamptz(s: 'const Set *', t: int) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.minus_set_timestamptz(s_converted, t_converted) +def contained_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.contained_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_bigint(s: 'const Span *', i: int) -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.minus_span_bigint(s_converted, i_converted) +def contained_text_set(txt: str, s: "const Set *") -> "bool": + txt_converted = cstring2text(txt) + s_converted = _ffi.cast("const Set *", s) + result = _lib.contained_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_date(s: 'const Span *', d: 'DateADT') -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.minus_span_date(s_converted, d_converted) +def contained_timestamptz_set(t: int, s: "const Set *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + s_converted = _ffi.cast("const Set *", s) + result = _lib.contained_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_float(s: 'const Span *', d: float) -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.minus_span_float(s_converted, d) +def contained_timestamptz_span(t: int, s: "const Span *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + s_converted = _ffi.cast("const Span *", s) + result = _lib.contained_timestamptz_span(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_int(s: 'const Span *', i: int) -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.minus_span_int(s_converted, i) +def contained_timestamptz_spanset(t: int, ss: "const SpanSet *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.contained_timestamptz_spanset(t_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_span(s1: 'const Span *', s2: 'const Span *') -> 'SpanSet *': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.minus_span_span(s1_converted, s2_converted) +def contains_set_bigint(s: "const Set *", i: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.contains_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.minus_span_spanset(s_converted, ss_converted) +def contains_set_date(s: "const Set *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Set *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.contains_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_timestamptz(s: 'const Span *', t: int) -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.minus_span_timestamptz(s_converted, t_converted) +def contains_set_float(s: "const Set *", d: float) -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.contains_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) - result = _lib.minus_spanset_bigint(ss_converted, i_converted) +def contains_set_geo(s: "const Set *", gs: "GSERIALIZED *") -> "bool": + s_converted = _ffi.cast("const Set *", s) + gs_converted = _ffi.cast("GSERIALIZED *", gs) + result = _lib.contains_set_geo(s_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) - result = _lib.minus_spanset_date(ss_converted, d_converted) +def contains_set_int(s: "const Set *", i: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.contains_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_float(ss: 'const SpanSet *', d: float) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.minus_spanset_float(ss_converted, d) +def contains_set_set(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.contains_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_int(ss: 'const SpanSet *', i: int) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.minus_spanset_int(ss_converted, i) +def contains_set_text(s: "const Set *", t: str) -> "bool": + s_converted = _ffi.cast("const Set *", s) + t_converted = cstring2text(t) + result = _lib.contains_set_text(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.minus_spanset_span(ss_converted, s_converted) +def contains_set_timestamptz(s: "const Set *", t: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.contains_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'SpanSet *': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.minus_spanset_spanset(ss1_converted, ss2_converted) +def contains_span_bigint(s: "const Span *", i: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.contains_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.minus_spanset_timestamptz(ss_converted, t_converted) +def contains_span_date(s: "const Span *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.contains_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def minus_text_set(txt: str, s: 'const Set *') -> 'Set *': - txt_converted = cstring2text(txt) - s_converted = _ffi.cast('const Set *', s) - result = _lib.minus_text_set(txt_converted, s_converted) +def contains_span_float(s: "const Span *", d: float) -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.contains_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def minus_timestamptz_span(t: int, s: 'const Span *') -> 'SpanSet *': - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Span *', s) - result = _lib.minus_timestamptz_span(t_converted, s_converted) +def contains_span_int(s: "const Span *", i: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.contains_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def minus_timestamptz_spanset(t: int, ss: 'const SpanSet *') -> 'SpanSet *': - t_converted = _ffi.cast('TimestampTz', t) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.minus_timestamptz_spanset(t_converted, ss_converted) +def contains_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.contains_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def minus_timestamptz_set(t: int, s: 'const Set *') -> 'Set *': - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) - result = _lib.minus_timestamptz_set(t_converted, s_converted) +def contains_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.contains_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def super_union_span_span(s1: 'const Span *', s2: 'const Span *') -> 'Span *': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.super_union_span_span(s1_converted, s2_converted) +def contains_span_timestamptz(s: "const Span *", t: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.contains_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_bigint(s: 'const Set *', i: int) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.union_set_bigint(s_converted, i_converted) +def contains_spanset_bigint(ss: "const SpanSet *", i: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + i_converted = _ffi.cast("int64", i) + result = _lib.contains_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_date(s: 'const Set *', d: 'DateADT') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.union_set_date(s_converted, d_converted) +def contains_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.contains_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_float(s: 'const Set *', d: float) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.union_set_float(s_converted, d) +def contains_spanset_float(ss: "const SpanSet *", d: float) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.contains_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def union_set_geo(s: 'const Set *', gs: 'const GSERIALIZED *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.union_set_geo(s_converted, gs_converted) +def contains_spanset_int(ss: "const SpanSet *", i: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.contains_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def union_set_int(s: 'const Set *', i: int) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.union_set_int(s_converted, i) +def contains_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.contains_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_set(s1: 'const Set *', s2: 'const Set *') -> 'Set *': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.union_set_set(s1_converted, s2_converted) +def contains_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.contains_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_text(s: 'const Set *', txt: str) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - txt_converted = cstring2text(txt) - result = _lib.union_set_text(s_converted, txt_converted) +def contains_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.contains_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_timestamptz(s: 'const Set *', t: int) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('const TimestampTz', t) - result = _lib.union_set_timestamptz(s_converted, t_converted) +def overlaps_set_set(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.overlaps_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_bigint(s: 'const Span *', i: int) -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.union_span_bigint(s_converted, i_converted) +def overlaps_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.overlaps_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_date(s: 'const Span *', d: 'DateADT') -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.union_span_date(s_converted, d_converted) +def overlaps_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overlaps_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_float(s: 'const Span *', d: float) -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.union_span_float(s_converted, d) +def overlaps_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overlaps_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_int(s: 'const Span *', i: int) -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.union_span_int(s_converted, i) +def overlaps_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.overlaps_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_span(s1: 'const Span *', s2: 'const Span *') -> 'SpanSet *': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.union_span_span(s1_converted, s2_converted) +def after_date_set(d: "DateADT", s: "const Set *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + s_converted = _ffi.cast("const Set *", s) + result = _lib.after_date_set(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_timestamptz(s: 'const Span *', t: int) -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.union_span_timestamptz(s_converted, t_converted) +def after_date_span(d: "DateADT", s: "const Span *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + s_converted = _ffi.cast("const Span *", s) + result = _lib.after_date_span(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) - result = _lib.union_spanset_bigint(ss_converted, i_converted) +def after_date_spanset(d: "DateADT", ss: "const SpanSet *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.after_date_spanset(d_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) - result = _lib.union_spanset_date(ss_converted, d_converted) +def after_set_date(s: "const Set *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Set *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.after_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_float(ss: 'const SpanSet *', d: float) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.union_spanset_float(ss_converted, d) +def after_set_timestamptz(s: "const Set *", t: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.after_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_int(ss: 'const SpanSet *', i: int) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.union_spanset_int(ss_converted, i) +def after_span_date(s: "const Span *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.after_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.union_spanset_span(ss_converted, s_converted) +def after_span_timestamptz(s: "const Span *", t: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.after_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'SpanSet *': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.union_spanset_spanset(ss1_converted, ss2_converted) +def after_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.after_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.union_spanset_timestamptz(ss_converted, t_converted) +def after_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.after_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_bigint(s: 'const Span *', i: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.adjacent_span_bigint(s_converted, i_converted) +def after_timestamptz_set(t: int, s: "const Set *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + s_converted = _ffi.cast("const Set *", s) + result = _lib.after_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_date(s: 'const Span *', d: 'DateADT') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.adjacent_span_date(s_converted, d_converted) +def after_timestamptz_span(t: int, s: "const Span *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + s_converted = _ffi.cast("const Span *", s) + result = _lib.after_timestamptz_span(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_float(s: 'const Span *', d: float) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.adjacent_span_float(s_converted, d) +def after_timestamptz_spanset(t: int, ss: "const SpanSet *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.after_timestamptz_spanset(t_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_int(s: 'const Span *', i: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.adjacent_span_int(s_converted, i) +def before_date_set(d: "DateADT", s: "const Set *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + s_converted = _ffi.cast("const Set *", s) + result = _lib.before_date_set(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.adjacent_span_span(s1_converted, s2_converted) +def before_date_span(d: "DateADT", s: "const Span *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + s_converted = _ffi.cast("const Span *", s) + result = _lib.before_date_span(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_timestamptz(s: 'const Span *', t: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.adjacent_span_timestamptz(s_converted, t_converted) +def before_date_spanset(d: "DateADT", ss: "const SpanSet *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.before_date_spanset(d_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) - result = _lib.adjacent_spanset_bigint(ss_converted, i_converted) +def before_set_date(s: "const Set *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Set *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.before_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) - result = _lib.adjacent_spanset_date(ss_converted, d_converted) +def before_set_timestamptz(s: "const Set *", t: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.before_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_float(ss: 'const SpanSet *', d: float) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.adjacent_spanset_float(ss_converted, d) +def before_span_date(s: "const Span *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.before_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_int(ss: 'const SpanSet *', i: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.adjacent_spanset_int(ss_converted, i) +def before_span_timestamptz(s: "const Span *", t: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.before_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.adjacent_spanset_timestamptz(ss_converted, t_converted) +def before_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.before_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.adjacent_spanset_span(ss_converted, s_converted) +def before_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.before_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.adjacent_spanset_spanset(ss1_converted, ss2_converted) +def before_timestamptz_set(t: int, s: "const Set *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + s_converted = _ffi.cast("const Set *", s) + result = _lib.before_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_bigint_set(i: int, s: 'const Set *') -> 'bool': - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) - result = _lib.contained_bigint_set(i_converted, s_converted) +def before_timestamptz_span(t: int, s: "const Span *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + s_converted = _ffi.cast("const Span *", s) + result = _lib.before_timestamptz_span(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_bigint_span(i: int, s: 'const Span *') -> 'bool': - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Span *', s) - result = _lib.contained_bigint_span(i_converted, s_converted) +def before_timestamptz_spanset(t: int, ss: "const SpanSet *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.before_timestamptz_spanset(t_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contained_bigint_spanset(i: int, ss: 'const SpanSet *') -> 'bool': - i_converted = _ffi.cast('int64', i) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.contained_bigint_spanset(i_converted, ss_converted) +def left_bigint_set(i: int, s: "const Set *") -> "bool": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Set *", s) + result = _lib.left_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_date_set(d: 'DateADT', s: 'const Set *') -> 'bool': - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Set *', s) - result = _lib.contained_date_set(d_converted, s_converted) +def left_bigint_span(i: int, s: "const Span *") -> "bool": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Span *", s) + result = _lib.left_bigint_span(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_date_span(d: 'DateADT', s: 'const Span *') -> 'bool': - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Span *', s) - result = _lib.contained_date_span(d_converted, s_converted) +def left_bigint_spanset(i: int, ss: "const SpanSet *") -> "bool": + i_converted = _ffi.cast("int64", i) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.left_bigint_spanset(i_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contained_date_spanset(d: 'DateADT', ss: 'const SpanSet *') -> 'bool': - d_converted = _ffi.cast('DateADT', d) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.contained_date_spanset(d_converted, ss_converted) +def left_float_set(d: float, s: "const Set *") -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.left_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_float_set(d: float, s: 'const Set *') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.contained_float_set(d, s_converted) +def left_float_span(d: float, s: "const Span *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.left_float_span(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_float_span(d: float, s: 'const Span *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.contained_float_span(d, s_converted) +def left_float_spanset(d: float, ss: "const SpanSet *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.left_float_spanset(d, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contained_float_spanset(d: float, ss: 'const SpanSet *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.contained_float_spanset(d, ss_converted) +def left_int_set(i: int, s: "const Set *") -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.left_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_geo_set(gs: 'GSERIALIZED *', s: 'const Set *') -> 'bool': - gs_converted = _ffi.cast('GSERIALIZED *', gs) - s_converted = _ffi.cast('const Set *', s) - result = _lib.contained_geo_set(gs_converted, s_converted) +def left_int_span(i: int, s: "const Span *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.left_int_span(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def contained_int_set(i: int, s: 'const Set *') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.contained_int_set(i, s_converted) +def left_int_spanset(i: int, ss: "const SpanSet *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.left_int_spanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contained_int_span(i: int, s: 'const Span *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.contained_int_span(i, s_converted) +def left_set_bigint(s: "const Set *", i: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.left_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def contained_int_spanset(i: int, ss: 'const SpanSet *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.contained_int_spanset(i, ss_converted) +def left_set_float(s: "const Set *", d: float) -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.left_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def contained_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.contained_set_set(s1_converted, s2_converted) +def left_set_int(s: "const Set *", i: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.left_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def contained_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.contained_span_span(s1_converted, s2_converted) +def left_set_set(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.left_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.contained_span_spanset(s_converted, ss_converted) +def left_set_text(s: "const Set *", txt: str) -> "bool": + s_converted = _ffi.cast("const Set *", s) + txt_converted = cstring2text(txt) + result = _lib.left_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def contained_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.contained_spanset_span(ss_converted, s_converted) +def left_span_bigint(s: "const Span *", i: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.left_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def contained_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.contained_spanset_spanset(ss1_converted, ss2_converted) +def left_span_float(s: "const Span *", d: float) -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.left_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def contained_text_set(txt: str, s: 'const Set *') -> 'bool': - txt_converted = cstring2text(txt) - s_converted = _ffi.cast('const Set *', s) - result = _lib.contained_text_set(txt_converted, s_converted) +def left_span_int(s: "const Span *", i: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.left_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def contained_timestamptz_set(t: int, s: 'const Set *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) - result = _lib.contained_timestamptz_set(t_converted, s_converted) +def left_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.left_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_timestamptz_span(t: int, s: 'const Span *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Span *', s) - result = _lib.contained_timestamptz_span(t_converted, s_converted) +def left_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.left_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contained_timestamptz_spanset(t: int, ss: 'const SpanSet *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.contained_timestamptz_spanset(t_converted, ss_converted) +def left_spanset_bigint(ss: "const SpanSet *", i: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + i_converted = _ffi.cast("int64", i) + result = _lib.left_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_bigint(s: 'const Set *', i: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.contains_set_bigint(s_converted, i_converted) +def left_spanset_float(ss: "const SpanSet *", d: float) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.left_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def contains_set_date(s: 'const Set *', d: 'DateADT') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.contains_set_date(s_converted, d_converted) +def left_spanset_int(ss: "const SpanSet *", i: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.left_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def contains_set_float(s: 'const Set *', d: float) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.contains_set_float(s_converted, d) +def left_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.left_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_geo(s: 'const Set *', gs: 'GSERIALIZED *') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - gs_converted = _ffi.cast('GSERIALIZED *', gs) - result = _lib.contains_set_geo(s_converted, gs_converted) +def left_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.left_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_int(s: 'const Set *', i: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.contains_set_int(s_converted, i) +def left_text_set(txt: str, s: "const Set *") -> "bool": + txt_converted = cstring2text(txt) + s_converted = _ffi.cast("const Set *", s) + result = _lib.left_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.contains_set_set(s1_converted, s2_converted) +def overafter_date_set(d: "DateADT", s: "const Set *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + s_converted = _ffi.cast("const Set *", s) + result = _lib.overafter_date_set(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_text(s: 'const Set *', t: str) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - t_converted = cstring2text(t) - result = _lib.contains_set_text(s_converted, t_converted) +def overafter_date_span(d: "DateADT", s: "const Span *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overafter_date_span(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_timestamptz(s: 'const Set *', t: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.contains_set_timestamptz(s_converted, t_converted) +def overafter_date_spanset(d: "DateADT", ss: "const SpanSet *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overafter_date_spanset(d_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_bigint(s: 'const Span *', i: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.contains_span_bigint(s_converted, i_converted) +def overafter_set_date(s: "const Set *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Set *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.overafter_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_float(s: 'const Span *', d: float) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.contains_span_float(s_converted, d) +def overafter_set_timestamptz(s: "const Set *", t: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.overafter_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_int(s: 'const Span *', i: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.contains_span_int(s_converted, i) +def overafter_span_date(s: "const Span *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.overafter_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.contains_span_span(s1_converted, s2_converted) +def overafter_span_timestamptz(s: "const Span *", t: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.overafter_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.contains_span_spanset(s_converted, ss_converted) +def overafter_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.overafter_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_timestamptz(s: 'const Span *', t: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.contains_span_timestamptz(s_converted, t_converted) +def overafter_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.overafter_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_date(s: 'const Span *', d: 'DateADT') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.contains_span_date(s_converted, d_converted) +def overafter_timestamptz_set(t: int, s: "const Set *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + s_converted = _ffi.cast("const Set *", s) + result = _lib.overafter_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) - result = _lib.contains_spanset_bigint(ss_converted, i_converted) +def overafter_timestamptz_span(t: int, s: "const Span *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overafter_timestamptz_span(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_float(ss: 'const SpanSet *', d: float) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.contains_spanset_float(ss_converted, d) +def overafter_timestamptz_spanset(t: int, ss: "const SpanSet *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overafter_timestamptz_spanset(t_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_int(ss: 'const SpanSet *', i: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.contains_spanset_int(ss_converted, i) +def overbefore_date_set(d: "DateADT", s: "const Set *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + s_converted = _ffi.cast("const Set *", s) + result = _lib.overbefore_date_set(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.contains_spanset_span(ss_converted, s_converted) +def overbefore_date_span(d: "DateADT", s: "const Span *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overbefore_date_span(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.contains_spanset_spanset(ss1_converted, ss2_converted) +def overbefore_date_spanset(d: "DateADT", ss: "const SpanSet *") -> "bool": + d_converted = _ffi.cast("DateADT", d) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overbefore_date_spanset(d_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.contains_spanset_timestamptz(ss_converted, t_converted) +def overbefore_set_date(s: "const Set *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Set *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.overbefore_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) - result = _lib.contains_spanset_date(ss_converted, d_converted) +def overbefore_set_timestamptz(s: "const Set *", t: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.overbefore_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.overlaps_set_set(s1_converted, s2_converted) +def overbefore_span_date(s: "const Span *", d: "DateADT") -> "bool": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.overbefore_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.overlaps_span_span(s1_converted, s2_converted) +def overbefore_span_timestamptz(s: "const Span *", t: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.overbefore_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overlaps_spanset_span(ss_converted, s_converted) +def overbefore_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.overbefore_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.overlaps_spanset_spanset(ss1_converted, ss2_converted) +def overbefore_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.overbefore_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def after_date_set(d: 'DateADT', s: 'const Set *') -> 'bool': - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Set *', s) - result = _lib.after_date_set(d_converted, s_converted) +def overbefore_timestamptz_set(t: int, s: "const Set *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + s_converted = _ffi.cast("const Set *", s) + result = _lib.overbefore_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def after_date_span(d: 'DateADT', s: 'const Span *') -> 'bool': - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Span *', s) - result = _lib.after_date_span(d_converted, s_converted) +def overbefore_timestamptz_span(t: int, s: "const Span *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overbefore_timestamptz_span(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def after_date_spanset(d: 'DateADT', ss: 'const SpanSet *') -> 'bool': - d_converted = _ffi.cast('DateADT', d) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.after_date_spanset(d_converted, ss_converted) +def overbefore_timestamptz_spanset(t: int, ss: "const SpanSet *") -> "bool": + t_converted = _ffi.cast("TimestampTz", t) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overbefore_timestamptz_spanset(t_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def after_set_date(s: 'const Set *', d: 'DateADT') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.after_set_date(s_converted, d_converted) +def overleft_bigint_set(i: int, s: "const Set *") -> "bool": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Set *", s) + result = _lib.overleft_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def after_set_timestamptz(s: 'const Set *', t: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.after_set_timestamptz(s_converted, t_converted) +def overleft_bigint_span(i: int, s: "const Span *") -> "bool": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overleft_bigint_span(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def after_span_date(s: 'const Span *', d: 'DateADT') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.after_span_date(s_converted, d_converted) +def overleft_bigint_spanset(i: int, ss: "const SpanSet *") -> "bool": + i_converted = _ffi.cast("int64", i) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overleft_bigint_spanset(i_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def after_span_timestamptz(s: 'const Span *', t: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.after_span_timestamptz(s_converted, t_converted) +def overleft_float_set(d: float, s: "const Set *") -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.overleft_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def after_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) - result = _lib.after_spanset_date(ss_converted, d_converted) +def overleft_float_span(d: float, s: "const Span *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.overleft_float_span(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def after_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.after_spanset_timestamptz(ss_converted, t_converted) +def overleft_float_spanset(d: float, ss: "const SpanSet *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overleft_float_spanset(d, ss_converted) _check_error() return result if result != _ffi.NULL else None -def after_timestamptz_set(t: int, s: 'const Set *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) - result = _lib.after_timestamptz_set(t_converted, s_converted) +def overleft_int_set(i: int, s: "const Set *") -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.overleft_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def after_timestamptz_span(t: int, s: 'const Span *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Span *', s) - result = _lib.after_timestamptz_span(t_converted, s_converted) +def overleft_int_span(i: int, s: "const Span *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.overleft_int_span(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def after_timestamptz_spanset(t: int, ss: 'const SpanSet *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.after_timestamptz_spanset(t_converted, ss_converted) +def overleft_int_spanset(i: int, ss: "const SpanSet *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overleft_int_spanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def before_date_set(d: 'DateADT', s: 'const Set *') -> 'bool': - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Set *', s) - result = _lib.before_date_set(d_converted, s_converted) +def overleft_set_bigint(s: "const Set *", i: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.overleft_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def before_date_span(d: 'DateADT', s: 'const Span *') -> 'bool': - d_converted = _ffi.cast('DateADT', d) - s_converted = _ffi.cast('const Span *', s) - result = _lib.before_date_span(d_converted, s_converted) +def overleft_set_float(s: "const Set *", d: float) -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.overleft_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def before_date_spanset(d: 'DateADT', ss: 'const SpanSet *') -> 'bool': - d_converted = _ffi.cast('DateADT', d) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.before_date_spanset(d_converted, ss_converted) +def overleft_set_int(s: "const Set *", i: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.overleft_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def before_set_date(s: 'const Set *', d: 'DateADT') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.before_set_date(s_converted, d_converted) +def overleft_set_set(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.overleft_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def before_set_timestamptz(s: 'const Set *', t: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.before_set_timestamptz(s_converted, t_converted) +def overleft_set_text(s: "const Set *", txt: str) -> "bool": + s_converted = _ffi.cast("const Set *", s) + txt_converted = cstring2text(txt) + result = _lib.overleft_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def before_span_date(s: 'const Span *', d: 'DateADT') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.before_span_date(s_converted, d_converted) +def overleft_span_bigint(s: "const Span *", i: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.overleft_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def before_span_timestamptz(s: 'const Span *', t: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.before_span_timestamptz(s_converted, t_converted) +def overleft_span_float(s: "const Span *", d: float) -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.overleft_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def before_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) - result = _lib.before_spanset_date(ss_converted, d_converted) +def overleft_span_int(s: "const Span *", i: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.overleft_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def before_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.before_spanset_timestamptz(ss_converted, t_converted) +def overleft_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.overleft_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def before_timestamptz_set(t: int, s: 'const Set *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) - result = _lib.before_timestamptz_set(t_converted, s_converted) +def overleft_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overleft_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def before_timestamptz_span(t: int, s: 'const Span *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Span *', s) - result = _lib.before_timestamptz_span(t_converted, s_converted) +def overleft_spanset_bigint(ss: "const SpanSet *", i: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + i_converted = _ffi.cast("int64", i) + result = _lib.overleft_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def before_timestamptz_spanset(t: int, ss: 'const SpanSet *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.before_timestamptz_spanset(t_converted, ss_converted) +def overleft_spanset_float(ss: "const SpanSet *", d: float) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overleft_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def left_bigint_set(i: int, s: 'const Set *') -> 'bool': - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) - result = _lib.left_bigint_set(i_converted, s_converted) +def overleft_spanset_int(ss: "const SpanSet *", i: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overleft_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def left_bigint_span(i: int, s: 'const Span *') -> 'bool': - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Span *', s) - result = _lib.left_bigint_span(i_converted, s_converted) +def overleft_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overleft_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_bigint_spanset(i: int, ss: 'const SpanSet *') -> 'bool': - i_converted = _ffi.cast('int64', i) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.left_bigint_spanset(i_converted, ss_converted) +def overleft_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.overleft_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def left_float_set(d: float, s: 'const Set *') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.left_float_set(d, s_converted) +def overleft_text_set(txt: str, s: "const Set *") -> "bool": + txt_converted = cstring2text(txt) + s_converted = _ffi.cast("const Set *", s) + result = _lib.overleft_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_float_span(d: float, s: 'const Span *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.left_float_span(d, s_converted) +def overright_bigint_set(i: int, s: "const Set *") -> "bool": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Set *", s) + result = _lib.overright_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_float_spanset(d: float, ss: 'const SpanSet *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.left_float_spanset(d, ss_converted) +def overright_bigint_span(i: int, s: "const Span *") -> "bool": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overright_bigint_span(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_int_set(i: int, s: 'const Set *') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.left_int_set(i, s_converted) +def overright_bigint_spanset(i: int, ss: "const SpanSet *") -> "bool": + i_converted = _ffi.cast("int64", i) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overright_bigint_spanset(i_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def left_int_span(i: int, s: 'const Span *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.left_int_span(i, s_converted) +def overright_float_set(d: float, s: "const Set *") -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.overright_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_int_spanset(i: int, ss: 'const SpanSet *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.left_int_spanset(i, ss_converted) +def overright_float_span(d: float, s: "const Span *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.overright_float_span(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_set_bigint(s: 'const Set *', i: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.left_set_bigint(s_converted, i_converted) +def overright_float_spanset(d: float, ss: "const SpanSet *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overright_float_spanset(d, ss_converted) _check_error() return result if result != _ffi.NULL else None -def left_set_float(s: 'const Set *', d: float) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.left_set_float(s_converted, d) +def overright_int_set(i: int, s: "const Set *") -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.overright_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_set_int(s: 'const Set *', i: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.left_set_int(s_converted, i) +def overright_int_span(i: int, s: "const Span *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.overright_int_span(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.left_set_set(s1_converted, s2_converted) +def overright_int_spanset(i: int, ss: "const SpanSet *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overright_int_spanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def left_set_text(s: 'const Set *', txt: str) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - txt_converted = cstring2text(txt) - result = _lib.left_set_text(s_converted, txt_converted) +def overright_set_bigint(s: "const Set *", i: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.overright_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def left_span_bigint(s: 'const Span *', i: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.left_span_bigint(s_converted, i_converted) +def overright_set_float(s: "const Set *", d: float) -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.overright_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def left_span_float(s: 'const Span *', d: float) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.left_span_float(s_converted, d) +def overright_set_int(s: "const Set *", i: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.overright_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def left_span_int(s: 'const Span *', i: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.left_span_int(s_converted, i) +def overright_set_set(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.overright_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def left_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.left_span_span(s1_converted, s2_converted) +def overright_set_text(s: "const Set *", txt: str) -> "bool": + s_converted = _ffi.cast("const Set *", s) + txt_converted = cstring2text(txt) + result = _lib.overright_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def left_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.left_span_spanset(s_converted, ss_converted) +def overright_span_bigint(s: "const Span *", i: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.overright_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def left_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) - result = _lib.left_spanset_bigint(ss_converted, i_converted) +def overright_span_float(s: "const Span *", d: float) -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.overright_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def left_spanset_float(ss: 'const SpanSet *', d: float) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.left_spanset_float(ss_converted, d) +def overright_span_int(s: "const Span *", i: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.overright_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def left_spanset_int(ss: 'const SpanSet *', i: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.left_spanset_int(ss_converted, i) +def overright_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.overright_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def left_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.left_spanset_span(ss_converted, s_converted) +def overright_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overright_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def left_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.left_spanset_spanset(ss1_converted, ss2_converted) +def overright_spanset_bigint(ss: "const SpanSet *", i: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + i_converted = _ffi.cast("int64", i) + result = _lib.overright_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def left_text_set(txt: str, s: 'const Set *') -> 'bool': - txt_converted = cstring2text(txt) - s_converted = _ffi.cast('const Set *', s) - result = _lib.left_text_set(txt_converted, s_converted) +def overright_spanset_float(ss: "const SpanSet *", d: float) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overright_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def overafter_set_date(s: 'const Set *', d: 'DateADT') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.overafter_set_date(s_converted, d_converted) +def overright_spanset_int(ss: "const SpanSet *", i: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overright_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def overafter_set_timestamptz(s: 'const Set *', t: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.overafter_set_timestamptz(s_converted, t_converted) +def overright_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overright_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_span_timestamptz(s: 'const Span *', t: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.overafter_span_timestamptz(s_converted, t_converted) +def overright_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.overright_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_span_date(s: 'const Span *', d: 'DateADT') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.overafter_span_date(s_converted, d_converted) +def overright_text_set(txt: str, s: "const Set *") -> "bool": + txt_converted = cstring2text(txt) + s_converted = _ffi.cast("const Set *", s) + result = _lib.overright_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.overafter_spanset_timestamptz(ss_converted, t_converted) +def right_bigint_set(i: int, s: "const Set *") -> "bool": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Set *", s) + result = _lib.right_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) - result = _lib.overafter_spanset_date(ss_converted, d_converted) +def right_bigint_span(i: int, s: "const Span *") -> "bool": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Span *", s) + result = _lib.right_bigint_span(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_timestamptz_set(t: int, s: 'const Set *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) - result = _lib.overafter_timestamptz_set(t_converted, s_converted) +def right_bigint_spanset(i: int, ss: "const SpanSet *") -> "bool": + i_converted = _ffi.cast("int64", i) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.right_bigint_spanset(i_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_timestamptz_span(t: int, s: 'const Span *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overafter_timestamptz_span(t_converted, s_converted) +def right_float_set(d: float, s: "const Set *") -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.right_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_timestamptz_spanset(t: int, ss: 'const SpanSet *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overafter_timestamptz_spanset(t_converted, ss_converted) +def right_float_span(d: float, s: "const Span *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.right_float_span(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_set_date(s: 'const Set *', d: 'DateADT') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.overbefore_set_date(s_converted, d_converted) +def right_float_spanset(d: float, ss: "const SpanSet *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.right_float_spanset(d, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_set_timestamptz(s: 'const Set *', t: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.overbefore_set_timestamptz(s_converted, t_converted) +def right_int_set(i: int, s: "const Set *") -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.right_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_span_timestamptz(s: 'const Span *', t: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.overbefore_span_timestamptz(s_converted, t_converted) +def right_int_span(i: int, s: "const Span *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.right_int_span(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_span_date(s: 'const Span *', d: 'DateADT') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.overbefore_span_date(s_converted, d_converted) +def right_int_spanset(i: int, ss: "const SpanSet *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.right_int_spanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.overbefore_spanset_timestamptz(ss_converted, t_converted) +def right_set_bigint(s: "const Set *", i: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.right_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) - result = _lib.overbefore_spanset_date(ss_converted, d_converted) +def right_set_float(s: "const Set *", d: float) -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.right_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def overbefore_timestamptz_set(t: int, s: 'const Set *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Set *', s) - result = _lib.overbefore_timestamptz_set(t_converted, s_converted) +def right_set_int(s: "const Set *", i: int) -> "bool": + s_converted = _ffi.cast("const Set *", s) + result = _lib.right_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def overbefore_timestamptz_span(t: int, s: 'const Span *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overbefore_timestamptz_span(t_converted, s_converted) +def right_set_set(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.right_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_timestamptz_spanset(t: int, ss: 'const SpanSet *') -> 'bool': - t_converted = _ffi.cast('TimestampTz', t) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overbefore_timestamptz_spanset(t_converted, ss_converted) +def right_set_text(s: "const Set *", txt: str) -> "bool": + s_converted = _ffi.cast("const Set *", s) + txt_converted = cstring2text(txt) + result = _lib.right_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_bigint_set(i: int, s: 'const Set *') -> 'bool': - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) - result = _lib.overleft_bigint_set(i_converted, s_converted) +def right_span_bigint(s: "const Span *", i: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.right_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_bigint_span(i: int, s: 'const Span *') -> 'bool': - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overleft_bigint_span(i_converted, s_converted) +def right_span_float(s: "const Span *", d: float) -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.right_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def overleft_bigint_spanset(i: int, ss: 'const SpanSet *') -> 'bool': - i_converted = _ffi.cast('int64', i) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overleft_bigint_spanset(i_converted, ss_converted) +def right_span_int(s: "const Span *", i: int) -> "bool": + s_converted = _ffi.cast("const Span *", s) + result = _lib.right_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def overleft_float_set(d: float, s: 'const Set *') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.overleft_float_set(d, s_converted) +def right_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.right_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_float_span(d: float, s: 'const Span *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.overleft_float_span(d, s_converted) +def right_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.right_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_float_spanset(d: float, ss: 'const SpanSet *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overleft_float_spanset(d, ss_converted) +def right_spanset_bigint(ss: "const SpanSet *", i: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + i_converted = _ffi.cast("int64", i) + result = _lib.right_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_int_set(i: int, s: 'const Set *') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.overleft_int_set(i, s_converted) +def right_spanset_float(ss: "const SpanSet *", d: float) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.right_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def overleft_int_span(i: int, s: 'const Span *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.overleft_int_span(i, s_converted) +def right_spanset_int(ss: "const SpanSet *", i: int) -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.right_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def overleft_int_spanset(i: int, ss: 'const SpanSet *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overleft_int_spanset(i, ss_converted) +def right_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.right_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_set_bigint(s: 'const Set *', i: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.overleft_set_bigint(s_converted, i_converted) +def right_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.right_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_set_float(s: 'const Set *', d: float) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.overleft_set_float(s_converted, d) +def right_text_set(txt: str, s: "const Set *") -> "bool": + txt_converted = cstring2text(txt) + s_converted = _ffi.cast("const Set *", s) + result = _lib.right_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_set_int(s: 'const Set *', i: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.overleft_set_int(s_converted, i) +def intersection_bigint_set(i: int, s: "const Set *") -> "Set *": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Set *", s) + result = _lib.intersection_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.overleft_set_set(s1_converted, s2_converted) +def intersection_date_set(d: "const DateADT", s: "const Set *") -> "Set *": + d_converted = _ffi.cast("const DateADT", d) + s_converted = _ffi.cast("const Set *", s) + result = _lib.intersection_date_set(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_set_text(s: 'const Set *', txt: str) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - txt_converted = cstring2text(txt) - result = _lib.overleft_set_text(s_converted, txt_converted) +def intersection_float_set(d: float, s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.intersection_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_span_bigint(s: 'const Span *', i: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.overleft_span_bigint(s_converted, i_converted) +def intersection_geo_set(gs: "const GSERIALIZED *", s: "const Set *") -> "Set *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + s_converted = _ffi.cast("const Set *", s) + result = _lib.intersection_geo_set(gs_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_span_float(s: 'const Span *', d: float) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.overleft_span_float(s_converted, d) +def intersection_int_set(i: int, s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.intersection_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_span_int(s: 'const Span *', i: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.overleft_span_int(s_converted, i) +def intersection_set_bigint(s: "const Set *", i: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.intersection_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.overleft_span_span(s1_converted, s2_converted) +def intersection_set_date(s: "const Set *", d: "DateADT") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.intersection_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overleft_span_spanset(s_converted, ss_converted) +def intersection_set_float(s: "const Set *", d: float) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.intersection_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def overleft_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) - result = _lib.overleft_spanset_bigint(ss_converted, i_converted) +def intersection_set_geo(s: "const Set *", gs: "const GSERIALIZED *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.intersection_set_geo(s_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_spanset_float(ss: 'const SpanSet *', d: float) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overleft_spanset_float(ss_converted, d) +def intersection_set_int(s: "const Set *", i: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.intersection_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def overleft_spanset_int(ss: 'const SpanSet *', i: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overleft_spanset_int(ss_converted, i) +def intersection_set_set(s1: "const Set *", s2: "const Set *") -> "Set *": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.intersection_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overleft_spanset_span(ss_converted, s_converted) +def intersection_set_text(s: "const Set *", txt: str) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + txt_converted = cstring2text(txt) + result = _lib.intersection_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.overleft_spanset_spanset(ss1_converted, ss2_converted) +def intersection_set_timestamptz(s: "const Set *", t: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.intersection_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_text_set(txt: str, s: 'const Set *') -> 'bool': - txt_converted = cstring2text(txt) - s_converted = _ffi.cast('const Set *', s) - result = _lib.overleft_text_set(txt_converted, s_converted) +def intersection_span_bigint(s: "const Span *", i: int) -> "Span *": + s_converted = _ffi.cast("const Span *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.intersection_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def overright_bigint_set(i: int, s: 'const Set *') -> 'bool': - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) - result = _lib.overright_bigint_set(i_converted, s_converted) +def intersection_span_date(s: "const Span *", d: "DateADT") -> "Span *": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.intersection_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def overright_bigint_span(i: int, s: 'const Span *') -> 'bool': - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overright_bigint_span(i_converted, s_converted) +def intersection_span_float(s: "const Span *", d: float) -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.intersection_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def overright_bigint_spanset(i: int, ss: 'const SpanSet *') -> 'bool': - i_converted = _ffi.cast('int64', i) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overright_bigint_spanset(i_converted, ss_converted) +def intersection_span_int(s: "const Span *", i: int) -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.intersection_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def overright_float_set(d: float, s: 'const Set *') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.overright_float_set(d, s_converted) +def intersection_span_span(s1: "const Span *", s2: "const Span *") -> "Span *": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.intersection_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_float_span(d: float, s: 'const Span *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.overright_float_span(d, s_converted) +def intersection_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.intersection_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overright_float_spanset(d: float, ss: 'const SpanSet *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overright_float_spanset(d, ss_converted) +def intersection_span_timestamptz(s: "const Span *", t: int) -> "Span *": + s_converted = _ffi.cast("const Span *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.intersection_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def overright_int_set(i: int, s: 'const Set *') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.overright_int_set(i, s_converted) +def intersection_spanset_bigint(ss: "const SpanSet *", i: int) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + i_converted = _ffi.cast("int64", i) + result = _lib.intersection_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def overright_int_span(i: int, s: 'const Span *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.overright_int_span(i, s_converted) +def intersection_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.intersection_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def overright_int_spanset(i: int, ss: 'const SpanSet *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overright_int_spanset(i, ss_converted) +def intersection_spanset_float(ss: "const SpanSet *", d: float) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.intersection_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def overright_set_bigint(s: 'const Set *', i: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.overright_set_bigint(s_converted, i_converted) +def intersection_spanset_int(ss: "const SpanSet *", i: int) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.intersection_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def overright_set_float(s: 'const Set *', d: float) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.overright_set_float(s_converted, d) +def intersection_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.intersection_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_set_int(s: 'const Set *', i: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.overright_set_int(s_converted, i) +def intersection_spanset_spanset( + ss1: "const SpanSet *", ss2: "const SpanSet *" +) -> "SpanSet *": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.intersection_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.overright_set_set(s1_converted, s2_converted) +def intersection_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.intersection_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def overright_set_text(s: 'const Set *', txt: str) -> 'bool': - s_converted = _ffi.cast('const Set *', s) +def intersection_text_set(txt: str, s: "const Set *") -> "Set *": txt_converted = cstring2text(txt) - result = _lib.overright_set_text(s_converted, txt_converted) + s_converted = _ffi.cast("const Set *", s) + result = _lib.intersection_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_span_bigint(s: 'const Span *', i: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.overright_span_bigint(s_converted, i_converted) +def intersection_timestamptz_set(t: int, s: "const Set *") -> "Set *": + t_converted = _ffi.cast("const TimestampTz", t) + s_converted = _ffi.cast("const Set *", s) + result = _lib.intersection_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_span_float(s: 'const Span *', d: float) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.overright_span_float(s_converted, d) +def minus_bigint_set(i: int, s: "const Set *") -> "Set *": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Set *", s) + result = _lib.minus_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_span_int(s: 'const Span *', i: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.overright_span_int(s_converted, i) +def minus_bigint_span(i: int, s: "const Span *") -> "SpanSet *": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Span *", s) + result = _lib.minus_bigint_span(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.overright_span_span(s1_converted, s2_converted) +def minus_bigint_spanset(i: int, ss: "const SpanSet *") -> "SpanSet *": + i_converted = _ffi.cast("int64", i) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.minus_bigint_spanset(i_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overright_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overright_span_spanset(s_converted, ss_converted) +def minus_date_set(d: "DateADT", s: "const Set *") -> "Set *": + d_converted = _ffi.cast("DateADT", d) + s_converted = _ffi.cast("const Set *", s) + result = _lib.minus_date_set(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) - result = _lib.overright_spanset_bigint(ss_converted, i_converted) +def minus_date_span(d: "DateADT", s: "const Span *") -> "SpanSet *": + d_converted = _ffi.cast("DateADT", d) + s_converted = _ffi.cast("const Span *", s) + result = _lib.minus_date_span(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_spanset_float(ss: 'const SpanSet *', d: float) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overright_spanset_float(ss_converted, d) +def minus_date_spanset(d: "DateADT", ss: "const SpanSet *") -> "SpanSet *": + d_converted = _ffi.cast("DateADT", d) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.minus_date_spanset(d_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overright_spanset_int(ss: 'const SpanSet *', i: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overright_spanset_int(ss_converted, i) +def minus_float_set(d: float, s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.minus_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overright_spanset_span(ss_converted, s_converted) +def minus_float_span(d: float, s: "const Span *") -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.minus_float_span(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.overright_spanset_spanset(ss1_converted, ss2_converted) +def minus_float_spanset(d: float, ss: "const SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.minus_float_spanset(d, ss_converted) _check_error() return result if result != _ffi.NULL else None -def overright_text_set(txt: str, s: 'const Set *') -> 'bool': - txt_converted = cstring2text(txt) - s_converted = _ffi.cast('const Set *', s) - result = _lib.overright_text_set(txt_converted, s_converted) +def minus_geo_set(gs: "const GSERIALIZED *", s: "const Set *") -> "Set *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + s_converted = _ffi.cast("const Set *", s) + result = _lib.minus_geo_set(gs_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_bigint_set(i: int, s: 'const Set *') -> 'bool': - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Set *', s) - result = _lib.right_bigint_set(i_converted, s_converted) +def minus_int_set(i: int, s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.minus_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_bigint_span(i: int, s: 'const Span *') -> 'bool': - i_converted = _ffi.cast('int64', i) - s_converted = _ffi.cast('const Span *', s) - result = _lib.right_bigint_span(i_converted, s_converted) +def minus_int_span(i: int, s: "const Span *") -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.minus_int_span(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_bigint_spanset(i: int, ss: 'const SpanSet *') -> 'bool': - i_converted = _ffi.cast('int64', i) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.right_bigint_spanset(i_converted, ss_converted) +def minus_int_spanset(i: int, ss: "const SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.minus_int_spanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def right_float_set(d: float, s: 'const Set *') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.right_float_set(d, s_converted) +def minus_set_bigint(s: "const Set *", i: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.minus_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def right_float_span(d: float, s: 'const Span *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.right_float_span(d, s_converted) +def minus_set_date(s: "const Set *", d: "DateADT") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.minus_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def right_float_spanset(d: float, ss: 'const SpanSet *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.right_float_spanset(d, ss_converted) +def minus_set_float(s: "const Set *", d: float) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.minus_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def right_int_set(i: int, s: 'const Set *') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.right_int_set(i, s_converted) +def minus_set_geo(s: "const Set *", gs: "const GSERIALIZED *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.minus_set_geo(s_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def right_int_span(i: int, s: 'const Span *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.right_int_span(i, s_converted) +def minus_set_int(s: "const Set *", i: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.minus_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def right_int_spanset(i: int, ss: 'const SpanSet *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.right_int_spanset(i, ss_converted) +def minus_set_set(s1: "const Set *", s2: "const Set *") -> "Set *": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.minus_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def right_set_bigint(s: 'const Set *', i: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.right_set_bigint(s_converted, i_converted) +def minus_set_text(s: "const Set *", txt: str) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + txt_converted = cstring2text(txt) + result = _lib.minus_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def right_set_float(s: 'const Set *', d: float) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.right_set_float(s_converted, d) +def minus_set_timestamptz(s: "const Set *", t: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.minus_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def right_set_int(s: 'const Set *', i: int) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - result = _lib.right_set_int(s_converted, i) +def minus_span_bigint(s: "const Span *", i: int) -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.minus_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def right_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.right_set_set(s1_converted, s2_converted) +def minus_span_date(s: "const Span *", d: "DateADT") -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.minus_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def right_set_text(s: 'const Set *', txt: str) -> 'bool': - s_converted = _ffi.cast('const Set *', s) - txt_converted = cstring2text(txt) - result = _lib.right_set_text(s_converted, txt_converted) +def minus_span_float(s: "const Span *", d: float) -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.minus_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def right_span_bigint(s: 'const Span *', i: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.right_span_bigint(s_converted, i_converted) +def minus_span_int(s: "const Span *", i: int) -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.minus_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def right_span_float(s: 'const Span *', d: float) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.right_span_float(s_converted, d) +def minus_span_span(s1: "const Span *", s2: "const Span *") -> "SpanSet *": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.minus_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def right_span_int(s: 'const Span *', i: int) -> 'bool': - s_converted = _ffi.cast('const Span *', s) - result = _lib.right_span_int(s_converted, i) +def minus_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.minus_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def right_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.right_span_span(s1_converted, s2_converted) +def minus_span_timestamptz(s: "const Span *", t: int) -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.minus_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def right_span_spanset(s: 'const Span *', ss: 'const SpanSet *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.right_span_spanset(s_converted, ss_converted) +def minus_spanset_bigint(ss: "const SpanSet *", i: int) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + i_converted = _ffi.cast("int64", i) + result = _lib.minus_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def right_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) - result = _lib.right_spanset_bigint(ss_converted, i_converted) +def minus_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.minus_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def right_spanset_float(ss: 'const SpanSet *', d: float) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.right_spanset_float(ss_converted, d) +def minus_spanset_float(ss: "const SpanSet *", d: float) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.minus_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def right_spanset_int(ss: 'const SpanSet *', i: int) -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.right_spanset_int(ss_converted, i) +def minus_spanset_int(ss: "const SpanSet *", i: int) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.minus_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def right_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.right_spanset_span(ss_converted, s_converted) +def minus_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.minus_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def right_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.right_spanset_spanset(ss1_converted, ss2_converted) +def minus_spanset_spanset( + ss1: "const SpanSet *", ss2: "const SpanSet *" +) -> "SpanSet *": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.minus_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def right_text_set(txt: str, s: 'const Set *') -> 'bool': - txt_converted = cstring2text(txt) - s_converted = _ffi.cast('const Set *', s) - result = _lib.right_text_set(txt_converted, s_converted) +def minus_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.minus_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def distance_set_bigint(s: 'const Set *', i: int) -> 'double': - s_converted = _ffi.cast('const Set *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.distance_set_bigint(s_converted, i_converted) +def minus_text_set(txt: str, s: "const Set *") -> "Set *": + txt_converted = cstring2text(txt) + s_converted = _ffi.cast("const Set *", s) + result = _lib.minus_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def distance_set_float(s: 'const Set *', d: float) -> 'double': - s_converted = _ffi.cast('const Set *', s) - result = _lib.distance_set_float(s_converted, d) +def minus_timestamptz_set(t: int, s: "const Set *") -> "Set *": + t_converted = _ffi.cast("TimestampTz", t) + s_converted = _ffi.cast("const Set *", s) + result = _lib.minus_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def distance_set_int(s: 'const Set *', i: int) -> 'double': - s_converted = _ffi.cast('const Set *', s) - result = _lib.distance_set_int(s_converted, i) +def minus_timestamptz_span(t: int, s: "const Span *") -> "SpanSet *": + t_converted = _ffi.cast("TimestampTz", t) + s_converted = _ffi.cast("const Span *", s) + result = _lib.minus_timestamptz_span(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def distance_set_set(s1: 'const Set *', s2: 'const Set *') -> 'double': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.distance_set_set(s1_converted, s2_converted) +def minus_timestamptz_spanset(t: int, ss: "const SpanSet *") -> "SpanSet *": + t_converted = _ffi.cast("TimestampTz", t) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.minus_timestamptz_spanset(t_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def distance_set_timestamptz(s: 'const Set *', t: int) -> 'double': - s_converted = _ffi.cast('const Set *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.distance_set_timestamptz(s_converted, t_converted) +def union_bigint_set(i: int, s: "const Set *") -> "Set *": + i_converted = _ffi.cast("int64", i) + s_converted = _ffi.cast("const Set *", s) + result = _lib.union_bigint_set(i_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def distance_set_date(s: 'const Set *', d: 'DateADT') -> 'double': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.distance_set_date(s_converted, d_converted) +def union_bigint_span(s: "const Span *", i: int) -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.union_bigint_span(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def distance_span_bigint(s: 'const Span *', i: int) -> 'double': - s_converted = _ffi.cast('const Span *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.distance_span_bigint(s_converted, i_converted) +def union_bigint_spanset(i: int, ss: "SpanSet *") -> "SpanSet *": + i_converted = _ffi.cast("int64", i) + ss_converted = _ffi.cast("SpanSet *", ss) + result = _lib.union_bigint_spanset(i_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def distance_span_float(s: 'const Span *', d: float) -> 'double': - s_converted = _ffi.cast('const Span *', s) - result = _lib.distance_span_float(s_converted, d) +def union_date_set(d: "const DateADT", s: "const Set *") -> "Set *": + d_converted = _ffi.cast("const DateADT", d) + s_converted = _ffi.cast("const Set *", s) + result = _lib.union_date_set(d_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def distance_span_int(s: 'const Span *', i: int) -> 'double': - s_converted = _ffi.cast('const Span *', s) - result = _lib.distance_span_int(s_converted, i) +def union_date_span(s: "const Span *", d: "DateADT") -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.union_date_span(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def distance_span_span(s1: 'const Span *', s2: 'const Span *') -> 'double': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.distance_span_span(s1_converted, s2_converted) +def union_date_spanset(d: "DateADT", ss: "SpanSet *") -> "SpanSet *": + d_converted = _ffi.cast("DateADT", d) + ss_converted = _ffi.cast("SpanSet *", ss) + result = _lib.union_date_spanset(d_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def distance_span_timestamptz(s: 'const Span *', t: int) -> 'double': - s_converted = _ffi.cast('const Span *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.distance_span_timestamptz(s_converted, t_converted) +def union_float_set(d: float, s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.union_float_set(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def distance_span_date(s: 'const Span *', d: 'DateADT') -> 'double': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('DateADT', d) - result = _lib.distance_span_date(s_converted, d_converted) +def union_float_span(s: "const Span *", d: float) -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.union_float_span(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_bigint(ss: 'const SpanSet *', i: int) -> 'double': - ss_converted = _ffi.cast('const SpanSet *', ss) - i_converted = _ffi.cast('int64', i) - result = _lib.distance_spanset_bigint(ss_converted, i_converted) +def union_float_spanset(d: float, ss: "SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("SpanSet *", ss) + result = _lib.union_float_spanset(d, ss_converted) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_float(ss: 'const SpanSet *', d: float) -> 'double': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.distance_spanset_float(ss_converted, d) +def union_geo_set(gs: "const GSERIALIZED *", s: "const Set *") -> "Set *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + s_converted = _ffi.cast("const Set *", s) + result = _lib.union_geo_set(gs_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_int(ss: 'const SpanSet *', i: int) -> 'double': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.distance_spanset_int(ss_converted, i) +def union_int_set(i: int, s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.union_int_set(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_timestamptz(ss: 'const SpanSet *', t: int) -> 'double': - ss_converted = _ffi.cast('const SpanSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.distance_spanset_timestamptz(ss_converted, t_converted) +def union_int_span(i: int, s: "const Span *") -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.union_int_span(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_date(ss: 'const SpanSet *', d: 'DateADT') -> 'double': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('DateADT', d) - result = _lib.distance_spanset_date(ss_converted, d_converted) +def union_int_spanset(i: int, ss: "SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("SpanSet *", ss) + result = _lib.union_int_spanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_span(ss: 'const SpanSet *', s: 'const Span *') -> 'double': - ss_converted = _ffi.cast('const SpanSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.distance_spanset_span(ss_converted, s_converted) +def union_set_bigint(s: "const Set *", i: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.union_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_spanset(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'double': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.distance_spanset_spanset(ss1_converted, ss2_converted) +def union_set_date(s: "const Set *", d: "DateADT") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.union_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def set_cmp(s1: 'const Set *', s2: 'const Set *') -> 'int': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.set_cmp(s1_converted, s2_converted) +def union_set_float(s: "const Set *", d: float) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.union_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def set_eq(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.set_eq(s1_converted, s2_converted) +def union_set_geo(s: "const Set *", gs: "const GSERIALIZED *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.union_set_geo(s_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def set_ge(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.set_ge(s1_converted, s2_converted) +def union_set_int(s: "const Set *", i: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.union_set_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def set_gt(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.set_gt(s1_converted, s2_converted) +def union_set_set(s1: "const Set *", s2: "const Set *") -> "Set *": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.union_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def set_le(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.set_le(s1_converted, s2_converted) +def union_set_text(s: "const Set *", txt: str) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + txt_converted = cstring2text(txt) + result = _lib.union_set_text(s_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def set_lt(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.set_lt(s1_converted, s2_converted) +def union_set_timestamptz(s: "const Set *", t: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + t_converted = _ffi.cast("const TimestampTz", t) + result = _lib.union_set_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def set_ne(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.set_ne(s1_converted, s2_converted) +def union_span_bigint(s: "const Span *", i: int) -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.union_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def span_cmp(s1: 'const Span *', s2: 'const Span *') -> 'int': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.span_cmp(s1_converted, s2_converted) +def union_span_date(s: "const Span *", d: "DateADT") -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.union_span_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def span_eq(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.span_eq(s1_converted, s2_converted) +def union_span_float(s: "const Span *", d: float) -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.union_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def span_ge(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.span_ge(s1_converted, s2_converted) +def union_span_int(s: "const Span *", i: int) -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.union_span_int(s_converted, i) _check_error() return result if result != _ffi.NULL else None -def span_gt(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.span_gt(s1_converted, s2_converted) +def union_span_span(s1: "const Span *", s2: "const Span *") -> "SpanSet *": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.union_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def span_le(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.span_le(s1_converted, s2_converted) +def union_span_spanset(s: "const Span *", ss: "const SpanSet *") -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.union_span_spanset(s_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def span_lt(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.span_lt(s1_converted, s2_converted) +def union_span_timestamptz(s: "const Span *", t: int) -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.union_span_timestamptz(s_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def span_ne(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.span_ne(s1_converted, s2_converted) +def union_spanset_bigint(ss: "const SpanSet *", i: int) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + i_converted = _ffi.cast("int64", i) + result = _lib.union_spanset_bigint(ss_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_cmp(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'int': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.spanset_cmp(ss1_converted, ss2_converted) +def union_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.union_spanset_date(ss_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_eq(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.spanset_eq(ss1_converted, ss2_converted) +def union_spanset_float(ss: "const SpanSet *", d: float) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.union_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def spanset_ge(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.spanset_ge(ss1_converted, ss2_converted) +def union_spanset_int(ss: "const SpanSet *", i: int) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.union_spanset_int(ss_converted, i) _check_error() return result if result != _ffi.NULL else None -def spanset_gt(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.spanset_gt(ss1_converted, ss2_converted) +def union_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.union_spanset_span(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_le(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.spanset_le(ss1_converted, ss2_converted) +def union_spanset_spanset( + ss1: "const SpanSet *", ss2: "const SpanSet *" +) -> "SpanSet *": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.union_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_lt(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.spanset_lt(ss1_converted, ss2_converted) +def union_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.union_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_ne(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.spanset_ne(ss1_converted, ss2_converted) +def union_text_set(txt: str, s: "const Set *") -> "Set *": + txt_converted = cstring2text(txt) + s_converted = _ffi.cast("const Set *", s) + result = _lib.union_text_set(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def bigint_extent_transfn(s: 'Span *', i: int) -> 'Span *': - s_converted = _ffi.cast('Span *', s) - i_converted = _ffi.cast('int64', i) - result = _lib.bigint_extent_transfn(s_converted, i_converted) +def union_timestamptz_set(t: int, s: "const Set *") -> "Set *": + t_converted = _ffi.cast("const TimestampTz", t) + s_converted = _ffi.cast("const Set *", s) + result = _lib.union_timestamptz_set(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def bigint_union_transfn(state: 'Set *', i: int) -> 'Set *': - state_converted = _ffi.cast('Set *', state) - i_converted = _ffi.cast('int64', i) - result = _lib.bigint_union_transfn(state_converted, i_converted) +def union_timestamptz_span(t: int, s: "const Span *") -> "SpanSet *": + t_converted = _ffi.cast("TimestampTz", t) + s_converted = _ffi.cast("const Span *", s) + result = _lib.union_timestamptz_span(t_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def float_extent_transfn(s: 'Span *', d: float) -> 'Span *': - s_converted = _ffi.cast('Span *', s) - result = _lib.float_extent_transfn(s_converted, d) +def union_timestamptz_spanset(t: int, ss: "SpanSet *") -> "SpanSet *": + t_converted = _ffi.cast("TimestampTz", t) + ss_converted = _ffi.cast("SpanSet *", ss) + result = _lib.union_timestamptz_spanset(t_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def float_union_transfn(state: 'Set *', d: float) -> 'Set *': - state_converted = _ffi.cast('Set *', state) - result = _lib.float_union_transfn(state_converted, d) +def distance_bigintset_bigintset(s1: "const Set *", s2: "const Set *") -> "int64": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.distance_bigintset_bigintset(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def int_extent_transfn(s: 'Span *', i: int) -> 'Span *': - s_converted = _ffi.cast('Span *', s) - result = _lib.int_extent_transfn(s_converted, i) +def distance_bigintspan_bigintspan(s1: "const Span *", s2: "const Span *") -> "int64": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.distance_bigintspan_bigintspan(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def int_union_transfn(state: 'Set *', i: int) -> 'Set *': - state_converted = _ffi.cast('Set *', state) - result = _lib.int_union_transfn(state_converted, i) +def distance_bigintspanset_bigintspan( + ss: "const SpanSet *", s: "const Span *" +) -> "int64": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.distance_bigintspanset_bigintspan(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def set_extent_transfn(span: 'Span *', set: 'const Set *') -> 'Span *': - span_converted = _ffi.cast('Span *', span) - set_converted = _ffi.cast('const Set *', set) - result = _lib.set_extent_transfn(span_converted, set_converted) +def distance_bigintspanset_bigintspanset( + ss1: "const SpanSet *", ss2: "const SpanSet *" +) -> "int64": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.distance_bigintspanset_bigintspanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def set_union_finalfn(state: 'Set *') -> 'Set *': - state_converted = _ffi.cast('Set *', state) - result = _lib.set_union_finalfn(state_converted) +def distance_dateset_dateset(s1: "const Set *", s2: "const Set *") -> "int": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.distance_dateset_dateset(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def set_union_transfn(state: 'Set *', set: 'Set *') -> 'Set *': - state_converted = _ffi.cast('Set *', state) - set_converted = _ffi.cast('Set *', set) - result = _lib.set_union_transfn(state_converted, set_converted) +def distance_datespan_datespan(s1: "const Span *", s2: "const Span *") -> "int": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.distance_datespan_datespan(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def span_extent_transfn(s1: 'Span *', s2: 'const Span *') -> 'Span *': - s1_converted = _ffi.cast('Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.span_extent_transfn(s1_converted, s2_converted) +def distance_datespanset_datespan(ss: "const SpanSet *", s: "const Span *") -> "int": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.distance_datespanset_datespan(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def span_union_transfn(state: 'SpanSet *', span: 'const Span *') -> 'SpanSet *': - state_converted = _ffi.cast('SpanSet *', state) - span_converted = _ffi.cast('const Span *', span) - result = _lib.span_union_transfn(state_converted, span_converted) +def distance_datespanset_datespanset( + ss1: "const SpanSet *", ss2: "const SpanSet *" +) -> "int": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.distance_datespanset_datespanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_extent_transfn(s: 'Span *', ss: 'const SpanSet *') -> 'Span *': - s_converted = _ffi.cast('Span *', s) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.spanset_extent_transfn(s_converted, ss_converted) +def distance_floatset_floatset(s1: "const Set *", s2: "const Set *") -> "double": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.distance_floatset_floatset(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_union_finalfn(state: 'SpanSet *') -> 'SpanSet *': - state_converted = _ffi.cast('SpanSet *', state) - result = _lib.spanset_union_finalfn(state_converted) +def distance_floatspan_floatspan(s1: "const Span *", s2: "const Span *") -> "double": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.distance_floatspan_floatspan(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_union_transfn(state: 'SpanSet *', ss: 'const SpanSet *') -> 'SpanSet *': - state_converted = _ffi.cast('SpanSet *', state) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.spanset_union_transfn(state_converted, ss_converted) +def distance_floatspanset_floatspan( + ss: "const SpanSet *", s: "const Span *" +) -> "double": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.distance_floatspanset_floatspan(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def text_union_transfn(state: 'Set *', txt: str) -> 'Set *': - state_converted = _ffi.cast('Set *', state) - txt_converted = cstring2text(txt) - result = _lib.text_union_transfn(state_converted, txt_converted) +def distance_floatspanset_floatspanset( + ss1: "const SpanSet *", ss2: "const SpanSet *" +) -> "double": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.distance_floatspanset_floatspanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_extent_transfn(s: 'Span *', t: int) -> 'Span *': - s_converted = _ffi.cast('Span *', s) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.timestamptz_extent_transfn(s_converted, t_converted) +def distance_intset_intset(s1: "const Set *", s2: "const Set *") -> "int": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.distance_intset_intset(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_tcount_transfn(state: "Optional['SkipList *']", t: int) -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.timestamptz_tcount_transfn(state_converted, t_converted) +def distance_intspan_intspan(s1: "const Span *", s2: "const Span *") -> "int": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.distance_intspan_intspan(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def timestamptz_union_transfn(state: 'Set *', t: int) -> 'Set *': - state_converted = _ffi.cast('Set *', state) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.timestamptz_union_transfn(state_converted, t_converted) +def distance_intspanset_intspan(ss: "const SpanSet *", s: "const Span *") -> "int": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.distance_intspanset_intspan(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tstzset_tcount_transfn(state: "Optional['SkipList *']", s: 'const Set *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - s_converted = _ffi.cast('const Set *', s) - result = _lib.tstzset_tcount_transfn(state_converted, s_converted) +def distance_intspanset_intspanset( + ss1: "const SpanSet *", ss2: "const SpanSet *" +) -> "int": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.distance_intspanset_intspanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_tcount_transfn(state: "Optional['SkipList *']", s: 'const Span *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - s_converted = _ffi.cast('const Span *', s) - result = _lib.tstzspan_tcount_transfn(state_converted, s_converted) +def distance_set_bigint(s: "const Set *", i: int) -> "int64": + s_converted = _ffi.cast("const Set *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.distance_set_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_tcount_transfn(state: "Optional['SkipList *']", ss: 'const SpanSet *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.tstzspanset_tcount_transfn(state_converted, ss_converted) +def distance_set_date(s: "const Set *", d: "DateADT") -> "int": + s_converted = _ffi.cast("const Set *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.distance_set_date(s_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_in(string: str) -> 'TBox *': - string_converted = string.encode('utf-8') - result = _lib.tbox_in(string_converted) +def distance_set_float(s: "const Set *", d: float) -> "double": + s_converted = _ffi.cast("const Set *", s) + result = _lib.distance_set_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def tbox_out(box: 'const TBox *', maxdd: int) -> str: - box_converted = _ffi.cast('const TBox *', box) - result = _lib.tbox_out(box_converted, maxdd) +def distance_set_int(s: "const Set *", i: int) -> "int": + s_converted = _ffi.cast("const Set *", s) + result = _lib.distance_set_int(s_converted, i) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tbox_from_wkb(wkb: bytes) -> 'TBOX *': - wkb_converted = _ffi.new('uint8_t []', wkb) - result = _lib.tbox_from_wkb(wkb_converted, len(wkb)) +def distance_set_timestamptz(s: "const Set *", t: int) -> "double": + s_converted = _ffi.cast("const Set *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.distance_set_timestamptz(s_converted, t_converted) + _check_error() return result if result != _ffi.NULL else None -def tbox_from_hexwkb(hexwkb: str) -> 'TBox *': - hexwkb_converted = hexwkb.encode('utf-8') - result = _lib.tbox_from_hexwkb(hexwkb_converted) +def distance_span_bigint(s: "const Span *", i: int) -> "int64": + s_converted = _ffi.cast("const Span *", s) + i_converted = _ffi.cast("int64", i) + result = _lib.distance_span_bigint(s_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_from_wkb(wkb: bytes) -> 'STBOX *': - wkb_converted = _ffi.new('uint8_t []', wkb) - result = _lib.stbox_from_wkb(wkb_converted, len(wkb)) +def distance_span_date(s: "const Span *", d: "DateADT") -> "int": + s_converted = _ffi.cast("const Span *", s) + d_converted = _ffi.cast("DateADT", d) + result = _lib.distance_span_date(s_converted, d_converted) + _check_error() return result if result != _ffi.NULL else None -def stbox_from_hexwkb(hexwkb: str) -> 'STBox *': - hexwkb_converted = hexwkb.encode('utf-8') - result = _lib.stbox_from_hexwkb(hexwkb_converted) +def distance_span_float(s: "const Span *", d: float) -> "double": + s_converted = _ffi.cast("const Span *", s) + result = _lib.distance_span_float(s_converted, d) _check_error() return result if result != _ffi.NULL else None -def tbox_as_wkb(box: 'const TBox *', variant: int) -> bytes: - box_converted = _ffi.cast('const TBox *', box) - variant_converted = _ffi.cast('uint8_t', variant) - size_out = _ffi.new('size_t *') - result = _lib.tbox_as_wkb(box_converted, variant_converted, size_out) +def distance_span_int(s: "const Span *", i: int) -> "int": + s_converted = _ffi.cast("const Span *", s) + result = _lib.distance_span_int(s_converted, i) _check_error() - result_converted = bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None - return result_converted + return result if result != _ffi.NULL else None -def tbox_as_hexwkb(box: 'const TBox *', variant: int) -> "Tuple[str, 'size_t *']": - box_converted = _ffi.cast('const TBox *', box) - variant_converted = _ffi.cast('uint8_t', variant) - size = _ffi.new('size_t *') - result = _lib.tbox_as_hexwkb(box_converted, variant_converted, size) +def distance_span_timestamptz(s: "const Span *", t: int) -> "double": + s_converted = _ffi.cast("const Span *", s) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.distance_span_timestamptz(s_converted, t_converted) _check_error() - result = _ffi.string(result).decode('utf-8') - return result if result != _ffi.NULL else None, size[0] + return result if result != _ffi.NULL else None -def stbox_as_wkb(box: 'const STBox *', variant: int) -> bytes: - box_converted = _ffi.cast('const STBox *', box) - variant_converted = _ffi.cast('uint8_t', variant) - size_out = _ffi.new('size_t *') - result = _lib.stbox_as_wkb(box_converted, variant_converted, size_out) +def distance_spanset_bigint(ss: "const SpanSet *", i: int) -> "int64": + ss_converted = _ffi.cast("const SpanSet *", ss) + i_converted = _ffi.cast("int64", i) + result = _lib.distance_spanset_bigint(ss_converted, i_converted) _check_error() - result_converted = bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None - return result_converted + return result if result != _ffi.NULL else None -def stbox_as_hexwkb(box: 'const STBox *', variant: int) -> "Tuple[str, 'size_t *']": - box_converted = _ffi.cast('const STBox *', box) - variant_converted = _ffi.cast('uint8_t', variant) - size = _ffi.new('size_t *') - result = _lib.stbox_as_hexwkb(box_converted, variant_converted, size) +def distance_spanset_date(ss: "const SpanSet *", d: "DateADT") -> "int": + ss_converted = _ffi.cast("const SpanSet *", ss) + d_converted = _ffi.cast("DateADT", d) + result = _lib.distance_spanset_date(ss_converted, d_converted) _check_error() - result = _ffi.string(result).decode('utf-8') - return result if result != _ffi.NULL else None, size[0] + return result if result != _ffi.NULL else None -def stbox_in(string: str) -> 'STBox *': - string_converted = string.encode('utf-8') - result = _lib.stbox_in(string_converted) +def distance_spanset_float(ss: "const SpanSet *", d: float) -> "double": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.distance_spanset_float(ss_converted, d) _check_error() return result if result != _ffi.NULL else None -def stbox_out(box: 'const STBox *', maxdd: int) -> str: - box_converted = _ffi.cast('const STBox *', box) - result = _lib.stbox_out(box_converted, maxdd) +def distance_spanset_int(ss: "const SpanSet *", i: int) -> "int": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.distance_spanset_int(ss_converted, i) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def float_tstzspan_to_tbox(d: float, s: 'const Span *') -> 'TBox *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.float_tstzspan_to_tbox(d, s_converted) +def distance_spanset_timestamptz(ss: "const SpanSet *", t: int) -> "double": + ss_converted = _ffi.cast("const SpanSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.distance_spanset_timestamptz(ss_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def float_timestamptz_to_tbox(d: float, t: int) -> 'TBox *': - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.float_timestamptz_to_tbox(d, t_converted) +def distance_tstzset_tstzset(s1: "const Set *", s2: "const Set *") -> "double": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.distance_tstzset_tstzset(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def geo_tstzspan_to_stbox(gs: 'const GSERIALIZED *', s: 'const Span *') -> 'STBox *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - s_converted = _ffi.cast('const Span *', s) - result = _lib.geo_tstzspan_to_stbox(gs_converted, s_converted) +def distance_tstzspan_tstzspan(s1: "const Span *", s2: "const Span *") -> "double": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.distance_tstzspan_tstzspan(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def geo_timestamptz_to_stbox(gs: 'const GSERIALIZED *', t: int) -> 'STBox *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.geo_timestamptz_to_stbox(gs_converted, t_converted) +def distance_tstzspanset_tstzspan(ss: "const SpanSet *", s: "const Span *") -> "double": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.distance_tstzspanset_tstzspan(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def int_tstzspan_to_tbox(i: int, s: 'const Span *') -> 'TBox *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.int_tstzspan_to_tbox(i, s_converted) +def distance_tstzspanset_tstzspanset( + ss1: "const SpanSet *", ss2: "const SpanSet *" +) -> "double": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.distance_tstzspanset_tstzspanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def int_timestamptz_to_tbox(i: int, t: int) -> 'TBox *': - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.int_timestamptz_to_tbox(i, t_converted) +def bigint_extent_transfn(state: "Span *", i: int) -> "Span *": + state_converted = _ffi.cast("Span *", state) + i_converted = _ffi.cast("int64", i) + result = _lib.bigint_extent_transfn(state_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_tstzspan_to_tbox(span: 'const Span *', s: 'const Span *') -> 'TBox *': - span_converted = _ffi.cast('const Span *', span) - s_converted = _ffi.cast('const Span *', s) - result = _lib.numspan_tstzspan_to_tbox(span_converted, s_converted) +def bigint_union_transfn(state: "Set *", i: int) -> "Set *": + state_converted = _ffi.cast("Set *", state) + i_converted = _ffi.cast("int64", i) + result = _lib.bigint_union_transfn(state_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_timestamptz_to_tbox(span: 'const Span *', t: int) -> 'TBox *': - span_converted = _ffi.cast('const Span *', span) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.numspan_timestamptz_to_tbox(span_converted, t_converted) +def date_extent_transfn(state: "Span *", d: "DateADT") -> "Span *": + state_converted = _ffi.cast("Span *", state) + d_converted = _ffi.cast("DateADT", d) + result = _lib.date_extent_transfn(state_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_copy(box: 'const STBox *') -> 'STBox *': - box_converted = _ffi.cast('const STBox *', box) - result = _lib.stbox_copy(box_converted) +def date_union_transfn(state: "Set *", d: "DateADT") -> "Set *": + state_converted = _ffi.cast("Set *", state) + d_converted = _ffi.cast("DateADT", d) + result = _lib.date_union_transfn(state_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_make(hasx: bool, hasz: bool, geodetic: bool, srid: int, xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float, s: 'const Span *') -> 'STBox *': - srid_converted = _ffi.cast('int32', srid) - s_converted = _ffi.cast('const Span *', s) - result = _lib.stbox_make(hasx, hasz, geodetic, srid_converted, xmin, xmax, ymin, ymax, zmin, zmax, s_converted) +def float_extent_transfn(state: "Span *", d: float) -> "Span *": + state_converted = _ffi.cast("Span *", state) + result = _lib.float_extent_transfn(state_converted, d) _check_error() return result if result != _ffi.NULL else None -def tbox_copy(box: 'const TBox *') -> 'TBox *': - box_converted = _ffi.cast('const TBox *', box) - result = _lib.tbox_copy(box_converted) +def float_union_transfn(state: "Set *", d: float) -> "Set *": + state_converted = _ffi.cast("Set *", state) + result = _lib.float_union_transfn(state_converted, d) _check_error() return result if result != _ffi.NULL else None -def tbox_make(s: "Optional['const Span *']", p: "Optional['const Span *']") -> 'TBox *': - s_converted = _ffi.cast('const Span *', s) if s is not None else _ffi.NULL - p_converted = _ffi.cast('const Span *', p) if p is not None else _ffi.NULL - result = _lib.tbox_make(s_converted, p_converted) +def int_extent_transfn(state: "Span *", i: int) -> "Span *": + state_converted = _ffi.cast("Span *", state) + result = _lib.int_extent_transfn(state_converted, i) _check_error() return result if result != _ffi.NULL else None -def box3d_to_stbox(box: 'const BOX3D *') -> 'STBox *': - box_converted = _ffi.cast('const BOX3D *', box) - result = _lib.box3d_to_stbox(box_converted) +def int_union_transfn(state: "Set *", i: int) -> "Set *": + state_converted = _ffi.cast("Set *", state) + i_converted = _ffi.cast("int32", i) + result = _lib.int_union_transfn(state_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def gbox_to_stbox(box: 'const GBOX *') -> 'STBox *': - box_converted = _ffi.cast('const GBOX *', box) - result = _lib.gbox_to_stbox(box_converted) +def set_extent_transfn(state: "Span *", s: "const Set *") -> "Span *": + state_converted = _ffi.cast("Span *", state) + s_converted = _ffi.cast("const Set *", s) + result = _lib.set_extent_transfn(state_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def float_to_tbox(d: float) -> 'TBox *': - result = _lib.float_to_tbox(d) +def set_union_finalfn(state: "Set *") -> "Set *": + state_converted = _ffi.cast("Set *", state) + result = _lib.set_union_finalfn(state_converted) _check_error() return result if result != _ffi.NULL else None -def geo_to_stbox(gs: 'const GSERIALIZED *') -> 'STBox *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.geo_to_stbox(gs_converted) +def set_union_transfn(state: "Set *", s: "Set *") -> "Set *": + state_converted = _ffi.cast("Set *", state) + s_converted = _ffi.cast("Set *", s) + result = _lib.set_union_transfn(state_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def int_to_tbox(i: int) -> 'TBox *': - result = _lib.int_to_tbox(i) +def span_extent_transfn(state: "Span *", s: "const Span *") -> "Span *": + state_converted = _ffi.cast("Span *", state) + s_converted = _ffi.cast("const Span *", s) + result = _lib.span_extent_transfn(state_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def numset_to_tbox(s: 'const Set *') -> 'TBox *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.numset_to_tbox(s_converted) +def span_union_transfn(state: "SpanSet *", s: "const Span *") -> "SpanSet *": + state_converted = _ffi.cast("SpanSet *", state) + s_converted = _ffi.cast("const Span *", s) + result = _lib.span_union_transfn(state_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_to_tbox(s: 'const Span *') -> 'TBox *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.numspan_to_tbox(s_converted) +def spanset_extent_transfn(state: "Span *", ss: "const SpanSet *") -> "Span *": + state_converted = _ffi.cast("Span *", state) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.spanset_extent_transfn(state_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def numspanset_to_tbox(ss: 'const SpanSet *') -> 'TBox *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.numspanset_to_tbox(ss_converted) +def spanset_union_finalfn(state: "SpanSet *") -> "SpanSet *": + state_converted = _ffi.cast("SpanSet *", state) + result = _lib.spanset_union_finalfn(state_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_to_stbox(s: 'const Span *') -> 'STBox *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.tstzspan_to_stbox(s_converted) +def spanset_union_transfn(state: "SpanSet *", ss: "const SpanSet *") -> "SpanSet *": + state_converted = _ffi.cast("SpanSet *", state) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.spanset_union_transfn(state_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_to_tbox(s: 'const Span *') -> 'TBox *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.tstzspan_to_tbox(s_converted) +def text_union_transfn(state: "Set *", txt: str) -> "Set *": + state_converted = _ffi.cast("Set *", state) + txt_converted = cstring2text(txt) + result = _lib.text_union_transfn(state_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_to_stbox(ss: 'const SpanSet *') -> 'STBox *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.tstzspanset_to_stbox(ss_converted) +def timestamptz_extent_transfn(state: "Span *", t: int) -> "Span *": + state_converted = _ffi.cast("Span *", state) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.timestamptz_extent_transfn(state_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspanset_to_tbox(ss: 'const SpanSet *') -> 'TBox *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.tstzspanset_to_tbox(ss_converted) +def timestamptz_union_transfn(state: "Set *", t: int) -> "Set *": + state_converted = _ffi.cast("Set *", state) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.timestamptz_union_transfn(state_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_to_gbox(box: 'const STBox *') -> 'GBOX *': - box_converted = _ffi.cast('const STBox *', box) - result = _lib.stbox_to_gbox(box_converted) +def tbox_in(string: str) -> "TBox *": + string_converted = string.encode("utf-8") + result = _lib.tbox_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_to_box3d(box: 'const STBox *') -> 'BOX3D *': - box_converted = _ffi.cast('const STBox *', box) - result = _lib.stbox_to_box3d(box_converted) +def tbox_out(box: "const TBox *", maxdd: int) -> str: + box_converted = _ffi.cast("const TBox *", box) + result = _lib.tbox_out(box_converted, maxdd) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def stbox_to_geo(box: 'const STBox *') -> 'GSERIALIZED *': - box_converted = _ffi.cast('const STBox *', box) - result = _lib.stbox_to_geo(box_converted) - _check_error() +def tbox_from_wkb(wkb: bytes) -> "TBOX *": + wkb_converted = _ffi.new("uint8_t []", wkb) + result = _lib.tbox_from_wkb(wkb_converted, len(wkb)) return result if result != _ffi.NULL else None -def stbox_to_tstzspan(box: 'const STBox *') -> 'Span *': - box_converted = _ffi.cast('const STBox *', box) - result = _lib.stbox_to_tstzspan(box_converted) +def tbox_from_hexwkb(hexwkb: str) -> "TBox *": + hexwkb_converted = hexwkb.encode("utf-8") + result = _lib.tbox_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_to_intspan(box: 'const TBox *') -> 'Span *': - box_converted = _ffi.cast('const TBox *', box) - result = _lib.tbox_to_intspan(box_converted) - _check_error() +def stbox_from_wkb(wkb: bytes) -> "STBOX *": + wkb_converted = _ffi.new("uint8_t []", wkb) + result = _lib.stbox_from_wkb(wkb_converted, len(wkb)) return result if result != _ffi.NULL else None -def tbox_to_floatspan(box: 'const TBox *') -> 'Span *': - box_converted = _ffi.cast('const TBox *', box) - result = _lib.tbox_to_floatspan(box_converted) +def stbox_from_hexwkb(hexwkb: str) -> "STBox *": + hexwkb_converted = hexwkb.encode("utf-8") + result = _lib.stbox_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_to_tstzspan(box: 'const TBox *') -> 'Span *': - box_converted = _ffi.cast('const TBox *', box) - result = _lib.tbox_to_tstzspan(box_converted) +def tbox_as_wkb(box: "const TBox *", variant: int) -> bytes: + box_converted = _ffi.cast("const TBox *", box) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") + result = _lib.tbox_as_wkb(box_converted, variant_converted, size_out) _check_error() - return result if result != _ffi.NULL else None + result_converted = ( + bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None + ) + return result_converted -def timestamptz_to_stbox(t: int) -> 'STBox *': - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.timestamptz_to_stbox(t_converted) +def tbox_as_hexwkb(box: "const TBox *", variant: int) -> "Tuple[str, 'size_t *']": + box_converted = _ffi.cast("const TBox *", box) + variant_converted = _ffi.cast("uint8_t", variant) + size = _ffi.new("size_t *") + result = _lib.tbox_as_hexwkb(box_converted, variant_converted, size) _check_error() - return result if result != _ffi.NULL else None + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None, size[0] -def timestamptz_to_tbox(t: int) -> 'TBox *': - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.timestamptz_to_tbox(t_converted) +def stbox_as_wkb(box: "const STBox *", variant: int) -> bytes: + box_converted = _ffi.cast("const STBox *", box) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") + result = _lib.stbox_as_wkb(box_converted, variant_converted, size_out) _check_error() - return result if result != _ffi.NULL else None + result_converted = ( + bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None + ) + return result_converted -def tstzset_to_stbox(s: 'const Set *') -> 'STBox *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.tstzset_to_stbox(s_converted) +def stbox_as_hexwkb(box: "const STBox *", variant: int) -> "Tuple[str, 'size_t *']": + box_converted = _ffi.cast("const STBox *", box) + variant_converted = _ffi.cast("uint8_t", variant) + size = _ffi.new("size_t *") + result = _lib.stbox_as_hexwkb(box_converted, variant_converted, size) _check_error() - return result if result != _ffi.NULL else None + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None, size[0] -def tstzset_to_tbox(ss: 'const Set *') -> 'TBox *': - ss_converted = _ffi.cast('const Set *', ss) - result = _lib.tstzset_to_tbox(ss_converted) +def stbox_in(string: str) -> "STBox *": + string_converted = string.encode("utf-8") + result = _lib.stbox_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_to_tbox(temp: 'const Temporal *') -> 'TBox *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tnumber_to_tbox(temp_converted) +def stbox_out(box: "const STBox *", maxdd: int) -> str: + box_converted = _ffi.cast("const STBox *", box) + result = _lib.stbox_out(box_converted, maxdd) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tpoint_to_stbox(temp: 'const Temporal *') -> 'STBox *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_to_stbox(temp_converted) +def float_tstzspan_to_tbox(d: float, s: "const Span *") -> "TBox *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.float_tstzspan_to_tbox(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_hast(box: 'const STBox *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - result = _lib.stbox_hast(box_converted) +def float_timestamptz_to_tbox(d: float, t: int) -> "TBox *": + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.float_timestamptz_to_tbox(d, t_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_hasx(box: 'const STBox *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - result = _lib.stbox_hasx(box_converted) +def geo_tstzspan_to_stbox(gs: "const GSERIALIZED *", s: "const Span *") -> "STBox *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + s_converted = _ffi.cast("const Span *", s) + result = _lib.geo_tstzspan_to_stbox(gs_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_hasz(box: 'const STBox *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - result = _lib.stbox_hasz(box_converted) +def geo_timestamptz_to_stbox(gs: "const GSERIALIZED *", t: int) -> "STBox *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.geo_timestamptz_to_stbox(gs_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_isgeodetic(box: 'const STBox *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - result = _lib.stbox_isgeodetic(box_converted) +def int_tstzspan_to_tbox(i: int, s: "const Span *") -> "TBox *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.int_tstzspan_to_tbox(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_srid(box: 'const STBox *') -> 'int32': - box_converted = _ffi.cast('const STBox *', box) - result = _lib.stbox_srid(box_converted) +def int_timestamptz_to_tbox(i: int, t: int) -> "TBox *": + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.int_timestamptz_to_tbox(i, t_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_tmax(box: 'const STBox *') -> int: - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('TimestampTz *') - result = _lib.stbox_tmax(box_converted, out_result) +def numspan_tstzspan_to_tbox(span: "const Span *", s: "const Span *") -> "TBox *": + span_converted = _ffi.cast("const Span *", span) + s_converted = _ffi.cast("const Span *", s) + result = _lib.numspan_tstzspan_to_tbox(span_converted, s_converted) _check_error() - if result: - return out_result[0] if out_result[0] != _ffi.NULL else None - return None + return result if result != _ffi.NULL else None -def stbox_tmax_inc(box: 'const STBox *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('bool *') - result = _lib.stbox_tmax_inc(box_converted, out_result) +def numspan_timestamptz_to_tbox(span: "const Span *", t: int) -> "TBox *": + span_converted = _ffi.cast("const Span *", span) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.numspan_timestamptz_to_tbox(span_converted, t_converted) _check_error() - if result: - return out_result[0] if out_result[0] != _ffi.NULL else None + return result if result != _ffi.NULL else None + + +def stbox_copy(box: "const STBox *") -> "STBox *": + box_converted = _ffi.cast("const STBox *", box) + result = _lib.stbox_copy(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def stbox_make( + hasx: bool, + hasz: bool, + geodetic: bool, + srid: int, + xmin: float, + xmax: float, + ymin: float, + ymax: float, + zmin: float, + zmax: float, + s: "const Span *", +) -> "STBox *": + srid_converted = _ffi.cast("int32", srid) + s_converted = _ffi.cast("const Span *", s) + result = _lib.stbox_make( + hasx, + hasz, + geodetic, + srid_converted, + xmin, + xmax, + ymin, + ymax, + zmin, + zmax, + s_converted, + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tbox_copy(box: "const TBox *") -> "TBox *": + box_converted = _ffi.cast("const TBox *", box) + result = _lib.tbox_copy(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tbox_make(s: "Optional['const Span *']", p: "Optional['const Span *']") -> "TBox *": + s_converted = _ffi.cast("const Span *", s) if s is not None else _ffi.NULL + p_converted = _ffi.cast("const Span *", p) if p is not None else _ffi.NULL + result = _lib.tbox_make(s_converted, p_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def float_to_tbox(d: float) -> "TBox *": + result = _lib.float_to_tbox(d) + _check_error() + return result if result != _ffi.NULL else None + + +def geo_to_stbox(gs: "const GSERIALIZED *") -> "STBox *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.geo_to_stbox(gs_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def int_to_tbox(i: int) -> "TBox *": + result = _lib.int_to_tbox(i) + _check_error() + return result if result != _ffi.NULL else None + + +def set_to_tbox(s: "const Set *") -> "TBox *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.set_to_tbox(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def span_to_tbox(s: "const Span *") -> "TBox *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.span_to_tbox(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def spanset_to_tbox(ss: "const SpanSet *") -> "TBox *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.spanset_to_tbox(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def spatialset_to_stbox(s: "const Set *") -> "STBox *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.spatialset_to_stbox(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def stbox_to_gbox(box: "const STBox *") -> "GBOX *": + box_converted = _ffi.cast("const STBox *", box) + result = _lib.stbox_to_gbox(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def stbox_to_box3d(box: "const STBox *") -> "BOX3D *": + box_converted = _ffi.cast("const STBox *", box) + result = _lib.stbox_to_box3d(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def stbox_to_geo(box: "const STBox *") -> "GSERIALIZED *": + box_converted = _ffi.cast("const STBox *", box) + result = _lib.stbox_to_geo(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def stbox_to_tstzspan(box: "const STBox *") -> "Span *": + box_converted = _ffi.cast("const STBox *", box) + result = _lib.stbox_to_tstzspan(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tstzspanset_to_tbox(ss: "const SpanSet *") -> "TBox *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.tstzspanset_to_tbox(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tbox_to_intspan(box: "const TBox *") -> "Span *": + box_converted = _ffi.cast("const TBox *", box) + result = _lib.tbox_to_intspan(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tbox_to_floatspan(box: "const TBox *") -> "Span *": + box_converted = _ffi.cast("const TBox *", box) + result = _lib.tbox_to_floatspan(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tbox_to_tstzspan(box: "const TBox *") -> "Span *": + box_converted = _ffi.cast("const TBox *", box) + result = _lib.tbox_to_tstzspan(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def timestamptz_to_stbox(t: int) -> "STBox *": + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.timestamptz_to_stbox(t_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def timestamptz_to_tbox(t: int) -> "TBox *": + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.timestamptz_to_tbox(t_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tstzset_to_stbox(s: "const Set *") -> "STBox *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.tstzset_to_stbox(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tstzspan_to_stbox(s: "const Span *") -> "STBox *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.tstzspan_to_stbox(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tstzspanset_to_stbox(ss: "const SpanSet *") -> "STBox *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.tstzspanset_to_stbox(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tnumber_to_tbox(temp: "const Temporal *") -> "TBox *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tnumber_to_tbox(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tpoint_to_stbox(temp: "const Temporal *") -> "STBox *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_to_stbox(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def stbox_hast(box: "const STBox *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + result = _lib.stbox_hast(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def stbox_hasx(box: "const STBox *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + result = _lib.stbox_hasx(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def stbox_hasz(box: "const STBox *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + result = _lib.stbox_hasz(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def stbox_isgeodetic(box: "const STBox *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + result = _lib.stbox_isgeodetic(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def stbox_srid(box: "const STBox *") -> "int32": + box_converted = _ffi.cast("const STBox *", box) + result = _lib.stbox_srid(box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def stbox_tmax(box: "const STBox *") -> int: + box_converted = _ffi.cast("const STBox *", box) + out_result = _ffi.new("TimestampTz *") + result = _lib.stbox_tmax(box_converted, out_result) + _check_error() + if result: + return out_result[0] if out_result[0] != _ffi.NULL else None + return None + + +def stbox_tmax_inc(box: "const STBox *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + out_result = _ffi.new("bool *") + result = _lib.stbox_tmax_inc(box_converted, out_result) + _check_error() + if result: + return out_result[0] if out_result[0] != _ffi.NULL else None return None -def stbox_tmin(box: 'const STBox *') -> int: - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('TimestampTz *') +def stbox_tmin(box: "const STBox *") -> int: + box_converted = _ffi.cast("const STBox *", box) + out_result = _ffi.new("TimestampTz *") result = _lib.stbox_tmin(box_converted, out_result) _check_error() if result: @@ -5255,9 +5744,9 @@ def stbox_tmin(box: 'const STBox *') -> int: return None -def stbox_tmin_inc(box: 'const STBox *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('bool *') +def stbox_tmin_inc(box: "const STBox *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + out_result = _ffi.new("bool *") result = _lib.stbox_tmin_inc(box_converted, out_result) _check_error() if result: @@ -5265,9 +5754,9 @@ def stbox_tmin_inc(box: 'const STBox *') -> 'bool': return None -def stbox_xmax(box: 'const STBox *') -> 'double': - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('double *') +def stbox_xmax(box: "const STBox *") -> "double": + box_converted = _ffi.cast("const STBox *", box) + out_result = _ffi.new("double *") result = _lib.stbox_xmax(box_converted, out_result) _check_error() if result: @@ -5275,9 +5764,9 @@ def stbox_xmax(box: 'const STBox *') -> 'double': return None -def stbox_xmin(box: 'const STBox *') -> 'double': - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('double *') +def stbox_xmin(box: "const STBox *") -> "double": + box_converted = _ffi.cast("const STBox *", box) + out_result = _ffi.new("double *") result = _lib.stbox_xmin(box_converted, out_result) _check_error() if result: @@ -5285,9 +5774,9 @@ def stbox_xmin(box: 'const STBox *') -> 'double': return None -def stbox_ymax(box: 'const STBox *') -> 'double': - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('double *') +def stbox_ymax(box: "const STBox *") -> "double": + box_converted = _ffi.cast("const STBox *", box) + out_result = _ffi.new("double *") result = _lib.stbox_ymax(box_converted, out_result) _check_error() if result: @@ -5295,9 +5784,9 @@ def stbox_ymax(box: 'const STBox *') -> 'double': return None -def stbox_ymin(box: 'const STBox *') -> 'double': - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('double *') +def stbox_ymin(box: "const STBox *") -> "double": + box_converted = _ffi.cast("const STBox *", box) + out_result = _ffi.new("double *") result = _lib.stbox_ymin(box_converted, out_result) _check_error() if result: @@ -5305,9 +5794,9 @@ def stbox_ymin(box: 'const STBox *') -> 'double': return None -def stbox_zmax(box: 'const STBox *') -> 'double': - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('double *') +def stbox_zmax(box: "const STBox *") -> "double": + box_converted = _ffi.cast("const STBox *", box) + out_result = _ffi.new("double *") result = _lib.stbox_zmax(box_converted, out_result) _check_error() if result: @@ -5315,9 +5804,9 @@ def stbox_zmax(box: 'const STBox *') -> 'double': return None -def stbox_zmin(box: 'const STBox *') -> 'double': - box_converted = _ffi.cast('const STBox *', box) - out_result = _ffi.new('double *') +def stbox_zmin(box: "const STBox *") -> "double": + box_converted = _ffi.cast("const STBox *", box) + out_result = _ffi.new("double *") result = _lib.stbox_zmin(box_converted, out_result) _check_error() if result: @@ -5325,23 +5814,23 @@ def stbox_zmin(box: 'const STBox *') -> 'double': return None -def tbox_hast(box: 'const TBox *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) +def tbox_hast(box: "const TBox *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) result = _lib.tbox_hast(box_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_hasx(box: 'const TBox *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) +def tbox_hasx(box: "const TBox *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) result = _lib.tbox_hasx(box_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_tmax(box: 'const TBox *') -> int: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('TimestampTz *') +def tbox_tmax(box: "const TBox *") -> int: + box_converted = _ffi.cast("const TBox *", box) + out_result = _ffi.new("TimestampTz *") result = _lib.tbox_tmax(box_converted, out_result) _check_error() if result: @@ -5349,9 +5838,9 @@ def tbox_tmax(box: 'const TBox *') -> int: return None -def tbox_tmax_inc(box: 'const TBox *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('bool *') +def tbox_tmax_inc(box: "const TBox *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + out_result = _ffi.new("bool *") result = _lib.tbox_tmax_inc(box_converted, out_result) _check_error() if result: @@ -5359,9 +5848,9 @@ def tbox_tmax_inc(box: 'const TBox *') -> 'bool': return None -def tbox_tmin(box: 'const TBox *') -> int: - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('TimestampTz *') +def tbox_tmin(box: "const TBox *") -> int: + box_converted = _ffi.cast("const TBox *", box) + out_result = _ffi.new("TimestampTz *") result = _lib.tbox_tmin(box_converted, out_result) _check_error() if result: @@ -5369,9 +5858,9 @@ def tbox_tmin(box: 'const TBox *') -> int: return None -def tbox_tmin_inc(box: 'const TBox *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('bool *') +def tbox_tmin_inc(box: "const TBox *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + out_result = _ffi.new("bool *") result = _lib.tbox_tmin_inc(box_converted, out_result) _check_error() if result: @@ -5379,9 +5868,9 @@ def tbox_tmin_inc(box: 'const TBox *') -> 'bool': return None -def tbox_xmax(box: 'const TBox *') -> 'double': - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('double *') +def tbox_xmax(box: "const TBox *") -> "double": + box_converted = _ffi.cast("const TBox *", box) + out_result = _ffi.new("double *") result = _lib.tbox_xmax(box_converted, out_result) _check_error() if result: @@ -5389,9 +5878,9 @@ def tbox_xmax(box: 'const TBox *') -> 'double': return None -def tbox_xmax_inc(box: 'const TBox *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('bool *') +def tbox_xmax_inc(box: "const TBox *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + out_result = _ffi.new("bool *") result = _lib.tbox_xmax_inc(box_converted, out_result) _check_error() if result: @@ -5399,9 +5888,9 @@ def tbox_xmax_inc(box: 'const TBox *') -> 'bool': return None -def tbox_xmin(box: 'const TBox *') -> 'double': - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('double *') +def tbox_xmin(box: "const TBox *") -> "double": + box_converted = _ffi.cast("const TBox *", box) + out_result = _ffi.new("double *") result = _lib.tbox_xmin(box_converted, out_result) _check_error() if result: @@ -5409,9 +5898,9 @@ def tbox_xmin(box: 'const TBox *') -> 'double': return None -def tbox_xmin_inc(box: 'const TBox *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('bool *') +def tbox_xmin_inc(box: "const TBox *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + out_result = _ffi.new("bool *") result = _lib.tbox_xmin_inc(box_converted, out_result) _check_error() if result: @@ -5419,9 +5908,9 @@ def tbox_xmin_inc(box: 'const TBox *') -> 'bool': return None -def tboxfloat_xmax(box: 'const TBox *') -> 'double': - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('double *') +def tboxfloat_xmax(box: "const TBox *") -> "double": + box_converted = _ffi.cast("const TBox *", box) + out_result = _ffi.new("double *") result = _lib.tboxfloat_xmax(box_converted, out_result) _check_error() if result: @@ -5429,9 +5918,9 @@ def tboxfloat_xmax(box: 'const TBox *') -> 'double': return None -def tboxfloat_xmin(box: 'const TBox *') -> 'double': - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('double *') +def tboxfloat_xmin(box: "const TBox *") -> "double": + box_converted = _ffi.cast("const TBox *", box) + out_result = _ffi.new("double *") result = _lib.tboxfloat_xmin(box_converted, out_result) _check_error() if result: @@ -5439,9 +5928,9 @@ def tboxfloat_xmin(box: 'const TBox *') -> 'double': return None -def tboxint_xmax(box: 'const TBox *') -> 'int': - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('int *') +def tboxint_xmax(box: "const TBox *") -> "int": + box_converted = _ffi.cast("const TBox *", box) + out_result = _ffi.new("int *") result = _lib.tboxint_xmax(box_converted, out_result) _check_error() if result: @@ -5449,9 +5938,9 @@ def tboxint_xmax(box: 'const TBox *') -> 'int': return None -def tboxint_xmin(box: 'const TBox *') -> 'int': - box_converted = _ffi.cast('const TBox *', box) - out_result = _ffi.new('int *') +def tboxint_xmin(box: "const TBox *") -> "int": + box_converted = _ffi.cast("const TBox *", box) + out_result = _ffi.new("int *") result = _lib.tboxint_xmin(box_converted, out_result) _check_error() if result: @@ -5459,1139 +5948,1222 @@ def tboxint_xmin(box: 'const TBox *') -> 'int': return None -def stbox_expand_space(box: 'const STBox *', d: float) -> 'STBox *': - box_converted = _ffi.cast('const STBox *', box) +def stbox_expand_space(box: "const STBox *", d: float) -> "STBox *": + box_converted = _ffi.cast("const STBox *", box) result = _lib.stbox_expand_space(box_converted, d) _check_error() return result if result != _ffi.NULL else None -def stbox_expand_time(box: 'const STBox *', interval: 'const Interval *') -> 'STBox *': - box_converted = _ffi.cast('const STBox *', box) - interval_converted = _ffi.cast('const Interval *', interval) - result = _lib.stbox_expand_time(box_converted, interval_converted) +def stbox_expand_time(box: "const STBox *", interv: "const Interval *") -> "STBox *": + box_converted = _ffi.cast("const STBox *", box) + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.stbox_expand_time(box_converted, interv_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_get_space(box: 'const STBox *') -> 'STBox *': - box_converted = _ffi.cast('const STBox *', box) +def stbox_get_space(box: "const STBox *") -> "STBox *": + box_converted = _ffi.cast("const STBox *", box) result = _lib.stbox_get_space(box_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_round(box: 'const STBox *', maxdd: int) -> 'STBox *': - box_converted = _ffi.cast('const STBox *', box) +def stbox_quad_split(box: "const STBox *") -> "Tuple['STBox *', 'int']": + box_converted = _ffi.cast("const STBox *", box) + count = _ffi.new("int *") + result = _lib.stbox_quad_split(box_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def stbox_round(box: "const STBox *", maxdd: int) -> "STBox *": + box_converted = _ffi.cast("const STBox *", box) result = _lib.stbox_round(box_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def stbox_set_srid(box: 'const STBox *', srid: int) -> 'STBox *': - box_converted = _ffi.cast('const STBox *', box) - srid_converted = _ffi.cast('int32', srid) +def stbox_set_srid(box: "const STBox *", srid: int) -> "STBox *": + box_converted = _ffi.cast("const STBox *", box) + srid_converted = _ffi.cast("int32", srid) result = _lib.stbox_set_srid(box_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_shift_scale_time(box: 'const STBox *', shift: "Optional['const Interval *']", duration: "Optional['const Interval *']") -> 'STBox *': - box_converted = _ffi.cast('const STBox *', box) - shift_converted = _ffi.cast('const Interval *', shift) if shift is not None else _ffi.NULL - duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL - result = _lib.stbox_shift_scale_time(box_converted, shift_converted, duration_converted) +def stbox_shift_scale_time( + box: "const STBox *", + shift: "Optional['const Interval *']", + duration: "Optional['const Interval *']", +) -> "STBox *": + box_converted = _ffi.cast("const STBox *", box) + shift_converted = ( + _ffi.cast("const Interval *", shift) if shift is not None else _ffi.NULL + ) + duration_converted = ( + _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL + ) + result = _lib.stbox_shift_scale_time( + box_converted, shift_converted, duration_converted + ) _check_error() return result if result != _ffi.NULL else None -def tbox_expand_time(box: 'const TBox *', interval: 'const Interval *') -> 'TBox *': - box_converted = _ffi.cast('const TBox *', box) - interval_converted = _ffi.cast('const Interval *', interval) - result = _lib.tbox_expand_time(box_converted, interval_converted) +def tbox_expand_time(box: "const TBox *", interv: "const Interval *") -> "TBox *": + box_converted = _ffi.cast("const TBox *", box) + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.tbox_expand_time(box_converted, interv_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_expand_float(box: 'const TBox *', d: 'const double') -> 'TBox *': - box_converted = _ffi.cast('const TBox *', box) - d_converted = _ffi.cast('const double', d) +def tbox_expand_float(box: "const TBox *", d: "const double") -> "TBox *": + box_converted = _ffi.cast("const TBox *", box) + d_converted = _ffi.cast("const double", d) result = _lib.tbox_expand_float(box_converted, d_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_expand_int(box: 'const TBox *', i: 'const int') -> 'TBox *': - box_converted = _ffi.cast('const TBox *', box) - i_converted = _ffi.cast('const int', i) +def tbox_expand_int(box: "const TBox *", i: "const int") -> "TBox *": + box_converted = _ffi.cast("const TBox *", box) + i_converted = _ffi.cast("const int", i) result = _lib.tbox_expand_int(box_converted, i_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_round(box: 'const TBox *', maxdd: int) -> 'TBox *': - box_converted = _ffi.cast('const TBox *', box) +def tbox_round(box: "const TBox *", maxdd: int) -> "TBox *": + box_converted = _ffi.cast("const TBox *", box) result = _lib.tbox_round(box_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def tbox_shift_scale_float(box: 'const TBox *', shift: float, width: float, hasshift: bool, haswidth: bool) -> 'TBox *': - box_converted = _ffi.cast('const TBox *', box) - result = _lib.tbox_shift_scale_float(box_converted, shift, width, hasshift, haswidth) +def tbox_shift_scale_float( + box: "const TBox *", shift: float, width: float, hasshift: bool, haswidth: bool +) -> "TBox *": + box_converted = _ffi.cast("const TBox *", box) + result = _lib.tbox_shift_scale_float( + box_converted, shift, width, hasshift, haswidth + ) _check_error() return result if result != _ffi.NULL else None -def tbox_shift_scale_int(box: 'const TBox *', shift: int, width: int, hasshift: bool, haswidth: bool) -> 'TBox *': - box_converted = _ffi.cast('const TBox *', box) +def tbox_shift_scale_int( + box: "const TBox *", shift: int, width: int, hasshift: bool, haswidth: bool +) -> "TBox *": + box_converted = _ffi.cast("const TBox *", box) result = _lib.tbox_shift_scale_int(box_converted, shift, width, hasshift, haswidth) _check_error() return result if result != _ffi.NULL else None -def tbox_shift_scale_time(box: 'const TBox *', shift: "Optional['const Interval *']", duration: "Optional['const Interval *']") -> 'TBox *': - box_converted = _ffi.cast('const TBox *', box) - shift_converted = _ffi.cast('const Interval *', shift) if shift is not None else _ffi.NULL - duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL - result = _lib.tbox_shift_scale_time(box_converted, shift_converted, duration_converted) +def tbox_shift_scale_time( + box: "const TBox *", + shift: "Optional['const Interval *']", + duration: "Optional['const Interval *']", +) -> "TBox *": + box_converted = _ffi.cast("const TBox *", box) + shift_converted = ( + _ffi.cast("const Interval *", shift) if shift is not None else _ffi.NULL + ) + duration_converted = ( + _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL + ) + result = _lib.tbox_shift_scale_time( + box_converted, shift_converted, duration_converted + ) _check_error() return result if result != _ffi.NULL else None -def union_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *', strict: bool) -> 'TBox *': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def union_tbox_tbox( + box1: "const TBox *", box2: "const TBox *", strict: bool +) -> "TBox *": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.union_tbox_tbox(box1_converted, box2_converted, strict) _check_error() return result if result != _ffi.NULL else None -def inter_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'TBox *': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) - out_result = _ffi.new('TBox *') - result = _lib.inter_tbox_tbox(box1_converted, box2_converted, out_result) - _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None - - -def intersection_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'TBox *': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def intersection_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "TBox *": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.intersection_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def union_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *', strict: bool) -> 'STBox *': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def union_stbox_stbox( + box1: "const STBox *", box2: "const STBox *", strict: bool +) -> "STBox *": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.union_stbox_stbox(box1_converted, box2_converted, strict) _check_error() return result if result != _ffi.NULL else None -def inter_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'STBox *': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) - out_result = _ffi.new('STBox *') - result = _lib.inter_stbox_stbox(box1_converted, box2_converted, out_result) - _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None - - -def intersection_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'STBox *': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def intersection_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "STBox *": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.intersection_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) - result = _lib.contains_tbox_tbox(box1_converted, box2_converted) +def adjacent_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) + result = _lib.adjacent_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) - result = _lib.contained_tbox_tbox(box1_converted, box2_converted) +def adjacent_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) + result = _lib.adjacent_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) - result = _lib.overlaps_tbox_tbox(box1_converted, box2_converted) +def contained_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) + result = _lib.contained_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def same_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) - result = _lib.same_tbox_tbox(box1_converted, box2_converted) +def contained_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) + result = _lib.contained_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) - result = _lib.adjacent_tbox_tbox(box1_converted, box2_converted) +def contains_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) + result = _lib.contains_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) - result = _lib.contains_stbox_stbox(box1_converted, box2_converted) +def contains_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) + result = _lib.contains_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) - result = _lib.contained_stbox_stbox(box1_converted, box2_converted) +def overlaps_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) + result = _lib.overlaps_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overlaps_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.overlaps_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def same_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) - result = _lib.same_stbox_stbox(box1_converted, box2_converted) +def same_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) + result = _lib.same_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) - result = _lib.adjacent_stbox_stbox(box1_converted, box2_converted) +def same_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) + result = _lib.same_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def left_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def left_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.left_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def overleft_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.overleft_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def right_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def right_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.right_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def overright_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.overright_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def before_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def before_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.before_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def overbefore_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.overbefore_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def after_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def after_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.after_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def overafter_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.overafter_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def left_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def left_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.left_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overleft_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.overleft_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def right_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def right_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.right_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overright_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.overright_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def below_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def below_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.below_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overbelow_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.overbelow_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def above_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def above_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.above_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overabove_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.overabove_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def front_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def front_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.front_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overfront_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.overfront_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def back_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def back_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.back_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overback_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overback_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.overback_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def before_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def before_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.before_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overbefore_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.overbefore_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def after_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def after_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.after_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def overafter_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.overafter_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_quad_split(box: 'const STBox *') -> "Tuple['STBox *', 'int']": - box_converted = _ffi.cast('const STBox *', box) - count = _ffi.new('int *') - result = _lib.stbox_quad_split(box_converted, count) - _check_error() - return result if result != _ffi.NULL else None, count[0] - - -def tbox_eq(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_eq(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.tbox_eq(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_ne(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_ne(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.tbox_ne(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_cmp(box1: 'const TBox *', box2: 'const TBox *') -> 'int': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_cmp(box1: "const TBox *", box2: "const TBox *") -> "int": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.tbox_cmp(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_lt(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_lt(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.tbox_lt(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_le(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_le(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.tbox_le(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_ge(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_ge(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.tbox_ge(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_gt(box1: 'const TBox *', box2: 'const TBox *') -> 'bool': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) +def tbox_gt(box1: "const TBox *", box2: "const TBox *") -> "bool": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) result = _lib.tbox_gt(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_eq(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_eq(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.stbox_eq(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_ne(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_ne(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.stbox_ne(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_cmp(box1: 'const STBox *', box2: 'const STBox *') -> 'int': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_cmp(box1: "const STBox *", box2: "const STBox *") -> "int": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.stbox_cmp(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_lt(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_lt(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.stbox_lt(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_le(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_le(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.stbox_le(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_ge(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_ge(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.stbox_ge(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_gt(box1: 'const STBox *', box2: 'const STBox *') -> 'bool': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) +def stbox_gt(box1: "const STBox *", box2: "const STBox *") -> "bool": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) result = _lib.stbox_gt(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_in(string: str) -> 'Temporal *': - string_converted = string.encode('utf-8') +def tbool_in(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") result = _lib.tbool_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_out(temp: 'const Temporal *') -> str: - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_out(temp: "const Temporal *") -> str: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tbool_out(temp_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def temporal_as_hexwkb(temp: 'const Temporal *', variant: int) -> "Tuple[str, 'size_t *']": - temp_converted = _ffi.cast('const Temporal *', temp) - variant_converted = _ffi.cast('uint8_t', variant) - size_out = _ffi.new('size_t *') +def temporal_as_hexwkb( + temp: "const Temporal *", variant: int +) -> "Tuple[str, 'size_t *']": + temp_converted = _ffi.cast("const Temporal *", temp) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") result = _lib.temporal_as_hexwkb(temp_converted, variant_converted, size_out) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None, size_out[0] -def temporal_as_mfjson(temp: 'const Temporal *', with_bbox: bool, flags: int, precision: int, srs: "Optional[str]") -> str: - temp_converted = _ffi.cast('const Temporal *', temp) - srs_converted = srs.encode('utf-8') if srs is not None else _ffi.NULL - result = _lib.temporal_as_mfjson(temp_converted, with_bbox, flags, precision, srs_converted) +def temporal_as_mfjson( + temp: "const Temporal *", + with_bbox: bool, + flags: int, + precision: int, + srs: "Optional[str]", +) -> str: + temp_converted = _ffi.cast("const Temporal *", temp) + srs_converted = srs.encode("utf-8") if srs is not None else _ffi.NULL + result = _lib.temporal_as_mfjson( + temp_converted, with_bbox, flags, precision, srs_converted + ) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def temporal_as_wkb(temp: 'const Temporal *', variant: int) -> bytes: - temp_converted = _ffi.cast('const Temporal *', temp) - variant_converted = _ffi.cast('uint8_t', variant) - size_out = _ffi.new('size_t *') +def temporal_as_wkb(temp: "const Temporal *", variant: int) -> bytes: + temp_converted = _ffi.cast("const Temporal *", temp) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") result = _lib.temporal_as_wkb(temp_converted, variant_converted, size_out) _check_error() - result_converted = bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None + result_converted = ( + bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None + ) return result_converted -def temporal_from_hexwkb(hexwkb: str) -> 'Temporal *': - hexwkb_converted = hexwkb.encode('utf-8') +def temporal_from_hexwkb(hexwkb: str) -> "Temporal *": + hexwkb_converted = hexwkb.encode("utf-8") result = _lib.temporal_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_from_mfjson(mfjson: str) -> 'Temporal *': - mfjson_converted = mfjson.encode('utf-8') +def temporal_from_mfjson(mfjson: str) -> "Temporal *": + mfjson_converted = mfjson.encode("utf-8") result = _lib.temporal_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_from_wkb(wkb: bytes) -> 'Temporal *': - wkb_converted = _ffi.new('uint8_t []', wkb) +def temporal_from_wkb(wkb: bytes) -> "Temporal *": + wkb_converted = _ffi.new("uint8_t []", wkb) result = _lib.temporal_from_wkb(wkb_converted, len(wkb)) return result if result != _ffi.NULL else None -def tfloat_in(string: str) -> 'Temporal *': - string_converted = string.encode('utf-8') +def tfloat_in(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") result = _lib.tfloat_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_out(temp: 'const Temporal *', maxdd: int) -> str: - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_out(temp: "const Temporal *", maxdd: int) -> str: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_out(temp_converted, maxdd) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tgeogpoint_in(string: str) -> 'Temporal *': - string_converted = string.encode('utf-8') +def tgeogpoint_in(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") result = _lib.tgeogpoint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_in(string: str) -> 'Temporal *': - string_converted = string.encode('utf-8') +def tgeompoint_in(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") result = _lib.tgeompoint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tint_in(string: str) -> 'Temporal *': - string_converted = string.encode('utf-8') +def tint_in(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") result = _lib.tint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tint_out(temp: 'const Temporal *') -> str: - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_out(temp: "const Temporal *") -> str: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tint_out(temp_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tpoint_as_ewkt(temp: 'const Temporal *', maxdd: int) -> str: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_as_ewkt(temp: "const Temporal *", maxdd: int) -> str: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tpoint_as_ewkt(temp_converted, maxdd) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tpoint_as_text(temp: 'const Temporal *', maxdd: int) -> str: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_as_text(temp: "const Temporal *", maxdd: int) -> str: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tpoint_as_text(temp_converted, maxdd) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tpoint_out(temp: 'const Temporal *', maxdd: int) -> str: - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_out(temp: "const Temporal *", maxdd: int) -> str: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tpoint_out(temp_converted, maxdd) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def ttext_in(string: str) -> 'Temporal *': - string_converted = string.encode('utf-8') +def ttext_in(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") result = _lib.ttext_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_out(temp: 'const Temporal *') -> str: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_out(temp: "const Temporal *") -> str: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.ttext_out(temp_converted) _check_error() - result = _ffi.string(result).decode('utf-8') - return result if result != _ffi.NULL else None - - -def temporal_cp(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_cp(temp_converted) - _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tbool_from_base_temp(b: bool, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_from_base_temp(b: bool, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tbool_from_base_temp(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tboolinst_make(b: bool, t: int) -> 'TInstant *': - t_converted = _ffi.cast('TimestampTz', t) +def tboolinst_make(b: bool, t: int) -> "TInstant *": + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tboolinst_make(b, t_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseq_from_base_tstzset(b: bool, s: 'const Set *') -> 'TSequence *': - s_converted = _ffi.cast('const Set *', s) +def tboolseq_from_base_tstzset(b: bool, s: "const Set *") -> "TSequence *": + s_converted = _ffi.cast("const Set *", s) result = _lib.tboolseq_from_base_tstzset(b, s_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseq_from_base_tstzspan(b: bool, s: 'const Span *') -> 'TSequence *': - s_converted = _ffi.cast('const Span *', s) +def tboolseq_from_base_tstzspan(b: bool, s: "const Span *") -> "TSequence *": + s_converted = _ffi.cast("const Span *", s) result = _lib.tboolseq_from_base_tstzspan(b, s_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseqset_from_base_tstzspanset(b: bool, ss: 'const SpanSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) +def tboolseqset_from_base_tstzspanset( + b: bool, ss: "const SpanSet *" +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tboolseqset_from_base_tstzspanset(b, ss_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_copy(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_copy(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_copy(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_from_base_temp(d: float, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_from_base_temp(d: float, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_from_base_temp(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatinst_make(d: float, t: int) -> 'TInstant *': - t_converted = _ffi.cast('TimestampTz', t) +def tfloatinst_make(d: float, t: int) -> "TInstant *": + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tfloatinst_make(d, t_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseq_from_base_tstzspan(d: float, s: 'const Span *', interp: 'interpType') -> 'TSequence *': - s_converted = _ffi.cast('const Span *', s) - interp_converted = _ffi.cast('interpType', interp) +def tfloatseq_from_base_tstzspan( + d: float, s: "const Span *", interp: "interpType" +) -> "TSequence *": + s_converted = _ffi.cast("const Span *", s) + interp_converted = _ffi.cast("interpType", interp) result = _lib.tfloatseq_from_base_tstzspan(d, s_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseq_from_base_tstzset(d: float, s: 'const Set *') -> 'TSequence *': - s_converted = _ffi.cast('const Set *', s) +def tfloatseq_from_base_tstzset(d: float, s: "const Set *") -> "TSequence *": + s_converted = _ffi.cast("const Set *", s) result = _lib.tfloatseq_from_base_tstzset(d, s_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseqset_from_base_tstzspanset(d: float, ss: 'const SpanSet *', interp: 'interpType') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - interp_converted = _ffi.cast('interpType', interp) +def tfloatseqset_from_base_tstzspanset( + d: float, ss: "const SpanSet *", interp: "interpType" +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + interp_converted = _ffi.cast("interpType", interp) result = _lib.tfloatseqset_from_base_tstzspanset(d, ss_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_from_base_temp(i: int, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_from_base_temp(i: int, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tint_from_base_temp(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tintinst_make(i: int, t: int) -> 'TInstant *': - t_converted = _ffi.cast('TimestampTz', t) +def tintinst_make(i: int, t: int) -> "TInstant *": + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tintinst_make(i, t_converted) _check_error() return result if result != _ffi.NULL else None -def tintseq_from_base_tstzspan(i: int, s: 'const Span *') -> 'TSequence *': - s_converted = _ffi.cast('const Span *', s) +def tintseq_from_base_tstzspan(i: int, s: "const Span *") -> "TSequence *": + s_converted = _ffi.cast("const Span *", s) result = _lib.tintseq_from_base_tstzspan(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def tintseq_from_base_tstzset(i: int, s: 'const Set *') -> 'TSequence *': - s_converted = _ffi.cast('const Set *', s) +def tintseq_from_base_tstzset(i: int, s: "const Set *") -> "TSequence *": + s_converted = _ffi.cast("const Set *", s) result = _lib.tintseq_from_base_tstzset(i, s_converted) _check_error() return result if result != _ffi.NULL else None -def tintseqset_from_base_tstzspanset(i: int, ss: 'const SpanSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) +def tintseqset_from_base_tstzspanset(i: int, ss: "const SpanSet *") -> "TSequenceSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tintseqset_from_base_tstzspanset(i, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_from_base_temp(gs: 'const GSERIALIZED *', temp: 'const Temporal *') -> 'Temporal *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_from_base_temp( + gs: "const GSERIALIZED *", temp: "const Temporal *" +) -> "Temporal *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tpoint_from_base_temp(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpointinst_make(gs: 'const GSERIALIZED *', t: int) -> 'TInstant *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - t_converted = _ffi.cast('TimestampTz', t) +def tpointinst_make(gs: "const GSERIALIZED *", t: int) -> "TInstant *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.tpointinst_make(gs_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_from_base_tstzspan(gs: 'const GSERIALIZED *', s: 'const Span *', interp: 'interpType') -> 'TSequence *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - s_converted = _ffi.cast('const Span *', s) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tpointseq_from_base_tstzspan(gs_converted, s_converted, interp_converted) +def tpointseq_from_base_tstzspan( + gs: "const GSERIALIZED *", s: "const Span *", interp: "interpType" +) -> "TSequence *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + s_converted = _ffi.cast("const Span *", s) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tpointseq_from_base_tstzspan( + gs_converted, s_converted, interp_converted + ) _check_error() return result if result != _ffi.NULL else None -def tpointseq_from_base_tstzset(gs: 'const GSERIALIZED *', s: 'const Set *') -> 'TSequence *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - s_converted = _ffi.cast('const Set *', s) +def tpointseq_from_base_tstzset( + gs: "const GSERIALIZED *", s: "const Set *" +) -> "TSequence *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + s_converted = _ffi.cast("const Set *", s) result = _lib.tpointseq_from_base_tstzset(gs_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_from_base_tstzspanset(gs: 'const GSERIALIZED *', ss: 'const SpanSet *', interp: 'interpType') -> 'TSequenceSet *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - ss_converted = _ffi.cast('const SpanSet *', ss) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tpointseqset_from_base_tstzspanset(gs_converted, ss_converted, interp_converted) +def tpointseqset_from_base_tstzspanset( + gs: "const GSERIALIZED *", ss: "const SpanSet *", interp: "interpType" +) -> "TSequenceSet *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + ss_converted = _ffi.cast("const SpanSet *", ss) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tpointseqset_from_base_tstzspanset( + gs_converted, ss_converted, interp_converted + ) _check_error() return result if result != _ffi.NULL else None -def tsequence_make(instants: 'const TInstant **', count: int, lower_inc: bool, upper_inc: bool, interp: 'interpType', normalize: bool) -> 'TSequence *': - instants_converted = [_ffi.cast('const TInstant *', x) for x in instants] - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tsequence_make(instants_converted, count, lower_inc, upper_inc, interp_converted, normalize) +def tsequence_make( + instants: "const TInstant **", + count: int, + lower_inc: bool, + upper_inc: bool, + interp: "interpType", + normalize: bool, +) -> "TSequence *": + instants_converted = [_ffi.cast("const TInstant *", x) for x in instants] + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tsequence_make( + instants_converted, count, lower_inc, upper_inc, interp_converted, normalize + ) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_make(sequences: 'const TSequence **', count: int, normalize: bool) -> 'TSequenceSet *': - sequences_converted = [_ffi.cast('const TSequence *', x) for x in sequences] +def tsequenceset_make( + sequences: "const TSequence **", count: int, normalize: bool +) -> "TSequenceSet *": + sequences_converted = [_ffi.cast("const TSequence *", x) for x in sequences] result = _lib.tsequenceset_make(sequences_converted, count, normalize) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_make_gaps(instants: 'const TInstant **', count: int, interp: 'interpType', maxt: 'Interval *', maxdist: float) -> 'TSequenceSet *': - instants_converted = [_ffi.cast('const TInstant *', x) for x in instants] - interp_converted = _ffi.cast('interpType', interp) - maxt_converted = _ffi.cast('Interval *', maxt) - result = _lib.tsequenceset_make_gaps(instants_converted, count, interp_converted, maxt_converted, maxdist) +def tsequenceset_make_gaps( + instants: "const TInstant **", + count: int, + interp: "interpType", + maxt: "Interval *", + maxdist: float, +) -> "TSequenceSet *": + instants_converted = [_ffi.cast("const TInstant *", x) for x in instants] + interp_converted = _ffi.cast("interpType", interp) + maxt_converted = _ffi.cast("Interval *", maxt) + result = _lib.tsequenceset_make_gaps( + instants_converted, count, interp_converted, maxt_converted, maxdist + ) _check_error() return result if result != _ffi.NULL else None -def ttext_from_base_temp(txt: str, temp: 'const Temporal *') -> 'Temporal *': +def ttext_from_base_temp(txt: str, temp: "const Temporal *") -> "Temporal *": txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.ttext_from_base_temp(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ttextinst_make(txt: str, t: int) -> 'TInstant *': +def ttextinst_make(txt: str, t: int) -> "TInstant *": txt_converted = cstring2text(txt) - t_converted = _ffi.cast('TimestampTz', t) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.ttextinst_make(txt_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def ttextseq_from_base_tstzspan(txt: str, s: 'const Span *') -> 'TSequence *': +def ttextseq_from_base_tstzspan(txt: str, s: "const Span *") -> "TSequence *": txt_converted = cstring2text(txt) - s_converted = _ffi.cast('const Span *', s) + s_converted = _ffi.cast("const Span *", s) result = _lib.ttextseq_from_base_tstzspan(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def ttextseq_from_base_tstzset(txt: str, s: 'const Set *') -> 'TSequence *': +def ttextseq_from_base_tstzset(txt: str, s: "const Set *") -> "TSequence *": txt_converted = cstring2text(txt) - s_converted = _ffi.cast('const Set *', s) + s_converted = _ffi.cast("const Set *", s) result = _lib.ttextseq_from_base_tstzset(txt_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def ttextseqset_from_base_tstzspanset(txt: str, ss: 'const SpanSet *') -> 'TSequenceSet *': +def ttextseqset_from_base_tstzspanset( + txt: str, ss: "const SpanSet *" +) -> "TSequenceSet *": txt_converted = cstring2text(txt) - ss_converted = _ffi.cast('const SpanSet *', ss) + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.ttextseqset_from_base_tstzspanset(txt_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_to_tstzspan(temp: 'const Temporal *') -> 'Span *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_to_tstzspan(temp: "const Temporal *") -> "Span *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_to_tstzspan(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_to_tint(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_to_tint(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_to_tint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_to_tfloat(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_to_tfloat(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tint_to_tfloat(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_to_span(temp: 'const Temporal *') -> 'Span *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tnumber_to_span(temp: "const Temporal *") -> "Span *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tnumber_to_span(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_end_value(temp: 'const Temporal *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_end_value(temp: "const Temporal *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tbool_end_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_start_value(temp: 'const Temporal *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_start_value(temp: "const Temporal *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tbool_start_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_values(temp: 'const Temporal *') -> "Tuple['bool *', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tbool_value_at_timestamptz( + temp: "const Temporal *", t: int, strict: bool +) -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) + out_result = _ffi.new("bool *") + result = _lib.tbool_value_at_timestamptz( + temp_converted, t_converted, strict, out_result + ) + _check_error() + if result: + return out_result[0] if out_result[0] != _ffi.NULL else None + return None + + +def tbool_values(temp: "const Temporal *") -> "Tuple['bool *', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tbool_values(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_duration(temp: 'const Temporal *', boundspan: bool) -> 'Interval *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_duration(temp: "const Temporal *", boundspan: bool) -> "Interval *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_duration(temp_converted, boundspan) _check_error() return result if result != _ffi.NULL else None -def temporal_end_instant(temp: 'const Temporal *') -> 'const TInstant *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_end_instant(temp: "const Temporal *") -> "TInstant *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_end_instant(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_end_sequence(temp: 'const Temporal *') -> 'TSequence *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_end_sequence(temp: "const Temporal *") -> "TSequence *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_end_sequence(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_end_timestamptz(temp: 'const Temporal *') -> 'TimestampTz': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_end_timestamptz(temp: "const Temporal *") -> "TimestampTz": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_end_timestamptz(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_hash(temp: 'const Temporal *') -> 'uint32': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_hash(temp: "const Temporal *") -> "uint32": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_hash(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_instant_n(temp: 'const Temporal *', n: int) -> 'const TInstant *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_instant_n(temp: "const Temporal *", n: int) -> "TInstant *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_instant_n(temp_converted, n) _check_error() return result if result != _ffi.NULL else None -def temporal_instants(temp: 'const Temporal *') -> "Tuple['const TInstant **', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_instants(temp: "const Temporal *") -> "Tuple['TInstant **', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.temporal_instants(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_interp(temp: 'const Temporal *') -> str: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_interp(temp: "const Temporal *") -> str: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_interp(temp_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def temporal_max_instant(temp: 'const Temporal *') -> 'const TInstant *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_max_instant(temp: "const Temporal *") -> "TInstant *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_max_instant(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_min_instant(temp: 'const Temporal *') -> 'const TInstant *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_min_instant(temp: "const Temporal *") -> "TInstant *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_min_instant(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_num_instants(temp: 'const Temporal *') -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_num_instants(temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_num_instants(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_num_sequences(temp: 'const Temporal *') -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_num_sequences(temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_num_sequences(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_num_timestamps(temp: 'const Temporal *') -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_num_timestamps(temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_num_timestamps(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_segments(temp: 'const Temporal *') -> "Tuple['TSequence **', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_segments(temp: "const Temporal *") -> "Tuple['TSequence **', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.temporal_segments(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_sequence_n(temp: 'const Temporal *', i: int) -> 'TSequence *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_sequence_n(temp: "const Temporal *", i: int) -> "TSequence *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_sequence_n(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def temporal_sequences(temp: 'const Temporal *') -> "Tuple['TSequence **', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_sequences(temp: "const Temporal *") -> "Tuple['TSequence **', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.temporal_sequences(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_start_instant(temp: 'const Temporal *') -> 'const TInstant *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_lower_inc(temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_lower_inc(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_upper_inc(temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_upper_inc(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_start_instant(temp: "const Temporal *") -> "TInstant *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_start_instant(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_start_sequence(temp: 'const Temporal *') -> 'TSequence *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_start_sequence(temp: "const Temporal *") -> "TSequence *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_start_sequence(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_start_timestamptz(temp: 'const Temporal *') -> 'TimestampTz': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_start_timestamptz(temp: "const Temporal *") -> "TimestampTz": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_start_timestamptz(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_stops(temp: 'const Temporal *', maxdist: float, minduration: 'const Interval *') -> 'TSequenceSet *': - temp_converted = _ffi.cast('const Temporal *', temp) - minduration_converted = _ffi.cast('const Interval *', minduration) +def temporal_stops( + temp: "const Temporal *", maxdist: float, minduration: "const Interval *" +) -> "TSequenceSet *": + temp_converted = _ffi.cast("const Temporal *", temp) + minduration_converted = _ffi.cast("const Interval *", minduration) result = _lib.temporal_stops(temp_converted, maxdist, minduration_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_subtype(temp: 'const Temporal *') -> str: - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_subtype(temp: "const Temporal *") -> str: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_subtype(temp_converted) _check_error() - result = _ffi.string(result).decode('utf-8') + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def temporal_time(temp: 'const Temporal *') -> 'SpanSet *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_time(temp: "const Temporal *") -> "SpanSet *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_time(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_timestamptz_n(temp: 'const Temporal *', n: int) -> int: - temp_converted = _ffi.cast('const Temporal *', temp) - out_result = _ffi.new('TimestampTz *') +def temporal_timestamptz_n(temp: "const Temporal *", n: int) -> int: + temp_converted = _ffi.cast("const Temporal *", temp) + out_result = _ffi.new("TimestampTz *") result = _lib.temporal_timestamptz_n(temp_converted, n, out_result) _check_error() if result: @@ -6599,6703 +7171,8168 @@ def temporal_timestamptz_n(temp: 'const Temporal *', n: int) -> int: return None -def temporal_timestamps(temp: 'const Temporal *') -> "Tuple['TimestampTz *', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def temporal_timestamps(temp: "const Temporal *") -> "Tuple['TimestampTz *', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.temporal_timestamps(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tfloat_end_value(temp: 'const Temporal *') -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_end_value(temp: "const Temporal *") -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_end_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_max_value(temp: 'const Temporal *') -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_max_value(temp: "const Temporal *") -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_max_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_min_value(temp: 'const Temporal *') -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_min_value(temp: "const Temporal *") -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_min_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_start_value(temp: 'const Temporal *') -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_start_value(temp: "const Temporal *") -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_start_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_values(temp: 'const Temporal *') -> "Tuple['double *', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tfloat_value_at_timestamptz( + temp: "const Temporal *", t: int, strict: bool +) -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) + out_result = _ffi.new("double *") + result = _lib.tfloat_value_at_timestamptz( + temp_converted, t_converted, strict, out_result + ) + _check_error() + if result: + return out_result[0] if out_result[0] != _ffi.NULL else None + return None + + +def tfloat_values(temp: "const Temporal *") -> "Tuple['double *', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tfloat_values(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tint_end_value(temp: 'const Temporal *') -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_end_value(temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tint_end_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_max_value(temp: 'const Temporal *') -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_max_value(temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tint_max_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_min_value(temp: 'const Temporal *') -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_min_value(temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tint_min_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_start_value(temp: 'const Temporal *') -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_start_value(temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tint_start_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_values(temp: 'const Temporal *') -> "Tuple['int *', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tint_value_at_timestamptz(temp: "const Temporal *", t: int, strict: bool) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) + out_result = _ffi.new("int *") + result = _lib.tint_value_at_timestamptz( + temp_converted, t_converted, strict, out_result + ) + _check_error() + if result: + return out_result[0] if out_result[0] != _ffi.NULL else None + return None + + +def tint_values(temp: "const Temporal *") -> "Tuple['int *', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tint_values(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tnumber_valuespans(temp: 'const Temporal *') -> 'SpanSet *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tnumber_valuespans(temp_converted) +def tnumber_integral(temp: "const Temporal *") -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tnumber_integral(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tnumber_twavg(temp: "const Temporal *") -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tnumber_twavg(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tnumber_valuespans(temp: "const Temporal *") -> "SpanSet *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tnumber_valuespans(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_end_value(temp: 'const Temporal *') -> 'GSERIALIZED *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_end_value(temp: "const Temporal *") -> "GSERIALIZED *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tpoint_end_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_start_value(temp: 'const Temporal *') -> 'GSERIALIZED *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tpoint_start_value(temp: "const Temporal *") -> "GSERIALIZED *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tpoint_start_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_values(temp: 'const Temporal *') -> "Tuple['GSERIALIZED **', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def tpoint_value_at_timestamptz( + temp: "const Temporal *", t: int, strict: bool +) -> "GSERIALIZED **": + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) + out_result = _ffi.new("GSERIALIZED **") + result = _lib.tpoint_value_at_timestamptz( + temp_converted, t_converted, strict, out_result + ) + _check_error() + if result: + return out_result if out_result != _ffi.NULL else None + return None + + +def tpoint_values(temp: "const Temporal *") -> "Tuple['GSERIALIZED **', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.tpoint_values(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def ttext_end_value(temp: 'const Temporal *') -> str: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_end_value(temp: "const Temporal *") -> str: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.ttext_end_value(temp_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def ttext_max_value(temp: 'const Temporal *') -> str: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_max_value(temp: "const Temporal *") -> str: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.ttext_max_value(temp_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def ttext_min_value(temp: 'const Temporal *') -> str: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_min_value(temp: "const Temporal *") -> str: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.ttext_min_value(temp_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def ttext_start_value(temp: 'const Temporal *') -> str: - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_start_value(temp: "const Temporal *") -> str: + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.ttext_start_value(temp_converted) _check_error() result = text2cstring(result) return result if result != _ffi.NULL else None -def ttext_values(temp: 'const Temporal *') -> "Tuple['text **', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') +def ttext_value_at_timestamptz( + temp: "const Temporal *", t: int, strict: bool +) -> "text **": + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) + out_result = _ffi.new("text **") + result = _lib.ttext_value_at_timestamptz( + temp_converted, t_converted, strict, out_result + ) + _check_error() + if result: + return out_result if out_result != _ffi.NULL else None + return None + + +def ttext_values(temp: "const Temporal *") -> "Tuple['text **', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") result = _lib.ttext_values(temp_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def temporal_scale_time(temp: 'const Temporal *', duration: 'const Interval *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) +def float_degrees(value: float, normalize: bool) -> "double": + result = _lib.float_degrees(value, normalize) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_scale_time( + temp: "const Temporal *", duration: "const Interval *" +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) result = _lib.temporal_scale_time(temp_converted, duration_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_set_interp(temp: 'const Temporal *', interp: 'interpType') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - interp_converted = _ffi.cast('interpType', interp) +def temporal_set_interp(temp: "const Temporal *", interp: "interpType") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + interp_converted = _ffi.cast("interpType", interp) result = _lib.temporal_set_interp(temp_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_shift_scale_time(temp: 'const Temporal *', shift: "Optional['const Interval *']", duration: "Optional['const Interval *']") -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - shift_converted = _ffi.cast('const Interval *', shift) if shift is not None else _ffi.NULL - duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL - result = _lib.temporal_shift_scale_time(temp_converted, shift_converted, duration_converted) +def temporal_shift_scale_time( + temp: "const Temporal *", + shift: "Optional['const Interval *']", + duration: "Optional['const Interval *']", +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + shift_converted = ( + _ffi.cast("const Interval *", shift) if shift is not None else _ffi.NULL + ) + duration_converted = ( + _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL + ) + result = _lib.temporal_shift_scale_time( + temp_converted, shift_converted, duration_converted + ) _check_error() return result if result != _ffi.NULL else None -def temporal_shift_time(temp: 'const Temporal *', shift: 'const Interval *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - shift_converted = _ffi.cast('const Interval *', shift) +def temporal_shift_time( + temp: "const Temporal *", shift: "const Interval *" +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + shift_converted = _ffi.cast("const Interval *", shift) result = _lib.temporal_shift_time(temp_converted, shift_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_to_tinstant(temp: 'const Temporal *') -> 'TInstant *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_to_tinstant(temp: "const Temporal *") -> "TInstant *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_to_tinstant(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_to_tsequence(temp: 'const Temporal *', interp: 'interpType') -> 'TSequence *': - temp_converted = _ffi.cast('const Temporal *', temp) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.temporal_to_tsequence(temp_converted, interp_converted) +def temporal_to_tsequence(temp: "const Temporal *", interp_str: str) -> "TSequence *": + temp_converted = _ffi.cast("const Temporal *", temp) + interp_str_converted = interp_str.encode("utf-8") + result = _lib.temporal_to_tsequence(temp_converted, interp_str_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_to_tsequenceset( + temp: "const Temporal *", interp_str: str +) -> "TSequenceSet *": + temp_converted = _ffi.cast("const Temporal *", temp) + interp_str_converted = interp_str.encode("utf-8") + result = _lib.temporal_to_tsequenceset(temp_converted, interp_str_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tfloat_degrees(temp: "const Temporal *", normalize: bool) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tfloat_degrees(temp_converted, normalize) + _check_error() + return result if result != _ffi.NULL else None + + +def tfloat_radians(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tfloat_radians(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_to_tsequenceset(temp: 'const Temporal *', interp: 'interpType') -> 'TSequenceSet *': - temp_converted = _ffi.cast('const Temporal *', temp) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.temporal_to_tsequenceset(temp_converted, interp_converted) +def tfloat_round(temp: "const Temporal *", maxdd: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tfloat_round(temp_converted, maxdd) _check_error() return result if result != _ffi.NULL else None -def tfloat_scale_value(temp: 'const Temporal *', width: float) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_scale_value(temp: "const Temporal *", width: float) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_scale_value(temp_converted, width) _check_error() return result if result != _ffi.NULL else None -def tfloat_shift_scale_value(temp: 'const Temporal *', shift: float, width: float) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_shift_scale_value( + temp: "const Temporal *", shift: float, width: float +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_shift_scale_value(temp_converted, shift, width) _check_error() return result if result != _ffi.NULL else None -def tfloat_shift_value(temp: 'const Temporal *', shift: float) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_shift_value(temp: "const Temporal *", shift: float) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_shift_value(temp_converted, shift) _check_error() return result if result != _ffi.NULL else None -def tint_scale_value(temp: 'const Temporal *', width: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloatarr_round(temp: "const Temporal **", count: int, maxdd: int) -> "Temporal **": + temp_converted = [_ffi.cast("const Temporal *", x) for x in temp] + result = _lib.tfloatarr_round(temp_converted, count, maxdd) + _check_error() + return result if result != _ffi.NULL else None + + +def tint_scale_value(temp: "const Temporal *", width: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tint_scale_value(temp_converted, width) _check_error() return result if result != _ffi.NULL else None -def tint_shift_scale_value(temp: 'const Temporal *', shift: int, width: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_shift_scale_value( + temp: "const Temporal *", shift: int, width: int +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tint_shift_scale_value(temp_converted, shift, width) _check_error() return result if result != _ffi.NULL else None -def tint_shift_value(temp: 'const Temporal *', shift: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_shift_value(temp: "const Temporal *", shift: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tint_shift_value(temp_converted, shift) _check_error() return result if result != _ffi.NULL else None -def temporal_append_tinstant(temp: 'Temporal *', inst: 'const TInstant *', maxdist: float, maxt: "Optional['Interval *']", expand: bool) -> 'Temporal *': - temp_converted = _ffi.cast('Temporal *', temp) - inst_converted = _ffi.cast('const TInstant *', inst) - maxt_converted = _ffi.cast('Interval *', maxt) if maxt is not None else _ffi.NULL - result = _lib.temporal_append_tinstant(temp_converted, inst_converted, maxdist, maxt_converted, expand) +def tpoint_round(temp: "const Temporal *", maxdd: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_round(temp_converted, maxdd) + _check_error() + return result if result != _ffi.NULL else None + + +def tpointarr_round(temp: "const Temporal **", count: int, maxdd: int) -> "Temporal **": + temp_converted = [_ffi.cast("const Temporal *", x) for x in temp] + result = _lib.tpointarr_round(temp_converted, count, maxdd) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_append_tinstant( + temp: "Temporal *", + inst: "const TInstant *", + maxdist: float, + maxt: "Optional['Interval *']", + expand: bool, +) -> "Temporal *": + temp_converted = _ffi.cast("Temporal *", temp) + inst_converted = _ffi.cast("const TInstant *", inst) + maxt_converted = _ffi.cast("Interval *", maxt) if maxt is not None else _ffi.NULL + result = _lib.temporal_append_tinstant( + temp_converted, inst_converted, maxdist, maxt_converted, expand + ) _check_error() return result if result != _ffi.NULL else None -def temporal_append_tsequence(temp: 'Temporal *', seq: 'const TSequence *', expand: bool) -> 'Temporal *': - temp_converted = _ffi.cast('Temporal *', temp) - seq_converted = _ffi.cast('const TSequence *', seq) +def temporal_append_tsequence( + temp: "Temporal *", seq: "const TSequence *", expand: bool +) -> "Temporal *": + temp_converted = _ffi.cast("Temporal *", temp) + seq_converted = _ffi.cast("const TSequence *", seq) result = _lib.temporal_append_tsequence(temp_converted, seq_converted, expand) _check_error() return result if result != _ffi.NULL else None -def temporal_delete_tstzspan(temp: 'const Temporal *', s: 'const Span *', connect: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def temporal_delete_tstzspan( + temp: "const Temporal *", s: "const Span *", connect: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) result = _lib.temporal_delete_tstzspan(temp_converted, s_converted, connect) _check_error() return result if result != _ffi.NULL else None -def temporal_delete_tstzspanset(temp: 'const Temporal *', ss: 'const SpanSet *', connect: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) +def temporal_delete_tstzspanset( + temp: "const Temporal *", ss: "const SpanSet *", connect: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.temporal_delete_tstzspanset(temp_converted, ss_converted, connect) _check_error() return result if result != _ffi.NULL else None -def temporal_delete_timestamptz(temp: 'const Temporal *', t: int, connect: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) +def temporal_delete_timestamptz( + temp: "const Temporal *", t: int, connect: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.temporal_delete_timestamptz(temp_converted, t_converted, connect) _check_error() return result if result != _ffi.NULL else None -def temporal_delete_tstzset(temp: 'const Temporal *', s: 'const Set *', connect: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Set *', s) +def temporal_delete_tstzset( + temp: "const Temporal *", s: "const Set *", connect: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Set *", s) result = _lib.temporal_delete_tstzset(temp_converted, s_converted, connect) _check_error() return result if result != _ffi.NULL else None -def temporal_insert(temp1: 'const Temporal *', temp2: 'const Temporal *', connect: bool) -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_insert( + temp1: "const Temporal *", temp2: "const Temporal *", connect: bool +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.temporal_insert(temp1_converted, temp2_converted, connect) _check_error() return result if result != _ffi.NULL else None -def temporal_merge(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_merge( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.temporal_merge(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_merge_array(temparr: 'Temporal **', count: int) -> 'Temporal *': - temparr_converted = [_ffi.cast('Temporal *', x) for x in temparr] +def temporal_merge_array(temparr: "Temporal **", count: int) -> "Temporal *": + temparr_converted = [_ffi.cast("Temporal *", x) for x in temparr] result = _lib.temporal_merge_array(temparr_converted, count) _check_error() return result if result != _ffi.NULL else None -def temporal_update(temp1: 'const Temporal *', temp2: 'const Temporal *', connect: bool) -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_update( + temp1: "const Temporal *", temp2: "const Temporal *", connect: bool +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.temporal_update(temp1_converted, temp2_converted, connect) _check_error() return result if result != _ffi.NULL else None -def tbool_at_value(temp: 'const Temporal *', b: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_at_value(temp: "const Temporal *", b: bool) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tbool_at_value(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def tbool_minus_value(temp: 'const Temporal *', b: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tbool_minus_value(temp: "const Temporal *", b: bool) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tbool_minus_value(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def tbool_value_at_timestamptz(temp: 'const Temporal *', t: int, strict: bool) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('bool *') - result = _lib.tbool_value_at_timestamptz(temp_converted, t_converted, strict, out_result) - _check_error() - if result: - return out_result[0] if out_result[0] != _ffi.NULL else None - return None - - -def temporal_at_max(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_at_max(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_at_max(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_at_min(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_at_min(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_at_min(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_at_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def temporal_at_tstzspan(temp: "const Temporal *", s: "const Span *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) result = _lib.temporal_at_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_at_tstzspanset(temp: 'const Temporal *', ss: 'const SpanSet *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) +def temporal_at_tstzspanset( + temp: "const Temporal *", ss: "const SpanSet *" +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.temporal_at_tstzspanset(temp_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_at_timestamptz(temp: 'const Temporal *', t: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) +def temporal_at_timestamptz(temp: "const Temporal *", t: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.temporal_at_timestamptz(temp_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_at_tstzset(temp: 'const Temporal *', s: 'const Set *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Set *', s) +def temporal_at_tstzset(temp: "const Temporal *", s: "const Set *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Set *", s) result = _lib.temporal_at_tstzset(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_at_values(temp: 'const Temporal *', set: 'const Set *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - set_converted = _ffi.cast('const Set *', set) +def temporal_at_values(temp: "const Temporal *", set: "const Set *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + set_converted = _ffi.cast("const Set *", set) result = _lib.temporal_at_values(temp_converted, set_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_max(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_minus_max(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_minus_max(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_min(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def temporal_minus_min(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_minus_min(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) +def temporal_minus_tstzspan( + temp: "const Temporal *", s: "const Span *" +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) result = _lib.temporal_minus_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_tstzspanset(temp: 'const Temporal *', ss: 'const SpanSet *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) +def temporal_minus_tstzspanset( + temp: "const Temporal *", ss: "const SpanSet *" +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.temporal_minus_tstzspanset(temp_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_timestamptz(temp: 'const Temporal *', t: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) +def temporal_minus_timestamptz(temp: "const Temporal *", t: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) result = _lib.temporal_minus_timestamptz(temp_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_tstzset(temp: 'const Temporal *', s: 'const Set *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Set *', s) +def temporal_minus_tstzset(temp: "const Temporal *", s: "const Set *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Set *", s) result = _lib.temporal_minus_tstzset(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_minus_values(temp: 'const Temporal *', set: 'const Set *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - set_converted = _ffi.cast('const Set *', set) +def temporal_minus_values(temp: "const Temporal *", set: "const Set *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + set_converted = _ffi.cast("const Set *", set) result = _lib.temporal_minus_values(temp_converted, set_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_at_value(temp: 'const Temporal *', d: float) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_at_value(temp: "const Temporal *", d: float) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_at_value(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tfloat_minus_value(temp: 'const Temporal *', d: float) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tfloat_minus_value(temp: "const Temporal *", d: float) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tfloat_minus_value(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tfloat_value_at_timestamptz(temp: 'const Temporal *', t: int, strict: bool) -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('double *') - result = _lib.tfloat_value_at_timestamptz(temp_converted, t_converted, strict, out_result) - _check_error() - if result: - return out_result[0] if out_result[0] != _ffi.NULL else None - return None - - -def tint_at_value(temp: 'const Temporal *', i: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_at_value(temp: "const Temporal *", i: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tint_at_value(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tint_minus_value(temp: 'const Temporal *', i: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def tint_minus_value(temp: "const Temporal *", i: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tint_minus_value(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tint_value_at_timestamptz(temp: 'const Temporal *', t: int, strict: bool) -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('int *') - result = _lib.tint_value_at_timestamptz(temp_converted, t_converted, strict, out_result) - _check_error() - if result: - return out_result[0] if out_result[0] != _ffi.NULL else None - return None - - -def tnumber_at_span(temp: 'const Temporal *', span: 'const Span *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - span_converted = _ffi.cast('const Span *', span) +def tnumber_at_span(temp: "const Temporal *", span: "const Span *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + span_converted = _ffi.cast("const Span *", span) result = _lib.tnumber_at_span(temp_converted, span_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_at_spanset(temp: 'const Temporal *', ss: 'const SpanSet *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) +def tnumber_at_spanset(temp: "const Temporal *", ss: "const SpanSet *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tnumber_at_spanset(temp_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_at_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def tnumber_at_tbox(temp: "const Temporal *", box: "const TBox *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) result = _lib.tnumber_at_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_minus_span(temp: 'const Temporal *', span: 'const Span *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - span_converted = _ffi.cast('const Span *', span) +def tnumber_minus_span(temp: "const Temporal *", span: "const Span *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + span_converted = _ffi.cast("const Span *", span) result = _lib.tnumber_minus_span(temp_converted, span_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_minus_spanset(temp: 'const Temporal *', ss: 'const SpanSet *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) +def tnumber_minus_spanset( + temp: "const Temporal *", ss: "const SpanSet *" +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.tnumber_minus_spanset(temp_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_minus_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) +def tnumber_minus_tbox(temp: "const Temporal *", box: "const TBox *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) result = _lib.tnumber_minus_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_at_geom_time(temp: 'const Temporal *', gs: 'const GSERIALIZED *', zspan: "Optional['const Span *']", period: 'const Span *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - zspan_converted = _ffi.cast('const Span *', zspan) if zspan is not None else _ffi.NULL - period_converted = _ffi.cast('const Span *', period) - result = _lib.tpoint_at_geom_time(temp_converted, gs_converted, zspan_converted, period_converted) +def tpoint_at_geom_time( + temp: "const Temporal *", + gs: "const GSERIALIZED *", + zspan: "Optional['const Span *']", + period: "const Span *", +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + zspan_converted = ( + _ffi.cast("const Span *", zspan) if zspan is not None else _ffi.NULL + ) + period_converted = _ffi.cast("const Span *", period) + result = _lib.tpoint_at_geom_time( + temp_converted, gs_converted, zspan_converted, period_converted + ) _check_error() return result if result != _ffi.NULL else None -def tpoint_at_stbox(temp: 'const Temporal *', box: 'const STBox *', border_inc: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def tpoint_at_stbox( + temp: "const Temporal *", box: "const STBox *", border_inc: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.tpoint_at_stbox(temp_converted, box_converted, border_inc) _check_error() return result if result != _ffi.NULL else None -def tpoint_at_value(temp: 'const Temporal *', gs: 'GSERIALIZED *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('GSERIALIZED *', gs) +def tpoint_at_value(temp: "const Temporal *", gs: "GSERIALIZED *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("GSERIALIZED *", gs) result = _lib.tpoint_at_value(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_minus_geom_time(temp: 'const Temporal *', gs: 'const GSERIALIZED *', zspan: "Optional['const Span *']", period: 'const Span *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - zspan_converted = _ffi.cast('const Span *', zspan) if zspan is not None else _ffi.NULL - period_converted = _ffi.cast('const Span *', period) - result = _lib.tpoint_minus_geom_time(temp_converted, gs_converted, zspan_converted, period_converted) +def tpoint_minus_geom_time( + temp: "const Temporal *", + gs: "const GSERIALIZED *", + zspan: "Optional['const Span *']", + period: "const Span *", +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + zspan_converted = ( + _ffi.cast("const Span *", zspan) if zspan is not None else _ffi.NULL + ) + period_converted = _ffi.cast("const Span *", period) + result = _lib.tpoint_minus_geom_time( + temp_converted, gs_converted, zspan_converted, period_converted + ) _check_error() return result if result != _ffi.NULL else None -def tpoint_minus_stbox(temp: 'const Temporal *', box: 'const STBox *', border_inc: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) +def tpoint_minus_stbox( + temp: "const Temporal *", box: "const STBox *", border_inc: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) result = _lib.tpoint_minus_stbox(temp_converted, box_converted, border_inc) _check_error() return result if result != _ffi.NULL else None -def tpoint_minus_value(temp: 'const Temporal *', gs: 'GSERIALIZED *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('GSERIALIZED *', gs) +def tpoint_minus_value(temp: "const Temporal *", gs: "GSERIALIZED *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("GSERIALIZED *", gs) result = _lib.tpoint_minus_value(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_value_at_timestamptz(temp: 'const Temporal *', t: int, strict: bool) -> 'GSERIALIZED **': - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('GSERIALIZED **') - result = _lib.tpoint_value_at_timestamptz(temp_converted, t_converted, strict, out_result) - _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None - - -def ttext_at_value(temp: 'const Temporal *', txt: str) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_at_value(temp: "const Temporal *", txt: str) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) result = _lib.ttext_at_value(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_minus_value(temp: 'const Temporal *', txt: str) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def ttext_minus_value(temp: "const Temporal *", txt: str) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) result = _lib.ttext_minus_value(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_value_at_timestamptz(temp: 'const Temporal *', t: int, strict: bool) -> 'text **': - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('text **') - result = _lib.ttext_value_at_timestamptz(temp_converted, t_converted, strict, out_result) - _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None - - -def temporal_cmp(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'int': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_cmp(temp1: "const Temporal *", temp2: "const Temporal *") -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.temporal_cmp(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_eq(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_eq(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.temporal_eq(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_ge(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_ge(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.temporal_ge(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_gt(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_gt(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.temporal_gt(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_le(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_le(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.temporal_le(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_lt(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_lt(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.temporal_lt(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_ne(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) +def temporal_ne(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) result = _lib.temporal_ne(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_always_eq(temp: 'const Temporal *', b: bool) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tbool_always_eq(temp_converted, b) - _check_error() - return result if result != _ffi.NULL else None - - -def tbool_ever_eq(temp: 'const Temporal *', b: bool) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tbool_ever_eq(temp_converted, b) +def always_eq_bool_tbool(b: bool, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_eq_bool_tbool(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_always_eq(temp: 'const Temporal *', d: float) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_always_eq(temp_converted, d) +def always_eq_float_tfloat(d: float, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_eq_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_always_le(temp: 'const Temporal *', d: float) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_always_le(temp_converted, d) +def always_eq_int_tint(i: int, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_eq_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_always_lt(temp: 'const Temporal *', d: float) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_always_lt(temp_converted, d) +def always_eq_point_tpoint( + gs: "const GSERIALIZED *", temp: "const Temporal *" +) -> "int": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_eq_point_tpoint(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_ever_eq(temp: 'const Temporal *', d: float) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_ever_eq(temp_converted, d) +def always_eq_tbool_bool(temp: "const Temporal *", b: bool) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_eq_tbool_bool(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def tfloat_ever_le(temp: 'const Temporal *', d: float) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_ever_le(temp_converted, d) +def always_eq_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.always_eq_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_ever_lt(temp: 'const Temporal *', d: float) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_ever_lt(temp_converted, d) +def always_eq_text_ttext(txt: str, temp: "const Temporal *") -> "int": + txt_converted = cstring2text(txt) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_eq_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_always_eq(temp: 'const Temporal *', i: int) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tint_always_eq(temp_converted, i) +def always_eq_tfloat_float(temp: "const Temporal *", d: float) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_eq_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tint_always_le(temp: 'const Temporal *', i: int) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tint_always_le(temp_converted, i) +def always_eq_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_eq_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tint_always_lt(temp: 'const Temporal *', i: int) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tint_always_lt(temp_converted, i) +def always_eq_tpoint_point( + temp: "const Temporal *", gs: "const GSERIALIZED *" +) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.always_eq_tpoint_point(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tint_ever_eq(temp: 'const Temporal *', i: int) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tint_ever_eq(temp_converted, i) +def always_eq_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.always_eq_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tint_ever_le(temp: 'const Temporal *', i: int) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tint_ever_le(temp_converted, i) +def always_eq_ttext_text(temp: "const Temporal *", txt: str) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.always_eq_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def tint_ever_lt(temp: 'const Temporal *', i: int) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tint_ever_lt(temp_converted, i) +def always_ne_bool_tbool(b: bool, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ne_bool_tbool(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_always_eq(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.tpoint_always_eq(temp_converted, gs_converted) +def always_ne_float_tfloat(d: float, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ne_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_ever_eq(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.tpoint_ever_eq(temp_converted, gs_converted) +def always_ne_int_tint(i: int, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ne_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_always_eq(temp: 'const Temporal *', txt: str) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - txt_converted = cstring2text(txt) - result = _lib.ttext_always_eq(temp_converted, txt_converted) +def always_ne_point_tpoint( + gs: "const GSERIALIZED *", temp: "const Temporal *" +) -> "int": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ne_point_tpoint(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_always_le(temp: 'const Temporal *', txt: str) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - txt_converted = cstring2text(txt) - result = _lib.ttext_always_le(temp_converted, txt_converted) +def always_ne_tbool_bool(temp: "const Temporal *", b: bool) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ne_tbool_bool(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def ttext_always_lt(temp: 'const Temporal *', txt: str) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - txt_converted = cstring2text(txt) - result = _lib.ttext_always_lt(temp_converted, txt_converted) +def always_ne_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.always_ne_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_ever_eq(temp: 'const Temporal *', txt: str) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ne_text_ttext(txt: str, temp: "const Temporal *") -> "int": txt_converted = cstring2text(txt) - result = _lib.ttext_ever_eq(temp_converted, txt_converted) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ne_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_ever_le(temp: 'const Temporal *', txt: str) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - txt_converted = cstring2text(txt) - result = _lib.ttext_ever_le(temp_converted, txt_converted) +def always_ne_tfloat_float(temp: "const Temporal *", d: float) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ne_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def ttext_ever_lt(temp: 'const Temporal *', txt: str) -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - txt_converted = cstring2text(txt) - result = _lib.ttext_ever_lt(temp_converted, txt_converted) +def always_ne_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ne_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def teq_bool_tbool(b: bool, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.teq_bool_tbool(b, temp_converted) +def always_ne_tpoint_point( + temp: "const Temporal *", gs: "const GSERIALIZED *" +) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.always_ne_tpoint_point(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def teq_float_tfloat(d: float, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.teq_float_tfloat(d, temp_converted) +def always_ne_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.always_ne_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def teq_int_tint(i: int, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.teq_int_tint(i, temp_converted) +def always_ne_ttext_text(temp: "const Temporal *", txt: str) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.always_ne_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def teq_point_tpoint(gs: 'const GSERIALIZED *', temp: 'const Temporal *') -> 'Temporal *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.teq_point_tpoint(gs_converted, temp_converted) +def always_ge_float_tfloat(d: float, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ge_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def teq_tbool_bool(temp: 'const Temporal *', b: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.teq_tbool_bool(temp_converted, b) +def always_ge_int_tint(i: int, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ge_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def teq_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.teq_temporal_temporal(temp1_converted, temp2_converted) +def always_ge_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.always_ge_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def teq_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': +def always_ge_text_ttext(txt: str, temp: "const Temporal *") -> "int": txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.teq_text_ttext(txt_converted, temp_converted) - _check_error() - return result if result != _ffi.NULL else None - - -def teq_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.teq_tfloat_float(temp_converted, d) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ge_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def teq_tpoint_point(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.teq_tpoint_point(temp_converted, gs_converted) +def always_ge_tfloat_float(temp: "const Temporal *", d: float) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ge_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def teq_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.teq_tint_int(temp_converted, i) +def always_ge_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ge_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def teq_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def always_ge_ttext_text(temp: "const Temporal *", txt: str) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) - result = _lib.teq_ttext_text(temp_converted, txt_converted) + result = _lib.always_ge_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def tge_float_tfloat(d: float, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tge_float_tfloat(d, temp_converted) +def always_gt_float_tfloat(d: float, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_gt_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tge_int_tint(i: int, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tge_int_tint(i, temp_converted) +def always_gt_int_tint(i: int, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_gt_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tge_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.tge_temporal_temporal(temp1_converted, temp2_converted) +def always_gt_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.always_gt_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tge_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': +def always_gt_text_ttext(txt: str, temp: "const Temporal *") -> "int": txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tge_text_ttext(txt_converted, temp_converted) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_gt_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tge_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tge_tfloat_float(temp_converted, d) +def always_gt_tfloat_float(temp: "const Temporal *", d: float) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_gt_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tge_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tge_tint_int(temp_converted, i) +def always_gt_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_gt_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tge_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def always_gt_ttext_text(temp: "const Temporal *", txt: str) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) - result = _lib.tge_ttext_text(temp_converted, txt_converted) + result = _lib.always_gt_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def tgt_float_tfloat(d: float, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tgt_float_tfloat(d, temp_converted) +def always_le_float_tfloat(d: float, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_le_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgt_int_tint(i: int, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tgt_int_tint(i, temp_converted) +def always_le_int_tint(i: int, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_le_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgt_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.tgt_temporal_temporal(temp1_converted, temp2_converted) +def always_le_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.always_le_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tgt_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': +def always_le_text_ttext(txt: str, temp: "const Temporal *") -> "int": txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tgt_text_ttext(txt_converted, temp_converted) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_le_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgt_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tgt_tfloat_float(temp_converted, d) +def always_le_tfloat_float(temp: "const Temporal *", d: float) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_le_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tgt_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tgt_tint_int(temp_converted, i) +def always_le_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_le_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tgt_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def always_le_ttext_text(temp: "const Temporal *", txt: str) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) - result = _lib.tgt_ttext_text(temp_converted, txt_converted) + result = _lib.always_le_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def tle_float_tfloat(d: float, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tle_float_tfloat(d, temp_converted) +def always_lt_float_tfloat(d: float, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_lt_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tle_int_tint(i: int, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tle_int_tint(i, temp_converted) +def always_lt_int_tint(i: int, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_lt_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tle_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.tle_temporal_temporal(temp1_converted, temp2_converted) +def always_lt_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.always_lt_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tle_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': +def always_lt_text_ttext(txt: str, temp: "const Temporal *") -> "int": txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tle_text_ttext(txt_converted, temp_converted) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_lt_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tle_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tle_tfloat_float(temp_converted, d) +def always_lt_tfloat_float(temp: "const Temporal *", d: float) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_lt_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tle_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tle_tint_int(temp_converted, i) +def always_lt_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_lt_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tle_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def always_lt_ttext_text(temp: "const Temporal *", txt: str) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) - result = _lib.tle_ttext_text(temp_converted, txt_converted) + result = _lib.always_lt_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def tlt_float_tfloat(d: float, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tlt_float_tfloat(d, temp_converted) +def ever_eq_bool_tbool(b: bool, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_eq_bool_tbool(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tlt_int_tint(i: int, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tlt_int_tint(i, temp_converted) +def ever_eq_float_tfloat(d: float, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_eq_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tlt_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.tlt_temporal_temporal(temp1_converted, temp2_converted) +def ever_eq_int_tint(i: int, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_eq_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tlt_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': - txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tlt_text_ttext(txt_converted, temp_converted) +def ever_eq_point_tpoint(gs: "const GSERIALIZED *", temp: "const Temporal *") -> "int": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_eq_point_tpoint(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tlt_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tlt_tfloat_float(temp_converted, d) +def ever_eq_tbool_bool(temp: "const Temporal *", b: bool) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_eq_tbool_bool(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def tlt_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tlt_tint_int(temp_converted, i) +def ever_eq_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.ever_eq_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tlt_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) +def ever_eq_text_ttext(txt: str, temp: "const Temporal *") -> "int": txt_converted = cstring2text(txt) - result = _lib.tlt_ttext_text(temp_converted, txt_converted) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_eq_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tne_bool_tbool(b: bool, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tne_bool_tbool(b, temp_converted) +def ever_eq_tfloat_float(temp: "const Temporal *", d: float) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_eq_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tne_float_tfloat(d: float, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tne_float_tfloat(d, temp_converted) +def ever_eq_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_eq_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def tne_int_tint(i: int, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tne_int_tint(i, temp_converted) +def ever_eq_tpoint_point(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.ever_eq_tpoint_point(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def tne_point_tpoint(gs: 'const GSERIALIZED *', temp: 'const Temporal *') -> 'Temporal *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tne_point_tpoint(gs_converted, temp_converted) +def ever_eq_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.ever_eq_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tne_tbool_bool(temp: 'const Temporal *', b: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tne_tbool_bool(temp_converted, b) +def ever_eq_ttext_text(temp: "const Temporal *", txt: str) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.ever_eq_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def tne_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.tne_temporal_temporal(temp1_converted, temp2_converted) +def ever_ge_float_tfloat(d: float, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ge_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tne_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': - txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tne_text_ttext(txt_converted, temp_converted) +def ever_ge_int_tint(i: int, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ge_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tne_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tne_tfloat_float(temp_converted, d) +def ever_ge_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.ever_ge_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tne_tpoint_point(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.tne_tpoint_point(temp_converted, gs_converted) +def ever_ge_text_ttext(txt: str, temp: "const Temporal *") -> "int": + txt_converted = cstring2text(txt) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ge_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tne_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tne_tint_int(temp_converted, i) +def ever_ge_tfloat_float(temp: "const Temporal *", d: float) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ge_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def tne_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - txt_converted = cstring2text(txt) - result = _lib.tne_ttext_text(temp_converted, txt_converted) +def ever_ge_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ge_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def adjacent_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.adjacent_numspan_tnumber(s_converted, temp_converted) +def ever_ge_ttext_text(temp: "const Temporal *", txt: str) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.ever_ge_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.adjacent_stbox_tpoint(box_converted, temp_converted) +def ever_gt_float_tfloat(d: float, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_gt_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.adjacent_tbox_tnumber(box_converted, temp_converted) +def ever_gt_int_tint(i: int, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_gt_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.adjacent_temporal_temporal(temp1_converted, temp2_converted) +def ever_gt_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.ever_gt_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.adjacent_temporal_tstzspan(temp_converted, s_converted) +def ever_gt_text_ttext(txt: str, temp: "const Temporal *") -> "int": + txt_converted = cstring2text(txt) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_gt_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.adjacent_tnumber_numspan(temp_converted, s_converted) +def ever_gt_tfloat_float(temp: "const Temporal *", d: float) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_gt_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def adjacent_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.adjacent_tnumber_tbox(temp_converted, box_converted) +def ever_gt_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_gt_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def adjacent_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.adjacent_tnumber_tnumber(temp1_converted, temp2_converted) +def ever_gt_ttext_text(temp: "const Temporal *", txt: str) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.ever_gt_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.adjacent_tpoint_stbox(temp_converted, box_converted) +def ever_le_float_tfloat(d: float, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_le_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.adjacent_tpoint_tpoint(temp1_converted, temp2_converted) +def ever_le_int_tint(i: int, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_le_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.adjacent_tstzspan_temporal(s_converted, temp_converted) +def ever_le_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.ever_le_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.contained_numspan_tnumber(s_converted, temp_converted) +def ever_le_text_ttext(txt: str, temp: "const Temporal *") -> "int": + txt_converted = cstring2text(txt) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_le_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contained_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.contained_stbox_tpoint(box_converted, temp_converted) +def ever_le_tfloat_float(temp: "const Temporal *", d: float) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_le_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def contained_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.contained_tbox_tnumber(box_converted, temp_converted) +def ever_le_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_le_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def contained_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.contained_temporal_temporal(temp1_converted, temp2_converted) +def ever_le_ttext_text(temp: "const Temporal *", txt: str) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.ever_le_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def contained_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.contained_temporal_tstzspan(temp_converted, s_converted) +def ever_lt_float_tfloat(d: float, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_lt_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.contained_tnumber_numspan(temp_converted, s_converted) +def ever_lt_int_tint(i: int, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_lt_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.contained_tnumber_tbox(temp_converted, box_converted) +def ever_lt_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.ever_lt_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.contained_tnumber_tnumber(temp1_converted, temp2_converted) +def ever_lt_text_ttext(txt: str, temp: "const Temporal *") -> "int": + txt_converted = cstring2text(txt) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_lt_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contained_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.contained_tpoint_stbox(temp_converted, box_converted) +def ever_lt_tfloat_float(temp: "const Temporal *", d: float) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_lt_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def contained_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.contained_tpoint_tpoint(temp1_converted, temp2_converted) +def ever_lt_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_lt_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def contained_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.contained_tstzspan_temporal(s_converted, temp_converted) +def ever_lt_ttext_text(temp: "const Temporal *", txt: str) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.ever_lt_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def contains_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.contains_numspan_tnumber(s_converted, temp_converted) +def ever_ne_bool_tbool(b: bool, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ne_bool_tbool(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contains_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.contains_stbox_tpoint(box_converted, temp_converted) +def ever_ne_float_tfloat(d: float, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ne_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.contains_tbox_tnumber(box_converted, temp_converted) +def ever_ne_int_tint(i: int, temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ne_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contains_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.contains_temporal_tstzspan(temp_converted, s_converted) +def ever_ne_point_tpoint(gs: "const GSERIALIZED *", temp: "const Temporal *") -> "int": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ne_point_tpoint(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contains_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.contains_temporal_temporal(temp1_converted, temp2_converted) +def ever_ne_tbool_bool(temp: "const Temporal *", b: bool) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ne_tbool_bool(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def contains_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.contains_tnumber_numspan(temp_converted, s_converted) +def ever_ne_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.ever_ne_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.contains_tnumber_tbox(temp_converted, box_converted) +def ever_ne_text_ttext(txt: str, temp: "const Temporal *") -> "int": + txt_converted = cstring2text(txt) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ne_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.contains_tnumber_tnumber(temp1_converted, temp2_converted) +def ever_ne_tfloat_float(temp: "const Temporal *", d: float) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ne_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def contains_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.contains_tpoint_stbox(temp_converted, box_converted) +def ever_ne_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ne_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def contains_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.contains_tpoint_tpoint(temp1_converted, temp2_converted) +def ever_ne_tpoint_point(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.ever_ne_tpoint_point(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def contains_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.contains_tstzspan_temporal(s_converted, temp_converted) +def ever_ne_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.ever_ne_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overlaps_numspan_tnumber(s_converted, temp_converted) +def ever_ne_ttext_text(temp: "const Temporal *", txt: str) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.ever_ne_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overlaps_stbox_tpoint(box_converted, temp_converted) +def teq_bool_tbool(b: bool, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.teq_bool_tbool(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overlaps_tbox_tnumber(box_converted, temp_converted) +def teq_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.teq_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overlaps_temporal_temporal(temp1_converted, temp2_converted) +def teq_int_tint(i: int, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.teq_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overlaps_temporal_tstzspan(temp_converted, s_converted) +def teq_point_tpoint( + gs: "const GSERIALIZED *", temp: "const Temporal *" +) -> "Temporal *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.teq_point_tpoint(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overlaps_tnumber_numspan(temp_converted, s_converted) +def teq_tbool_bool(temp: "const Temporal *", b: bool) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.teq_tbool_bool(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def overlaps_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.overlaps_tnumber_tbox(temp_converted, box_converted) +def teq_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.teq_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overlaps_tnumber_tnumber(temp1_converted, temp2_converted) +def teq_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": + txt_converted = cstring2text(txt) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.teq_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.overlaps_tpoint_stbox(temp_converted, box_converted) +def teq_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.teq_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def overlaps_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overlaps_tpoint_tpoint(temp1_converted, temp2_converted) +def teq_tpoint_point( + temp: "const Temporal *", gs: "const GSERIALIZED *" +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.teq_tpoint_point(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overlaps_tstzspan_temporal(s_converted, temp_converted) +def teq_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.teq_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def same_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.same_numspan_tnumber(s_converted, temp_converted) +def teq_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.teq_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def same_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.same_stbox_tpoint(box_converted, temp_converted) +def teq_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.teq_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def same_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.same_tbox_tnumber(box_converted, temp_converted) +def tge_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tge_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def same_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.same_temporal_temporal(temp1_converted, temp2_converted) +def tge_int_tint(i: int, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tge_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def same_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.same_temporal_tstzspan(temp_converted, s_converted) +def tge_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.tge_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def same_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.same_tnumber_numspan(temp_converted, s_converted) +def tge_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": + txt_converted = cstring2text(txt) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tge_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def same_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.same_tnumber_tbox(temp_converted, box_converted) +def tge_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tge_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def same_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.same_tnumber_tnumber(temp1_converted, temp2_converted) +def tge_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tge_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def same_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.same_tpoint_stbox(temp_converted, box_converted) +def tge_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.tge_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def same_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.same_tpoint_tpoint(temp1_converted, temp2_converted) +def tgt_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tgt_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def same_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.same_tstzspan_temporal(s_converted, temp_converted) +def tgt_int_tint(i: int, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tgt_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def above_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.above_stbox_tpoint(box_converted, temp_converted) +def tgt_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.tgt_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def above_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.above_tpoint_stbox(temp_converted, box_converted) +def tgt_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": + txt_converted = cstring2text(txt) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tgt_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def above_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.above_tpoint_tpoint(temp1_converted, temp2_converted) +def tgt_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tgt_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def after_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.after_stbox_tpoint(box_converted, temp_converted) +def tgt_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tgt_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def after_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.after_tbox_tnumber(box_converted, temp_converted) +def tgt_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.tgt_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def after_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.after_temporal_tstzspan(temp_converted, s_converted) +def tle_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tle_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def after_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.after_temporal_temporal(temp1_converted, temp2_converted) +def tle_int_tint(i: int, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tle_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def after_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.after_tnumber_tbox(temp_converted, box_converted) +def tle_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.tle_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def after_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.after_tnumber_tnumber(temp1_converted, temp2_converted) +def tle_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": + txt_converted = cstring2text(txt) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tle_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def after_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.after_tpoint_stbox(temp_converted, box_converted) +def tle_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tle_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def after_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.after_tpoint_tpoint(temp1_converted, temp2_converted) +def tle_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tle_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def after_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.after_tstzspan_temporal(s_converted, temp_converted) +def tle_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.tle_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def back_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.back_stbox_tpoint(box_converted, temp_converted) +def tlt_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tlt_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def back_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.back_tpoint_stbox(temp_converted, box_converted) +def tlt_int_tint(i: int, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tlt_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def back_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.back_tpoint_tpoint(temp1_converted, temp2_converted) +def tlt_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.tlt_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def before_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.before_stbox_tpoint(box_converted, temp_converted) +def tlt_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": + txt_converted = cstring2text(txt) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tlt_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def before_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.before_tbox_tnumber(box_converted, temp_converted) +def tlt_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tlt_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def before_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.before_temporal_tstzspan(temp_converted, s_converted) +def tlt_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tlt_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def before_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.before_temporal_temporal(temp1_converted, temp2_converted) +def tlt_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.tlt_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def before_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.before_tnumber_tbox(temp_converted, box_converted) +def tne_bool_tbool(b: bool, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tne_bool_tbool(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def before_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.before_tnumber_tnumber(temp1_converted, temp2_converted) +def tne_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tne_float_tfloat(d, temp_converted) _check_error() return result if result != _ffi.NULL else None -def before_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.before_tpoint_stbox(temp_converted, box_converted) +def tne_int_tint(i: int, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tne_int_tint(i, temp_converted) _check_error() return result if result != _ffi.NULL else None -def before_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.before_tpoint_tpoint(temp1_converted, temp2_converted) +def tne_point_tpoint( + gs: "const GSERIALIZED *", temp: "const Temporal *" +) -> "Temporal *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tne_point_tpoint(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def before_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.before_tstzspan_temporal(s_converted, temp_converted) +def tne_tbool_bool(temp: "const Temporal *", b: bool) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tne_tbool_bool(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def below_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.below_stbox_tpoint(box_converted, temp_converted) +def tne_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.tne_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def below_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.below_tpoint_stbox(temp_converted, box_converted) +def tne_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": + txt_converted = cstring2text(txt) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tne_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def below_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.below_tpoint_tpoint(temp1_converted, temp2_converted) +def tne_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tne_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def front_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.front_stbox_tpoint(box_converted, temp_converted) +def tne_tpoint_point( + temp: "const Temporal *", gs: "const GSERIALIZED *" +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.tne_tpoint_point(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def front_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.front_tpoint_stbox(temp_converted, box_converted) +def tne_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.tne_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def front_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.front_tpoint_tpoint(temp1_converted, temp2_converted) +def tne_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tne_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def left_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.left_stbox_tpoint(box_converted, temp_converted) +def tne_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.tne_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def left_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.left_tbox_tnumber(box_converted, temp_converted) +def adjacent_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.adjacent_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def left_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.left_numspan_tnumber(s_converted, temp_converted) +def adjacent_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.adjacent_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def left_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.left_tnumber_numspan(temp_converted, s_converted) +def adjacent_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.adjacent_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def left_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.left_tnumber_tbox(temp_converted, box_converted) +def adjacent_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.adjacent_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def left_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.left_tnumber_tnumber(temp1_converted, temp2_converted) +def adjacent_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.adjacent_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.left_tpoint_stbox(temp_converted, box_converted) +def adjacent_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.adjacent_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def left_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.left_tpoint_tpoint(temp1_converted, temp2_converted) +def adjacent_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.adjacent_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overabove_stbox_tpoint(box_converted, temp_converted) +def adjacent_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.adjacent_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.overabove_tpoint_stbox(temp_converted, box_converted) +def adjacent_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.adjacent_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overabove_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overabove_tpoint_tpoint(temp1_converted, temp2_converted) +def adjacent_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.adjacent_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overafter_stbox_tpoint(box_converted, temp_converted) +def adjacent_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.adjacent_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overafter_tbox_tnumber(box_converted, temp_converted) +def contained_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.contained_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overafter_temporal_tstzspan(temp_converted, s_converted) +def contained_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.contained_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overafter_temporal_temporal(temp1_converted, temp2_converted) +def contained_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.contained_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.overafter_tnumber_tbox(temp_converted, box_converted) +def contained_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.contained_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overafter_tnumber_tnumber(temp1_converted, temp2_converted) +def contained_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.contained_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.overafter_tpoint_stbox(temp_converted, box_converted) +def contained_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.contained_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overafter_tpoint_tpoint(temp1_converted, temp2_converted) +def contained_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.contained_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overafter_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overafter_tstzspan_temporal(s_converted, temp_converted) +def contained_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.contained_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overback_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overback_stbox_tpoint(box_converted, temp_converted) +def contained_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.contained_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overback_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.overback_tpoint_stbox(temp_converted, box_converted) +def contained_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.contained_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overback_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overback_tpoint_tpoint(temp1_converted, temp2_converted) +def contained_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.contained_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overbefore_stbox_tpoint(box_converted, temp_converted) +def contains_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.contains_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overbefore_tbox_tnumber(box_converted, temp_converted) +def contains_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.contains_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_temporal_tstzspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overbefore_temporal_tstzspan(temp_converted, s_converted) +def contains_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.contains_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_temporal_temporal(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overbefore_temporal_temporal(temp1_converted, temp2_converted) +def contains_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.contains_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.overbefore_tnumber_tbox(temp_converted, box_converted) +def contains_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.contains_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overbefore_tnumber_tnumber(temp1_converted, temp2_converted) +def contains_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.contains_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.overbefore_tpoint_stbox(temp_converted, box_converted) +def contains_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.contains_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overbefore_tpoint_tpoint(temp1_converted, temp2_converted) +def contains_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.contains_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overbefore_tstzspan_temporal(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overbefore_tstzspan_temporal(s_converted, temp_converted) +def contains_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.contains_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overbelow_stbox_tpoint(box_converted, temp_converted) +def contains_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.contains_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.overbelow_tpoint_stbox(temp_converted, box_converted) +def contains_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.contains_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overbelow_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overbelow_tpoint_tpoint(temp1_converted, temp2_converted) +def overlaps_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overlaps_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overfront_stbox_tpoint(box_converted, temp_converted) +def overlaps_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overlaps_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.overfront_tpoint_stbox(temp_converted, box_converted) +def overlaps_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overlaps_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overfront_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overfront_tpoint_tpoint(temp1_converted, temp2_converted) +def overlaps_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overlaps_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overleft_numspan_tnumber(s_converted, temp_converted) +def overlaps_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overlaps_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overleft_stbox_tpoint(box_converted, temp_converted) +def overlaps_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overlaps_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overleft_tbox_tnumber(box_converted, temp_converted) +def overlaps_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.overlaps_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overleft_tnumber_numspan(temp_converted, s_converted) +def overlaps_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overlaps_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.overleft_tnumber_tbox(temp_converted, box_converted) +def overlaps_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.overlaps_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overleft_tnumber_tnumber(temp1_converted, temp2_converted) +def overlaps_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overlaps_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.overleft_tpoint_stbox(temp_converted, box_converted) +def overlaps_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overlaps_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overleft_tpoint_tpoint(temp1_converted, temp2_converted) +def same_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.same_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overright_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overright_numspan_tnumber(s_converted, temp_converted) +def same_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.same_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overright_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overright_stbox_tpoint(box_converted, temp_converted) +def same_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.same_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.overright_tbox_tnumber(box_converted, temp_converted) +def same_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.same_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overright_tnumber_numspan(temp_converted, s_converted) +def same_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.same_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.overright_tnumber_tbox(temp_converted, box_converted) +def same_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.same_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overright_tnumber_tnumber(temp1_converted, temp2_converted) +def same_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.same_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.overright_tpoint_stbox(temp_converted, box_converted) +def same_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.same_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def overright_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.overright_tpoint_tpoint(temp1_converted, temp2_converted) +def same_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.same_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def right_numspan_tnumber(s: 'const Span *', temp: 'const Temporal *') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.right_numspan_tnumber(s_converted, temp_converted) +def same_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.same_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def right_stbox_tpoint(box: 'const STBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const STBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.right_stbox_tpoint(box_converted, temp_converted) +def same_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.same_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def right_tbox_tnumber(box: 'const TBox *', temp: 'const Temporal *') -> 'bool': - box_converted = _ffi.cast('const TBox *', box) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.right_tbox_tnumber(box_converted, temp_converted) +def above_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.above_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def right_tnumber_numspan(temp: 'const Temporal *', s: 'const Span *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.right_tnumber_numspan(temp_converted, s_converted) +def above_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.above_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def right_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.right_tnumber_tbox(temp_converted, box_converted) +def above_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.above_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def right_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.right_tnumber_tnumber(temp1_converted, temp2_converted) +def after_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.after_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def right_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.right_tpoint_stbox(temp_converted, box_converted) +def after_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.after_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def right_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'bool': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.right_tpoint_tpoint(temp1_converted, temp2_converted) +def after_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.after_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tand_bool_tbool(b: bool, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tand_bool_tbool(b, temp_converted) +def after_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.after_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tand_tbool_bool(temp: 'const Temporal *', b: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tand_tbool_bool(temp_converted, b) +def after_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.after_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tand_tbool_tbool(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.tand_tbool_tbool(temp1_converted, temp2_converted) +def after_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.after_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_when_true(temp: 'const Temporal *') -> 'SpanSet *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tbool_when_true(temp_converted) +def after_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.after_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tnot_tbool(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tnot_tbool(temp_converted) +def after_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.after_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tor_bool_tbool(b: bool, temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tor_bool_tbool(b, temp_converted) +def after_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.after_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tor_tbool_bool(temp: 'const Temporal *', b: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tor_tbool_bool(temp_converted, b) +def back_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.back_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tor_tbool_tbool(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.tor_tbool_tbool(temp1_converted, temp2_converted) +def back_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.back_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def add_float_tfloat(d: float, tnumber: 'const Temporal *') -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.add_float_tfloat(d, tnumber_converted) +def back_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.back_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def add_int_tint(i: int, tnumber: 'const Temporal *') -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.add_int_tint(i, tnumber_converted) +def before_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.before_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def add_tfloat_float(tnumber: 'const Temporal *', d: float) -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.add_tfloat_float(tnumber_converted, d) +def before_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.before_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def add_tint_int(tnumber: 'const Temporal *', i: int) -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.add_tint_int(tnumber_converted, i) +def before_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.before_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def add_tnumber_tnumber(tnumber1: 'const Temporal *', tnumber2: 'const Temporal *') -> 'Temporal *': - tnumber1_converted = _ffi.cast('const Temporal *', tnumber1) - tnumber2_converted = _ffi.cast('const Temporal *', tnumber2) - result = _lib.add_tnumber_tnumber(tnumber1_converted, tnumber2_converted) +def before_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.before_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def div_float_tfloat(d: float, tnumber: 'const Temporal *') -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.div_float_tfloat(d, tnumber_converted) +def before_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.before_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def div_int_tint(i: int, tnumber: 'const Temporal *') -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.div_int_tint(i, tnumber_converted) +def before_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.before_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def div_tfloat_float(tnumber: 'const Temporal *', d: float) -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.div_tfloat_float(tnumber_converted, d) +def before_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.before_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def div_tint_int(tnumber: 'const Temporal *', i: int) -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.div_tint_int(tnumber_converted, i) +def before_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.before_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def div_tnumber_tnumber(tnumber1: 'const Temporal *', tnumber2: 'const Temporal *') -> 'Temporal *': - tnumber1_converted = _ffi.cast('const Temporal *', tnumber1) - tnumber2_converted = _ffi.cast('const Temporal *', tnumber2) - result = _lib.div_tnumber_tnumber(tnumber1_converted, tnumber2_converted) +def before_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.before_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def float_degrees(value: float, normalize: bool) -> 'double': - result = _lib.float_degrees(value, normalize) +def below_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.below_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def mult_float_tfloat(d: float, tnumber: 'const Temporal *') -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.mult_float_tfloat(d, tnumber_converted) +def below_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.below_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def mult_int_tint(i: int, tnumber: 'const Temporal *') -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.mult_int_tint(i, tnumber_converted) +def below_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.below_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def mult_tfloat_float(tnumber: 'const Temporal *', d: float) -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.mult_tfloat_float(tnumber_converted, d) +def front_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.front_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def mult_tint_int(tnumber: 'const Temporal *', i: int) -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.mult_tint_int(tnumber_converted, i) +def front_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.front_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def mult_tnumber_tnumber(tnumber1: 'const Temporal *', tnumber2: 'const Temporal *') -> 'Temporal *': - tnumber1_converted = _ffi.cast('const Temporal *', tnumber1) - tnumber2_converted = _ffi.cast('const Temporal *', tnumber2) - result = _lib.mult_tnumber_tnumber(tnumber1_converted, tnumber2_converted) +def front_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.front_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def sub_float_tfloat(d: float, tnumber: 'const Temporal *') -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.sub_float_tfloat(d, tnumber_converted) +def left_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.left_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def sub_int_tint(i: int, tnumber: 'const Temporal *') -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.sub_int_tint(i, tnumber_converted) +def left_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.left_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def sub_tfloat_float(tnumber: 'const Temporal *', d: float) -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.sub_tfloat_float(tnumber_converted, d) +def left_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.left_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def sub_tint_int(tnumber: 'const Temporal *', i: int) -> 'Temporal *': - tnumber_converted = _ffi.cast('const Temporal *', tnumber) - result = _lib.sub_tint_int(tnumber_converted, i) +def left_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.left_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def sub_tnumber_tnumber(tnumber1: 'const Temporal *', tnumber2: 'const Temporal *') -> 'Temporal *': - tnumber1_converted = _ffi.cast('const Temporal *', tnumber1) - tnumber2_converted = _ffi.cast('const Temporal *', tnumber2) - result = _lib.sub_tnumber_tnumber(tnumber1_converted, tnumber2_converted) +def left_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.left_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_round(temp: 'const Temporal *', maxdd: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_round(temp_converted, maxdd) +def left_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.left_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatarr_round(temp: 'const Temporal **', count: int, maxdd: int) -> 'Temporal **': - temp_converted = [_ffi.cast('const Temporal *', x) for x in temp] - result = _lib.tfloatarr_round(temp_converted, count, maxdd) +def left_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.left_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_degrees(temp: 'const Temporal *', normalize: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_degrees(temp_converted, normalize) +def left_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.left_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_derivative(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_derivative(temp_converted) +def overabove_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overabove_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_radians(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_radians(temp_converted) +def overabove_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.overabove_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_abs(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tnumber_abs(temp_converted) +def overabove_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overabove_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_angular_difference(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tnumber_angular_difference(temp_converted) +def overafter_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overafter_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_delta_value(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tnumber_delta_value(temp_converted) +def overafter_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overafter_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def textcat_text_ttext(txt: str, temp: 'const Temporal *') -> 'Temporal *': - txt_converted = cstring2text(txt) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.textcat_text_ttext(txt_converted, temp_converted) +def overafter_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overafter_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def textcat_ttext_text(temp: 'const Temporal *', txt: str) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - txt_converted = cstring2text(txt) - result = _lib.textcat_ttext_text(temp_converted, txt_converted) +def overafter_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overafter_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def textcat_ttext_ttext(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.textcat_ttext_ttext(temp1_converted, temp2_converted) +def overafter_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.overafter_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_upper(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.ttext_upper(temp_converted) +def overafter_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overafter_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_lower(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.ttext_lower(temp_converted) +def overafter_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.overafter_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def distance_tfloat_float(temp: 'const Temporal *', d: float) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.distance_tfloat_float(temp_converted, d) +def overafter_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overafter_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def distance_tint_int(temp: 'const Temporal *', i: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.distance_tint_int(temp_converted, i) +def overafter_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overafter_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def distance_tnumber_tnumber(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.distance_tnumber_tnumber(temp1_converted, temp2_converted) +def overback_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overback_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def distance_tpoint_point(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.distance_tpoint_point(temp_converted, gs_converted) +def overback_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.overback_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def distance_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.distance_tpoint_tpoint(temp1_converted, temp2_converted) +def overback_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overback_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_stbox_geo(box: 'const STBox *', gs: 'const GSERIALIZED *') -> 'double': - box_converted = _ffi.cast('const STBox *', box) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.nad_stbox_geo(box_converted, gs_converted) +def overbefore_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overbefore_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def nad_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'double': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) - result = _lib.nad_stbox_stbox(box1_converted, box2_converted) +def overbefore_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overbefore_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'double': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) - result = _lib.nad_tbox_tbox(box1_converted, box2_converted) +def overbefore_temporal_tstzspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overbefore_temporal_tstzspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tfloat_float(temp: 'const Temporal *', d: float) -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.nad_tfloat_float(temp_converted, d) +def overbefore_temporal_temporal( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overbefore_temporal_temporal(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tfloat_tfloat(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'double': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.nad_tfloat_tfloat(temp1_converted, temp2_converted) +def overbefore_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.overbefore_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tint_int(temp: 'const Temporal *', i: int) -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.nad_tint_int(temp_converted, i) +def overbefore_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overbefore_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tint_tint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'int': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.nad_tint_tint(temp1_converted, temp2_converted) +def overbefore_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.overbefore_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnumber_tbox(temp: 'const Temporal *', box: 'const TBox *') -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const TBox *', box) - result = _lib.nad_tnumber_tbox(temp_converted, box_converted) +def overbefore_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overbefore_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.nad_tpoint_geo(temp_converted, gs_converted) +def overbefore_tstzspan_temporal(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overbefore_tstzspan_temporal(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tpoint_stbox(temp: 'const Temporal *', box: 'const STBox *') -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.nad_tpoint_stbox(temp_converted, box_converted) +def overbelow_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overbelow_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'double': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.nad_tpoint_tpoint(temp1_converted, temp2_converted) +def overbelow_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.overbelow_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'TInstant *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.nai_tpoint_geo(temp_converted, gs_converted) +def overbelow_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overbelow_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nai_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'TInstant *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.nai_tpoint_tpoint(temp1_converted, temp2_converted) +def overfront_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overfront_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def shortestline_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'GSERIALIZED **': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - out_result = _ffi.new('GSERIALIZED **') - result = _lib.shortestline_tpoint_geo(temp_converted, gs_converted, out_result) +def overfront_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.overfront_tpoint_stbox(temp_converted, box_converted) _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None + return result if result != _ffi.NULL else None -def shortestline_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'GSERIALIZED **': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - out_result = _ffi.new('GSERIALIZED **') - result = _lib.shortestline_tpoint_tpoint(temp1_converted, temp2_converted, out_result) +def overfront_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overfront_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None + return result if result != _ffi.NULL else None -def bearing_point_point(gs1: 'const GSERIALIZED *', gs2: 'const GSERIALIZED *') -> 'double': - gs1_converted = _ffi.cast('const GSERIALIZED *', gs1) - gs2_converted = _ffi.cast('const GSERIALIZED *', gs2) - out_result = _ffi.new('double *') - result = _lib.bearing_point_point(gs1_converted, gs2_converted, out_result) +def overleft_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overleft_numspan_tnumber(s_converted, temp_converted) _check_error() - if result: - return out_result[0] if out_result[0] != _ffi.NULL else None - return None + return result if result != _ffi.NULL else None -def bearing_tpoint_point(temp: 'const Temporal *', gs: 'const GSERIALIZED *', invert: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.bearing_tpoint_point(temp_converted, gs_converted, invert) +def overleft_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overleft_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def bearing_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.bearing_tpoint_tpoint(temp1_converted, temp2_converted) +def overleft_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overleft_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_angular_difference(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_angular_difference(temp_converted) +def overleft_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overleft_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_azimuth(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_azimuth(temp_converted) +def overleft_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.overleft_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_convex_hull(temp: 'const Temporal *') -> 'GSERIALIZED *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_convex_hull(temp_converted) +def overleft_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overleft_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_cumulative_length(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_cumulative_length(temp_converted) +def overleft_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.overleft_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_direction(temp: 'const Temporal *') -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) - out_result = _ffi.new('double *') - result = _lib.tpoint_direction(temp_converted, out_result) +def overleft_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overleft_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() - if result: - return out_result[0] if out_result[0] != _ffi.NULL else None - return None + return result if result != _ffi.NULL else None -def tpoint_get_x(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_get_x(temp_converted) +def overright_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overright_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_get_y(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_get_y(temp_converted) +def overright_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overright_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_get_z(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_get_z(temp_converted) +def overright_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.overright_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_is_simple(temp: 'const Temporal *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_is_simple(temp_converted) +def overright_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overright_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_length(temp: 'const Temporal *') -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_length(temp_converted) +def overright_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.overright_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_speed(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_speed(temp_converted) +def overright_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overright_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_srid(temp: 'const Temporal *') -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_srid(temp_converted) +def overright_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.overright_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_stboxes(temp: 'const Temporal *') -> "Tuple['STBox *', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') - result = _lib.tpoint_stboxes(temp_converted, count) +def overright_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.overright_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tpoint_trajectory(temp: 'const Temporal *') -> 'GSERIALIZED *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_trajectory(temp_converted) +def right_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": + s_converted = _ffi.cast("const Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.right_numspan_tnumber(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def geo_expand_space(gs: 'const GSERIALIZED *', d: float) -> 'STBox *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.geo_expand_space(gs_converted, d) +def right_stbox_tpoint(box: "const STBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const STBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.right_stbox_tpoint(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def geomeas_to_tpoint(gs: 'const GSERIALIZED *') -> 'Temporal *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.geomeas_to_tpoint(gs_converted) +def right_tbox_tnumber(box: "const TBox *", temp: "const Temporal *") -> "bool": + box_converted = _ffi.cast("const TBox *", box) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.right_tbox_tnumber(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpoint_to_tgeompoint(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tgeogpoint_to_tgeompoint(temp_converted) +def right_tnumber_numspan(temp: "const Temporal *", s: "const Span *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.right_tnumber_numspan(temp_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_to_tgeogpoint(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tgeompoint_to_tgeogpoint(temp_converted) +def right_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.right_tnumber_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_AsMVTGeom(temp: 'const Temporal *', bounds: 'const STBox *', extent: 'int32_t', buffer: 'int32_t', clip_geom: bool, gsarr: 'GSERIALIZED **', timesarr: 'int64 **') -> "Tuple['bool', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - bounds_converted = _ffi.cast('const STBox *', bounds) - extent_converted = _ffi.cast('int32_t', extent) - buffer_converted = _ffi.cast('int32_t', buffer) - gsarr_converted = [_ffi.cast('GSERIALIZED *', x) for x in gsarr] - timesarr_converted = [_ffi.cast('int64 *', x) for x in timesarr] - count = _ffi.new('int *') - result = _lib.tpoint_AsMVTGeom(temp_converted, bounds_converted, extent_converted, buffer_converted, clip_geom, gsarr_converted, timesarr_converted, count) +def right_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.right_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tpoint_expand_space(temp: 'const Temporal *', d: float) -> 'STBox *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_expand_space(temp_converted, d) +def right_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.right_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_make_simple(temp: 'const Temporal *') -> "Tuple['Temporal **', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') - result = _lib.tpoint_make_simple(temp_converted, count) +def right_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "bool": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.right_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tpoint_round(temp: 'const Temporal *', maxdd: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_round(temp_converted, maxdd) +def tand_bool_tbool(b: bool, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tand_bool_tbool(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpointarr_round(temp: 'const Temporal **', count: int, maxdd: int) -> 'Temporal **': - temp_converted = [_ffi.cast('const Temporal *', x) for x in temp] - result = _lib.tpointarr_round(temp_converted, count, maxdd) +def tand_tbool_bool(temp: "const Temporal *", b: bool) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tand_tbool_bool(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def tpoint_set_srid(temp: 'const Temporal *', srid: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - srid_converted = _ffi.cast('int32', srid) - result = _lib.tpoint_set_srid(temp_converted, srid_converted) +def tand_tbool_tbool( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.tand_tbool_tbool(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_tfloat_to_geomeas(tpoint: 'const Temporal *', measure: 'const Temporal *', segmentize: bool) -> 'GSERIALIZED **': - tpoint_converted = _ffi.cast('const Temporal *', tpoint) - measure_converted = _ffi.cast('const Temporal *', measure) - out_result = _ffi.new('GSERIALIZED **') - result = _lib.tpoint_tfloat_to_geomeas(tpoint_converted, measure_converted, segmentize, out_result) +def tbool_when_true(temp: "const Temporal *") -> "SpanSet *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tbool_when_true(temp_converted) _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None + return result if result != _ffi.NULL else None -def econtains_geo_tpoint(gs: 'const GSERIALIZED *', temp: 'const Temporal *') -> 'int': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.econtains_geo_tpoint(gs_converted, temp_converted) +def tnot_tbool(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tnot_tbool(temp_converted) _check_error() return result if result != _ffi.NULL else None -def edisjoint_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.edisjoint_tpoint_geo(temp_converted, gs_converted) +def tor_bool_tbool(b: bool, temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tor_bool_tbool(b, temp_converted) _check_error() return result if result != _ffi.NULL else None -def edisjoint_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'int': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.edisjoint_tpoint_tpoint(temp1_converted, temp2_converted) +def tor_tbool_bool(temp: "const Temporal *", b: bool) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tor_tbool_bool(temp_converted, b) _check_error() return result if result != _ffi.NULL else None -def edwithin_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *', dist: float) -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.edwithin_tpoint_geo(temp_converted, gs_converted, dist) +def tor_tbool_tbool( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.tor_tbool_tbool(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def edwithin_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *', dist: float) -> 'int': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.edwithin_tpoint_tpoint(temp1_converted, temp2_converted, dist) +def add_float_tfloat(d: float, tnumber: "const Temporal *") -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.add_float_tfloat(d, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def eintersects_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.eintersects_tpoint_geo(temp_converted, gs_converted) +def add_int_tint(i: int, tnumber: "const Temporal *") -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.add_int_tint(i, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def eintersects_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'int': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.eintersects_tpoint_tpoint(temp1_converted, temp2_converted) +def add_tfloat_float(tnumber: "const Temporal *", d: float) -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.add_tfloat_float(tnumber_converted, d) _check_error() return result if result != _ffi.NULL else None -def etouches_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *') -> 'int': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.etouches_tpoint_geo(temp_converted, gs_converted) +def add_tint_int(tnumber: "const Temporal *", i: int) -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.add_tint_int(tnumber_converted, i) _check_error() return result if result != _ffi.NULL else None -def tcontains_geo_tpoint(gs: 'const GSERIALIZED *', temp: 'const Temporal *', restr: bool, atvalue: bool) -> 'Temporal *': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tcontains_geo_tpoint(gs_converted, temp_converted, restr, atvalue) +def add_tnumber_tnumber( + tnumber1: "const Temporal *", tnumber2: "const Temporal *" +) -> "Temporal *": + tnumber1_converted = _ffi.cast("const Temporal *", tnumber1) + tnumber2_converted = _ffi.cast("const Temporal *", tnumber2) + result = _lib.add_tnumber_tnumber(tnumber1_converted, tnumber2_converted) _check_error() return result if result != _ffi.NULL else None -def tdisjoint_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *', restr: bool, atvalue: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.tdisjoint_tpoint_geo(temp_converted, gs_converted, restr, atvalue) +def div_float_tfloat(d: float, tnumber: "const Temporal *") -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.div_float_tfloat(d, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def tdwithin_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *', dist: float, restr: bool, atvalue: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.tdwithin_tpoint_geo(temp_converted, gs_converted, dist, restr, atvalue) +def div_int_tint(i: int, tnumber: "const Temporal *") -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.div_int_tint(i, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def tdwithin_tpoint_tpoint(temp1: 'const Temporal *', temp2: 'const Temporal *', dist: float, restr: bool, atvalue: bool) -> 'Temporal *': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.tdwithin_tpoint_tpoint(temp1_converted, temp2_converted, dist, restr, atvalue) +def div_tfloat_float(tnumber: "const Temporal *", d: float) -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.div_tfloat_float(tnumber_converted, d) _check_error() return result if result != _ffi.NULL else None -def tintersects_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *', restr: bool, atvalue: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.tintersects_tpoint_geo(temp_converted, gs_converted, restr, atvalue) +def div_tint_int(tnumber: "const Temporal *", i: int) -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.div_tint_int(tnumber_converted, i) _check_error() return result if result != _ffi.NULL else None -def ttouches_tpoint_geo(temp: 'const Temporal *', gs: 'const GSERIALIZED *', restr: bool, atvalue: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - result = _lib.ttouches_tpoint_geo(temp_converted, gs_converted, restr, atvalue) +def div_tnumber_tnumber( + tnumber1: "const Temporal *", tnumber2: "const Temporal *" +) -> "Temporal *": + tnumber1_converted = _ffi.cast("const Temporal *", tnumber1) + tnumber2_converted = _ffi.cast("const Temporal *", tnumber2) + result = _lib.div_tnumber_tnumber(tnumber1_converted, tnumber2_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_tand_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tbool_tand_transfn(state_converted, temp_converted) +def mult_float_tfloat(d: float, tnumber: "const Temporal *") -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.mult_float_tfloat(d, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_tor_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tbool_tor_transfn(state_converted, temp_converted) +def mult_int_tint(i: int, tnumber: "const Temporal *") -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.mult_int_tint(i, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_extent_transfn(s: 'Span *', temp: 'const Temporal *') -> 'Span *': - s_converted = _ffi.cast('Span *', s) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_extent_transfn(s_converted, temp_converted) +def mult_tfloat_float(tnumber: "const Temporal *", d: float) -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.mult_tfloat_float(tnumber_converted, d) _check_error() return result if result != _ffi.NULL else None -def temporal_tagg_finalfn(state: 'SkipList *') -> 'Temporal *': - state_converted = _ffi.cast('SkipList *', state) - result = _lib.temporal_tagg_finalfn(state_converted) +def mult_tint_int(tnumber: "const Temporal *", i: int) -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.mult_tint_int(tnumber_converted, i) _check_error() return result if result != _ffi.NULL else None -def temporal_tcount_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_tcount_transfn(state_converted, temp_converted) +def mult_tnumber_tnumber( + tnumber1: "const Temporal *", tnumber2: "const Temporal *" +) -> "Temporal *": + tnumber1_converted = _ffi.cast("const Temporal *", tnumber1) + tnumber2_converted = _ffi.cast("const Temporal *", tnumber2) + result = _lib.mult_tnumber_tnumber(tnumber1_converted, tnumber2_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_tmax_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_tmax_transfn(state_converted, temp_converted) +def sub_float_tfloat(d: float, tnumber: "const Temporal *") -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.sub_float_tfloat(d, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_tmin_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_tmin_transfn(state_converted, temp_converted) +def sub_int_tint(i: int, tnumber: "const Temporal *") -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.sub_int_tint(i, tnumber_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_tsum_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_tsum_transfn(state_converted, temp_converted) +def sub_tfloat_float(tnumber: "const Temporal *", d: float) -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.sub_tfloat_float(tnumber_converted, d) _check_error() return result if result != _ffi.NULL else None -def tint_tmax_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tint_tmax_transfn(state_converted, temp_converted) +def sub_tint_int(tnumber: "const Temporal *", i: int) -> "Temporal *": + tnumber_converted = _ffi.cast("const Temporal *", tnumber) + result = _lib.sub_tint_int(tnumber_converted, i) _check_error() return result if result != _ffi.NULL else None -def tint_tmin_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tint_tmin_transfn(state_converted, temp_converted) +def sub_tnumber_tnumber( + tnumber1: "const Temporal *", tnumber2: "const Temporal *" +) -> "Temporal *": + tnumber1_converted = _ffi.cast("const Temporal *", tnumber1) + tnumber2_converted = _ffi.cast("const Temporal *", tnumber2) + result = _lib.sub_tnumber_tnumber(tnumber1_converted, tnumber2_converted) _check_error() return result if result != _ffi.NULL else None -def tint_tsum_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tint_tsum_transfn(state_converted, temp_converted) +def tfloat_derivative(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tfloat_derivative(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_extent_transfn(box: "Optional['TBox *']", temp: 'const Temporal *') -> 'TBox *': - box_converted = _ffi.cast('TBox *', box) if box is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tnumber_extent_transfn(box_converted, temp_converted) +def tnumber_abs(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tnumber_abs(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_integral(temp: 'const Temporal *') -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tnumber_integral(temp_converted) +def tnumber_angular_difference(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tnumber_angular_difference(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_tavg_finalfn(state: 'SkipList *') -> 'Temporal *': - state_converted = _ffi.cast('SkipList *', state) - result = _lib.tnumber_tavg_finalfn(state_converted) +def tnumber_delta_value(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tnumber_delta_value(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_tavg_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tnumber_tavg_transfn(state_converted, temp_converted) +def textcat_text_ttext(txt: str, temp: "const Temporal *") -> "Temporal *": + txt_converted = cstring2text(txt) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.textcat_text_ttext(txt_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_twavg(temp: 'const Temporal *') -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tnumber_twavg(temp_converted) +def textcat_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + txt_converted = cstring2text(txt) + result = _lib.textcat_ttext_text(temp_converted, txt_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_extent_transfn(box: "Optional['STBox *']", temp: 'const Temporal *') -> 'STBox *': - box_converted = _ffi.cast('STBox *', box) if box is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_extent_transfn(box_converted, temp_converted) +def textcat_ttext_ttext( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.textcat_ttext_ttext(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_tcentroid_finalfn(state: 'SkipList *') -> 'Temporal *': - state_converted = _ffi.cast('SkipList *', state) - result = _lib.tpoint_tcentroid_finalfn(state_converted) +def ttext_upper(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ttext_upper(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_tcentroid_transfn(state: 'SkipList *', temp: 'Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('Temporal *', temp) - result = _lib.tpoint_tcentroid_transfn(state_converted, temp_converted) +def ttext_lower(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ttext_lower(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_twcentroid(temp: 'const Temporal *') -> 'GSERIALIZED *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_twcentroid(temp_converted) +def distance_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.distance_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def ttext_tmax_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.ttext_tmax_transfn(state_converted, temp_converted) +def distance_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.distance_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def ttext_tmin_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.ttext_tmin_transfn(state_converted, temp_converted) +def distance_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.distance_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_simplify_min_dist(temp: 'const Temporal *', dist: float) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_simplify_min_dist(temp_converted, dist) +def distance_tpoint_point( + temp: "const Temporal *", gs: "const GSERIALIZED *" +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.distance_tpoint_point(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_simplify_min_tdelta(temp: 'const Temporal *', mint: 'const Interval *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - mint_converted = _ffi.cast('const Interval *', mint) - result = _lib.temporal_simplify_min_tdelta(temp_converted, mint_converted) +def distance_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.distance_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_simplify_dp(temp: 'const Temporal *', eps_dist: float, synchronized: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_simplify_dp(temp_converted, eps_dist, synchronized) +def nad_stbox_geo(box: "const STBox *", gs: "const GSERIALIZED *") -> "double": + box_converted = _ffi.cast("const STBox *", box) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.nad_stbox_geo(box_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_simplify_max_dist(temp: 'const Temporal *', eps_dist: float, synchronized: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_simplify_max_dist(temp_converted, eps_dist, synchronized) +def nad_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "double": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) + result = _lib.nad_stbox_stbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_tprecision(temp: 'const Temporal *', duration: 'const Interval *', origin: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) - origin_converted = _ffi.cast('TimestampTz', origin) - result = _lib.temporal_tprecision(temp_converted, duration_converted, origin_converted) +def nad_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "double": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) + result = _lib.nad_tbox_tbox(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_tsample(temp: 'const Temporal *', duration: 'const Interval *', origin: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - duration_converted = _ffi.cast('const Interval *', duration) - origin_converted = _ffi.cast('TimestampTz', origin) - result = _lib.temporal_tsample(temp_converted, duration_converted, origin_converted) +def nad_tfloat_float(temp: "const Temporal *", d: float) -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.nad_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def temporal_dyntimewarp_distance(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'double': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.temporal_dyntimewarp_distance(temp1_converted, temp2_converted) +def nad_tfloat_tfloat(temp1: "const Temporal *", temp2: "const Temporal *") -> "double": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.nad_tfloat_tfloat(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_dyntimewarp_path(temp1: 'const Temporal *', temp2: 'const Temporal *') -> "Tuple['Match *', 'int']": - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - count = _ffi.new('int *') - result = _lib.temporal_dyntimewarp_path(temp1_converted, temp2_converted, count) +def nad_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.nad_tint_int(temp_converted, i) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def temporal_frechet_distance(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'double': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.temporal_frechet_distance(temp1_converted, temp2_converted) +def nad_tint_tint(temp1: "const Temporal *", temp2: "const Temporal *") -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.nad_tint_tint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_frechet_path(temp1: 'const Temporal *', temp2: 'const Temporal *') -> "Tuple['Match *', 'int']": - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - count = _ffi.new('int *') - result = _lib.temporal_frechet_path(temp1_converted, temp2_converted, count) +def nad_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.nad_tnumber_tbox(temp_converted, box_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def temporal_hausdorff_distance(temp1: 'const Temporal *', temp2: 'const Temporal *') -> 'double': - temp1_converted = _ffi.cast('const Temporal *', temp1) - temp2_converted = _ffi.cast('const Temporal *', temp2) - result = _lib.temporal_hausdorff_distance(temp1_converted, temp2_converted) +def nad_tpoint_geo(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.nad_tpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def float_bucket(value: float, size: float, origin: float) -> 'double': - result = _lib.float_bucket(value, size, origin) +def nad_tpoint_stbox(temp: "const Temporal *", box: "const STBox *") -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.nad_tpoint_stbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_bucket_list(bounds: 'const Span *', size: float, origin: float) -> "Tuple['Span *', 'int']": - bounds_converted = _ffi.cast('const Span *', bounds) - count = _ffi.new('int *') - result = _lib.floatspan_bucket_list(bounds_converted, size, origin, count) +def nad_tpoint_tpoint(temp1: "const Temporal *", temp2: "const Temporal *") -> "double": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.nad_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def int_bucket(value: int, size: int, origin: int) -> 'int': - result = _lib.int_bucket(value, size, origin) +def nai_tpoint_geo(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "TInstant *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.nai_tpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def intspan_bucket_list(bounds: 'const Span *', size: int, origin: int) -> "Tuple['Span *', 'int']": - bounds_converted = _ffi.cast('const Span *', bounds) - count = _ffi.new('int *') - result = _lib.intspan_bucket_list(bounds_converted, size, origin, count) +def nai_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "TInstant *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.nai_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tstzspan_bucket_list(bounds: 'const Span *', duration: 'const Interval *', origin: int) -> "Tuple['Span *', 'int']": - bounds_converted = _ffi.cast('const Span *', bounds) - duration_converted = _ffi.cast('const Interval *', duration) - origin_converted = _ffi.cast('TimestampTz', origin) - count = _ffi.new('int *') - result = _lib.tstzspan_bucket_list(bounds_converted, duration_converted, origin_converted, count) +def shortestline_tpoint_geo( + temp: "const Temporal *", gs: "const GSERIALIZED *" +) -> "GSERIALIZED *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.shortestline_tpoint_geo(temp_converted, gs_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def stbox_tile(point: 'GSERIALIZED *', t: int, xsize: float, ysize: float, zsize: float, duration: 'Interval *', sorigin: 'GSERIALIZED *', torigin: int, hast: bool) -> 'STBox *': - point_converted = _ffi.cast('GSERIALIZED *', point) - t_converted = _ffi.cast('TimestampTz', t) - duration_converted = _ffi.cast('Interval *', duration) - sorigin_converted = _ffi.cast('GSERIALIZED *', sorigin) - torigin_converted = _ffi.cast('TimestampTz', torigin) - result = _lib.stbox_tile(point_converted, t_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted, hast) +def shortestline_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "GSERIALIZED *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.shortestline_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_tile_list(bounds: 'const STBox *', xsize: float, ysize: float, zsize: float, duration: "Optional['const Interval *']", sorigin: 'GSERIALIZED *', torigin: int) -> "Tuple['STBox *', 'int']": - bounds_converted = _ffi.cast('const STBox *', bounds) - duration_converted = _ffi.cast('const Interval *', duration) if duration is not None else _ffi.NULL - sorigin_converted = _ffi.cast('GSERIALIZED *', sorigin) - torigin_converted = _ffi.cast('TimestampTz', torigin) - count = _ffi.new('int *') - result = _lib.stbox_tile_list(bounds_converted, xsize, ysize, zsize, duration_converted, sorigin_converted, torigin_converted, count) +def bearing_point_point( + gs1: "const GSERIALIZED *", gs2: "const GSERIALIZED *" +) -> "double": + gs1_converted = _ffi.cast("const GSERIALIZED *", gs1) + gs2_converted = _ffi.cast("const GSERIALIZED *", gs2) + out_result = _ffi.new("double *") + result = _lib.bearing_point_point(gs1_converted, gs2_converted, out_result) _check_error() - return result if result != _ffi.NULL else None, count[0] + if result: + return out_result[0] if out_result[0] != _ffi.NULL else None + return None -def tintbox_tile_list(box: 'const TBox *', xsize: int, duration: 'const Interval *', xorigin: 'Optional[int]', torigin: "Optional[int]") -> "Tuple['TBox *', 'int']": - box_converted = _ffi.cast('const TBox *', box) - duration_converted = _ffi.cast('const Interval *', duration) - xorigin_converted = xorigin if xorigin is not None else _ffi.NULL - torigin_converted = _ffi.cast('TimestampTz', torigin) if torigin is not None else _ffi.NULL - count = _ffi.new('int *') - result = _lib.tintbox_tile_list(box_converted, xsize, duration_converted, xorigin_converted, torigin_converted, count) +def bearing_tpoint_point( + temp: "const Temporal *", gs: "const GSERIALIZED *", invert: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.bearing_tpoint_point(temp_converted, gs_converted, invert) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tfloatbox_tile_list(box: 'const TBox *', xsize: float, duration: 'const Interval *', xorigin: 'Optional[float]', torigin: "Optional[int]") -> "Tuple['TBox *', 'int']": - box_converted = _ffi.cast('const TBox *', box) - duration_converted = _ffi.cast('const Interval *', duration) - xorigin_converted = xorigin if xorigin is not None else _ffi.NULL - torigin_converted = _ffi.cast('TimestampTz', torigin) if torigin is not None else _ffi.NULL - count = _ffi.new('int *') - result = _lib.tfloatbox_tile_list(box_converted, xsize, duration_converted, xorigin_converted, torigin_converted, count) +def bearing_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.bearing_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def temporal_time_split(temp: 'Temporal *', duration: 'Interval *', torigin: int) -> "Tuple['Temporal **', 'TimestampTz *', 'int']": - temp_converted = _ffi.cast('Temporal *', temp) - duration_converted = _ffi.cast('Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - time_buckets = _ffi.new('TimestampTz **') - count = _ffi.new('int *') - result = _lib.temporal_time_split(temp_converted, duration_converted, torigin_converted, time_buckets, count) +def tpoint_angular_difference(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_angular_difference(temp_converted) _check_error() - return result if result != _ffi.NULL else None, time_buckets[0], count[0] + return result if result != _ffi.NULL else None -def tfloat_value_split(temp: 'Temporal *', size: float, origin: float) -> "Tuple['Temporal **', 'double *', 'int']": - temp_converted = _ffi.cast('Temporal *', temp) - value_buckets = _ffi.new('double **') - count = _ffi.new('int *') - result = _lib.tfloat_value_split(temp_converted, size, origin, value_buckets, count) +def tpoint_azimuth(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_azimuth(temp_converted) _check_error() - return result if result != _ffi.NULL else None, value_buckets[0], count[0] + return result if result != _ffi.NULL else None -def tfloat_value_time_split(temp: 'Temporal *', size: float, duration: 'Interval *', vorigin: float, torigin: int) -> "Tuple['Temporal **', 'double *', 'TimestampTz *', 'int']": - temp_converted = _ffi.cast('Temporal *', temp) - duration_converted = _ffi.cast('Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - value_buckets = _ffi.new('double **') - time_buckets = _ffi.new('TimestampTz **') - count = _ffi.new('int *') - result = _lib.tfloat_value_time_split(temp_converted, size, duration_converted, vorigin, torigin_converted, value_buckets, time_buckets, count) +def tpoint_convex_hull(temp: "const Temporal *") -> "GSERIALIZED *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_convex_hull(temp_converted) _check_error() - return result if result != _ffi.NULL else None, value_buckets[0], time_buckets[0], count[0] + return result if result != _ffi.NULL else None -def timestamptz_bucket(timestamp: int, duration: 'const Interval *', origin: int) -> 'TimestampTz': - timestamp_converted = _ffi.cast('TimestampTz', timestamp) - duration_converted = _ffi.cast('const Interval *', duration) - origin_converted = _ffi.cast('TimestampTz', origin) - result = _lib.timestamptz_bucket(timestamp_converted, duration_converted, origin_converted) +def tpoint_cumulative_length(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_cumulative_length(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_value_split(temp: 'Temporal *', size: int, origin: int) -> "Tuple['Temporal **', 'int *', 'int']": - temp_converted = _ffi.cast('Temporal *', temp) - value_buckets = _ffi.new('int **') - count = _ffi.new('int *') - result = _lib.tint_value_split(temp_converted, size, origin, value_buckets, count) +def tpoint_direction(temp: "const Temporal *") -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) + out_result = _ffi.new("double *") + result = _lib.tpoint_direction(temp_converted, out_result) _check_error() - return result if result != _ffi.NULL else None, value_buckets[0], count[0] + if result: + return out_result[0] if out_result[0] != _ffi.NULL else None + return None -def tint_value_time_split(temp: 'Temporal *', size: int, duration: 'Interval *', vorigin: int, torigin: int) -> "Tuple['Temporal **', 'int *', 'TimestampTz *', 'int']": - temp_converted = _ffi.cast('Temporal *', temp) - duration_converted = _ffi.cast('Interval *', duration) - torigin_converted = _ffi.cast('TimestampTz', torigin) - value_buckets = _ffi.new('int **') - time_buckets = _ffi.new('TimestampTz **') - count = _ffi.new('int *') - result = _lib.tint_value_time_split(temp_converted, size, duration_converted, vorigin, torigin_converted, value_buckets, time_buckets, count) +def tpoint_get_x(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_get_x(temp_converted) _check_error() - return result if result != _ffi.NULL else None, value_buckets[0], time_buckets[0], count[0] + return result if result != _ffi.NULL else None -def tpoint_space_split(temp: 'Temporal *', xsize: 'float', ysize: 'float', zsize: 'float', sorigin: 'GSERIALIZED *', bitmatrix: bool) -> "Tuple['Temporal **', 'GSERIALIZED ***', 'int']": - temp_converted = _ffi.cast('Temporal *', temp) - xsize_converted = _ffi.cast('float', xsize) - ysize_converted = _ffi.cast('float', ysize) - zsize_converted = _ffi.cast('float', zsize) - sorigin_converted = _ffi.cast('GSERIALIZED *', sorigin) - space_buckets = _ffi.new('GSERIALIZED ***') - count = _ffi.new('int *') - result = _lib.tpoint_space_split(temp_converted, xsize_converted, ysize_converted, zsize_converted, sorigin_converted, bitmatrix, space_buckets, count) +def tpoint_get_y(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_get_y(temp_converted) _check_error() - return result if result != _ffi.NULL else None, space_buckets[0], count[0] + return result if result != _ffi.NULL else None -def tpoint_space_time_split(temp: 'Temporal *', xsize: 'float', ysize: 'float', zsize: 'float', duration: 'Interval *', sorigin: 'GSERIALIZED *', torigin: int, bitmatrix: bool) -> "Tuple['Temporal **', 'GSERIALIZED ***', 'TimestampTz *', 'int']": - temp_converted = _ffi.cast('Temporal *', temp) - xsize_converted = _ffi.cast('float', xsize) - ysize_converted = _ffi.cast('float', ysize) - zsize_converted = _ffi.cast('float', zsize) - duration_converted = _ffi.cast('Interval *', duration) - sorigin_converted = _ffi.cast('GSERIALIZED *', sorigin) - torigin_converted = _ffi.cast('TimestampTz', torigin) - space_buckets = _ffi.new('GSERIALIZED ***') - time_buckets = _ffi.new('TimestampTz **') - count = _ffi.new('int *') - result = _lib.tpoint_space_time_split(temp_converted, xsize_converted, ysize_converted, zsize_converted, duration_converted, sorigin_converted, torigin_converted, bitmatrix, space_buckets, time_buckets, count) +def tpoint_get_z(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_get_z(temp_converted) _check_error() - return result if result != _ffi.NULL else None, space_buckets[0], time_buckets[0], count[0] + return result if result != _ffi.NULL else None -def temptype_subtype(subtype: 'tempSubtype') -> 'bool': - subtype_converted = _ffi.cast('tempSubtype', subtype) - result = _lib.temptype_subtype(subtype_converted) +def tpoint_is_simple(temp: "const Temporal *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_is_simple(temp_converted) _check_error() return result if result != _ffi.NULL else None -def temptype_subtype_all(subtype: 'tempSubtype') -> 'bool': - subtype_converted = _ffi.cast('tempSubtype', subtype) - result = _lib.temptype_subtype_all(subtype_converted) +def tpoint_length(temp: "const Temporal *") -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_length(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tempsubtype_name(subtype: 'tempSubtype') -> str: - subtype_converted = _ffi.cast('tempSubtype', subtype) - result = _lib.tempsubtype_name(subtype_converted) +def tpoint_speed(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_speed(temp_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tempsubtype_from_string(string: str, subtype: 'int16 *') -> 'bool': - string_converted = string.encode('utf-8') - subtype_converted = _ffi.cast('int16 *', subtype) - result = _lib.tempsubtype_from_string(string_converted, subtype_converted) +def tpoint_srid(temp: "const Temporal *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_srid(temp_converted) _check_error() return result if result != _ffi.NULL else None -def meosoper_name(oper: 'meosOper') -> str: - oper_converted = _ffi.cast('meosOper', oper) - result = _lib.meosoper_name(oper_converted) +def tpoint_stboxes(temp: "const Temporal *") -> "Tuple['STBox *', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") + result = _lib.tpoint_stboxes(temp_converted, count) _check_error() - result = _ffi.string(result).decode('utf-8') - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def meosoper_from_string(name: str) -> 'meosOper': - name_converted = name.encode('utf-8') - result = _lib.meosoper_from_string(name_converted) +def tpoint_trajectory(temp: "const Temporal *") -> "GSERIALIZED *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_trajectory(temp_converted) _check_error() return result if result != _ffi.NULL else None -def interptype_name(interp: 'interpType') -> str: - interp_converted = _ffi.cast('interpType', interp) - result = _lib.interptype_name(interp_converted) +def tpoint_twcentroid(temp: "const Temporal *") -> "GSERIALIZED *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_twcentroid(temp_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def interptype_from_string(interp_str: str) -> 'interpType': - interp_str_converted = interp_str.encode('utf-8') - result = _lib.interptype_from_string(interp_str_converted) +def geo_expand_space(gs: "const GSERIALIZED *", d: float) -> "STBox *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.geo_expand_space(gs_converted, d) _check_error() return result if result != _ffi.NULL else None -def meostype_name(type: 'meosType') -> str: - type_converted = _ffi.cast('meosType', type) - result = _lib.meostype_name(type_converted) +def geomeas_to_tpoint(gs: "const GSERIALIZED *") -> "Temporal *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.geomeas_to_tpoint(gs_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def temptype_basetype(type: 'meosType') -> 'meosType': - type_converted = _ffi.cast('meosType', type) - result = _lib.temptype_basetype(type_converted) +def tgeogpoint_to_tgeompoint(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tgeogpoint_to_tgeompoint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def settype_basetype(type: 'meosType') -> 'meosType': - type_converted = _ffi.cast('meosType', type) - result = _lib.settype_basetype(type_converted) +def tgeompoint_to_tgeogpoint(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tgeompoint_to_tgeogpoint(temp_converted) _check_error() return result if result != _ffi.NULL else None -def spantype_basetype(type: 'meosType') -> 'meosType': - type_converted = _ffi.cast('meosType', type) - result = _lib.spantype_basetype(type_converted) +def tpoint_AsMVTGeom( + temp: "const Temporal *", + bounds: "const STBox *", + extent: "int32_t", + buffer: "int32_t", + clip_geom: bool, + gsarr: "GSERIALIZED **", + timesarr: "int64 **", +) -> "Tuple['bool', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + bounds_converted = _ffi.cast("const STBox *", bounds) + extent_converted = _ffi.cast("int32_t", extent) + buffer_converted = _ffi.cast("int32_t", buffer) + gsarr_converted = [_ffi.cast("GSERIALIZED *", x) for x in gsarr] + timesarr_converted = [_ffi.cast("int64 *", x) for x in timesarr] + count = _ffi.new("int *") + result = _lib.tpoint_AsMVTGeom( + temp_converted, + bounds_converted, + extent_converted, + buffer_converted, + clip_geom, + gsarr_converted, + timesarr_converted, + count, + ) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def spantype_spansettype(type: 'meosType') -> 'meosType': - type_converted = _ffi.cast('meosType', type) - result = _lib.spantype_spansettype(type_converted) +def tpoint_expand_space(temp: "const Temporal *", d: float) -> "STBox *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_expand_space(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def spansettype_spantype(type: 'meosType') -> 'meosType': - type_converted = _ffi.cast('meosType', type) - result = _lib.spansettype_spantype(type_converted) +def tpoint_make_simple(temp: "const Temporal *") -> "Tuple['Temporal **', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") + result = _lib.tpoint_make_simple(temp_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def basetype_spantype(type: 'meosType') -> 'meosType': - type_converted = _ffi.cast('meosType', type) - result = _lib.basetype_spantype(type_converted) +def tpoint_set_srid(temp: "const Temporal *", srid: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + srid_converted = _ffi.cast("int32", srid) + result = _lib.tpoint_set_srid(temp_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def basetype_settype(type: 'meosType') -> 'meosType': - type_converted = _ffi.cast('meosType', type) - result = _lib.basetype_settype(type_converted) +def tpoint_tfloat_to_geomeas( + tpoint: "const Temporal *", measure: "const Temporal *", segmentize: bool +) -> "GSERIALIZED **": + tpoint_converted = _ffi.cast("const Temporal *", tpoint) + measure_converted = _ffi.cast("const Temporal *", measure) + out_result = _ffi.new("GSERIALIZED **") + result = _lib.tpoint_tfloat_to_geomeas( + tpoint_converted, measure_converted, segmentize, out_result + ) _check_error() - return result if result != _ffi.NULL else None + if result: + return out_result if out_result != _ffi.NULL else None + return None -def meostype_internal(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.meostype_internal(type_converted) +def acontains_geo_tpoint(gs: "const GSERIALIZED *", temp: "const Temporal *") -> "int": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.acontains_geo_tpoint(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def meos_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.meos_basetype(type_converted) +def adisjoint_tpoint_geo(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.adisjoint_tpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def alpha_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.alpha_basetype(type_converted) +def adisjoint_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.adisjoint_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.tnumber_basetype(type_converted) +def adwithin_tpoint_geo( + temp: "const Temporal *", gs: "const GSERIALIZED *", dist: float +) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.adwithin_tpoint_geo(temp_converted, gs_converted, dist) _check_error() return result if result != _ffi.NULL else None -def alphanum_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.alphanum_basetype(type_converted) +def adwithin_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *", dist: float +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.adwithin_tpoint_tpoint(temp1_converted, temp2_converted, dist) _check_error() return result if result != _ffi.NULL else None -def geo_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.geo_basetype(type_converted) +def aintersects_tpoint_geo( + temp: "const Temporal *", gs: "const GSERIALIZED *" +) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.aintersects_tpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def spatial_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.spatial_basetype(type_converted) +def aintersects_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.aintersects_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def time_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.time_type(type_converted) +def atouches_tpoint_geo(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.atouches_tpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def set_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.set_basetype(type_converted) +def econtains_geo_tpoint(gs: "const GSERIALIZED *", temp: "const Temporal *") -> "int": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.econtains_geo_tpoint(gs_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def set_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.set_type(type_converted) +def edisjoint_tpoint_geo(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.edisjoint_tpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def numset_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.numset_type(type_converted) +def edisjoint_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.edisjoint_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_numset_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.ensure_numset_type(type_converted) +def edwithin_tpoint_geo( + temp: "const Temporal *", gs: "const GSERIALIZED *", dist: float +) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.edwithin_tpoint_geo(temp_converted, gs_converted, dist) _check_error() return result if result != _ffi.NULL else None -def timeset_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.timeset_type(type_converted) +def edwithin_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *", dist: float +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.edwithin_tpoint_tpoint(temp1_converted, temp2_converted, dist) _check_error() return result if result != _ffi.NULL else None -def ensure_timeset_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.ensure_timeset_type(type_converted) +def eintersects_tpoint_geo( + temp: "const Temporal *", gs: "const GSERIALIZED *" +) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.eintersects_tpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def set_spantype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.set_spantype(type_converted) +def eintersects_tpoint_tpoint( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "int": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.eintersects_tpoint_tpoint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_set_spantype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.ensure_set_spantype(type_converted) +def etouches_tpoint_geo(temp: "const Temporal *", gs: "const GSERIALIZED *") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.etouches_tpoint_geo(temp_converted, gs_converted) _check_error() return result if result != _ffi.NULL else None -def alphanumset_type(settype: 'meosType') -> 'bool': - settype_converted = _ffi.cast('meosType', settype) - result = _lib.alphanumset_type(settype_converted) +def tcontains_geo_tpoint( + gs: "const GSERIALIZED *", temp: "const Temporal *", restr: bool, atvalue: bool +) -> "Temporal *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tcontains_geo_tpoint(gs_converted, temp_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def geoset_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.geoset_type(type_converted) +def tdisjoint_tpoint_geo( + temp: "const Temporal *", gs: "const GSERIALIZED *", restr: bool, atvalue: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.tdisjoint_tpoint_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def ensure_geoset_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.ensure_geoset_type(type_converted) +def tdwithin_tpoint_geo( + temp: "const Temporal *", + gs: "const GSERIALIZED *", + dist: float, + restr: bool, + atvalue: bool, +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.tdwithin_tpoint_geo( + temp_converted, gs_converted, dist, restr, atvalue + ) _check_error() return result if result != _ffi.NULL else None -def spatialset_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.spatialset_type(type_converted) +def tdwithin_tpoint_tpoint( + temp1: "const Temporal *", + temp2: "const Temporal *", + dist: float, + restr: bool, + atvalue: bool, +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.tdwithin_tpoint_tpoint( + temp1_converted, temp2_converted, dist, restr, atvalue + ) _check_error() return result if result != _ffi.NULL else None -def ensure_spatialset_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.ensure_spatialset_type(type_converted) +def tintersects_tpoint_geo( + temp: "const Temporal *", gs: "const GSERIALIZED *", restr: bool, atvalue: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.tintersects_tpoint_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def span_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.span_basetype(type_converted) +def ttouches_tpoint_geo( + temp: "const Temporal *", gs: "const GSERIALIZED *", restr: bool, atvalue: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + result = _lib.ttouches_tpoint_geo(temp_converted, gs_converted, restr, atvalue) _check_error() return result if result != _ffi.NULL else None -def span_canon_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.span_canon_basetype(type_converted) +def tbool_tand_transfn( + state: "Optional['SkipList *']", temp: "const Temporal *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tbool_tand_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def span_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.span_type(type_converted) +def tbool_tor_transfn( + state: "Optional['SkipList *']", temp: "const Temporal *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tbool_tor_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def span_bbox_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.span_bbox_type(type_converted) +def temporal_extent_transfn(s: "Span *", temp: "const Temporal *") -> "Span *": + s_converted = _ffi.cast("Span *", s) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_extent_transfn(s_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.numspan_basetype(type_converted) +def temporal_tagg_finalfn(state: "SkipList *") -> "Temporal *": + state_converted = _ffi.cast("SkipList *", state) + result = _lib.temporal_tagg_finalfn(state_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.numspan_type(type_converted) +def temporal_tcount_transfn( + state: "Optional['SkipList *']", temp: "const Temporal *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_tcount_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_numspan_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.ensure_numspan_type(type_converted) +def tfloat_tmax_transfn( + state: "Optional['SkipList *']", temp: "const Temporal *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tfloat_tmax_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def timespan_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.timespan_basetype(type_converted) +def tfloat_tmin_transfn( + state: "Optional['SkipList *']", temp: "const Temporal *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tfloat_tmin_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def timespan_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.timespan_type(type_converted) +def tfloat_tsum_transfn( + state: "Optional['SkipList *']", temp: "const Temporal *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tfloat_tsum_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_timespan_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.ensure_timespan_type(type_converted) +def tfloat_wmax_transfn( + state: "SkipList *", temp: "const Temporal *", interv: "const Interval *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) + temp_converted = _ffi.cast("const Temporal *", temp) + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.tfloat_wmax_transfn(state_converted, temp_converted, interv_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.spanset_type(type_converted) +def tfloat_wmin_transfn( + state: "SkipList *", temp: "const Temporal *", interv: "const Interval *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) + temp_converted = _ffi.cast("const Temporal *", temp) + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.tfloat_wmin_transfn(state_converted, temp_converted, interv_converted) _check_error() return result if result != _ffi.NULL else None -def numspanset_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.numspanset_type(type_converted) +def tfloat_wsum_transfn( + state: "SkipList *", temp: "const Temporal *", interv: "const Interval *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) + temp_converted = _ffi.cast("const Temporal *", temp) + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.tfloat_wsum_transfn(state_converted, temp_converted, interv_converted) _check_error() return result if result != _ffi.NULL else None -def timespanset_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.timespanset_type(type_converted) +def timestamptz_tcount_transfn(state: "Optional['SkipList *']", t: int) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.timestamptz_tcount_transfn(state_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_timespanset_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.ensure_timespanset_type(type_converted) +def tint_tmax_transfn( + state: "Optional['SkipList *']", temp: "const Temporal *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tint_tmax_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.temporal_type(type_converted) +def tint_tmin_transfn( + state: "Optional['SkipList *']", temp: "const Temporal *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tint_tmin_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.temporal_basetype(type_converted) +def tint_tsum_transfn( + state: "Optional['SkipList *']", temp: "const Temporal *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tint_tsum_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def temptype_continuous(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.temptype_continuous(type_converted) +def tint_wmax_transfn( + state: "SkipList *", temp: "const Temporal *", interv: "const Interval *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) + temp_converted = _ffi.cast("const Temporal *", temp) + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.tint_wmax_transfn(state_converted, temp_converted, interv_converted) _check_error() return result if result != _ffi.NULL else None -def basetype_byvalue(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.basetype_byvalue(type_converted) +def tint_wmin_transfn( + state: "SkipList *", temp: "const Temporal *", interv: "const Interval *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) + temp_converted = _ffi.cast("const Temporal *", temp) + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.tint_wmin_transfn(state_converted, temp_converted, interv_converted) _check_error() return result if result != _ffi.NULL else None -def basetype_varlength(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.basetype_varlength(type_converted) +def tint_wsum_transfn( + state: "SkipList *", temp: "const Temporal *", interv: "const Interval *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) + temp_converted = _ffi.cast("const Temporal *", temp) + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.tint_wsum_transfn(state_converted, temp_converted, interv_converted) _check_error() return result if result != _ffi.NULL else None -def basetype_length(type: 'meosType') -> 'int16': - type_converted = _ffi.cast('meosType', type) - result = _lib.basetype_length(type_converted) +def tnumber_extent_transfn( + box: "Optional['TBox *']", temp: "const Temporal *" +) -> "TBox *": + box_converted = _ffi.cast("TBox *", box) if box is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tnumber_extent_transfn(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def talphanum_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.talphanum_type(type_converted) +def tnumber_tavg_finalfn(state: "SkipList *") -> "Temporal *": + state_converted = _ffi.cast("SkipList *", state) + result = _lib.tnumber_tavg_finalfn(state_converted) _check_error() return result if result != _ffi.NULL else None -def talpha_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.talpha_type(type_converted) +def tnumber_tavg_transfn( + state: "Optional['SkipList *']", temp: "const Temporal *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tnumber_tavg_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.tnumber_type(type_converted) +def tnumber_wavg_transfn( + state: "SkipList *", temp: "const Temporal *", interv: "const Interval *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) + temp_converted = _ffi.cast("const Temporal *", temp) + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.tnumber_wavg_transfn( + state_converted, temp_converted, interv_converted + ) _check_error() return result if result != _ffi.NULL else None -def ensure_tnumber_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.ensure_tnumber_type(type_converted) +def tpoint_extent_transfn( + box: "Optional['STBox *']", temp: "const Temporal *" +) -> "STBox *": + box_converted = _ffi.cast("STBox *", box) if box is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_extent_transfn(box_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.tnumber_basetype(type_converted) +def tpoint_tcentroid_finalfn(state: "SkipList *") -> "Temporal *": + state_converted = _ffi.cast("SkipList *", state) + result = _lib.tpoint_tcentroid_finalfn(state_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tnumber_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.ensure_tnumber_basetype(type_converted) +def tpoint_tcentroid_transfn(state: "SkipList *", temp: "Temporal *") -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) + temp_converted = _ffi.cast("Temporal *", temp) + result = _lib.tpoint_tcentroid_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_settype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.tnumber_settype(type_converted) +def tstzset_tcount_transfn( + state: "Optional['SkipList *']", s: "const Set *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + s_converted = _ffi.cast("const Set *", s) + result = _lib.tstzset_tcount_transfn(state_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_spantype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.tnumber_spantype(type_converted) +def tstzspan_tcount_transfn( + state: "Optional['SkipList *']", s: "const Span *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + s_converted = _ffi.cast("const Span *", s) + result = _lib.tstzspan_tcount_transfn(state_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_spansettype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.tnumber_spansettype(type_converted) +def tstzspanset_tcount_transfn( + state: "Optional['SkipList *']", ss: "const SpanSet *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.tstzspanset_tcount_transfn(state_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.tspatial_type(type_converted) +def ttext_tmax_transfn( + state: "Optional['SkipList *']", temp: "const Temporal *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ttext_tmax_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def ensure_tspatial_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.ensure_tspatial_type(type_converted) +def ttext_tmin_transfn( + state: "Optional['SkipList *']", temp: "const Temporal *" +) -> "SkipList *": + state_converted = _ffi.cast("SkipList *", state) if state is not None else _ffi.NULL + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ttext_tmin_transfn(state_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tspatial_basetype(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.tspatial_basetype(type_converted) +def temporal_simplify_dp( + temp: "const Temporal *", eps_dist: float, synchronized: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_simplify_dp(temp_converted, eps_dist, synchronized) _check_error() return result if result != _ffi.NULL else None -def tgeo_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.tgeo_type(type_converted) +def temporal_simplify_max_dist( + temp: "const Temporal *", eps_dist: float, synchronized: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_simplify_max_dist(temp_converted, eps_dist, synchronized) _check_error() return result if result != _ffi.NULL else None -def ensure_tgeo_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.ensure_tgeo_type(type_converted) +def temporal_simplify_min_dist(temp: "const Temporal *", dist: float) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_simplify_min_dist(temp_converted, dist) _check_error() return result if result != _ffi.NULL else None -def ensure_tnumber_tgeo_type(type: 'meosType') -> 'bool': - type_converted = _ffi.cast('meosType', type) - result = _lib.ensure_tnumber_tgeo_type(type_converted) +def temporal_simplify_min_tdelta( + temp: "const Temporal *", mint: "const Interval *" +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + mint_converted = _ffi.cast("const Interval *", mint) + result = _lib.temporal_simplify_min_tdelta(temp_converted, mint_converted) _check_error() return result if result != _ffi.NULL else None -def datum_hash(d: 'Datum', basetype: 'meosType') -> 'uint32': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.datum_hash(d_converted, basetype_converted) +def temporal_tprecision( + temp: "const Temporal *", duration: "const Interval *", origin: int +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) + origin_converted = _ffi.cast("TimestampTz", origin) + result = _lib.temporal_tprecision( + temp_converted, duration_converted, origin_converted + ) _check_error() return result if result != _ffi.NULL else None -def datum_hash_extended(d: 'Datum', basetype: 'meosType', seed: int) -> 'uint64': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - seed_converted = _ffi.cast('uint64', seed) - result = _lib.datum_hash_extended(d_converted, basetype_converted, seed_converted) +def temporal_tsample( + temp: "const Temporal *", duration: "const Interval *", origin: int +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + duration_converted = _ffi.cast("const Interval *", duration) + origin_converted = _ffi.cast("TimestampTz", origin) + result = _lib.temporal_tsample(temp_converted, duration_converted, origin_converted) _check_error() return result if result != _ffi.NULL else None -def set_in(string: str, basetype: 'meosType') -> 'Set *': - string_converted = string.encode('utf-8') - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.set_in(string_converted, basetype_converted) +def temporal_dyntimewarp_distance( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "double": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.temporal_dyntimewarp_distance(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def set_out(s: 'const Set *', maxdd: int) -> str: - s_converted = _ffi.cast('const Set *', s) - result = _lib.set_out(s_converted, maxdd) +def temporal_dyntimewarp_path( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Tuple['Match *', 'int']": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + count = _ffi.new("int *") + result = _lib.temporal_dyntimewarp_path(temp1_converted, temp2_converted, count) _check_error() - result = _ffi.string(result).decode('utf-8') - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def span_in(string: str, spantype: 'meosType') -> 'Span *': - string_converted = string.encode('utf-8') - spantype_converted = _ffi.cast('meosType', spantype) - result = _lib.span_in(string_converted, spantype_converted) +def temporal_frechet_distance( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "double": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.temporal_frechet_distance(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def span_out(s: 'const Span *', maxdd: int) -> str: - s_converted = _ffi.cast('const Span *', s) - result = _lib.span_out(s_converted, maxdd) +def temporal_frechet_path( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Tuple['Match *', 'int']": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + count = _ffi.new("int *") + result = _lib.temporal_frechet_path(temp1_converted, temp2_converted, count) _check_error() - result = _ffi.string(result).decode('utf-8') - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def spanset_in(string: str, spantype: 'meosType') -> 'SpanSet *': - string_converted = string.encode('utf-8') - spantype_converted = _ffi.cast('meosType', spantype) - result = _lib.spanset_in(string_converted, spantype_converted) +def temporal_hausdorff_distance( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "double": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.temporal_hausdorff_distance(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_out(ss: 'const SpanSet *', maxdd: int) -> str: - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.spanset_out(ss_converted, maxdd) +def float_bucket(value: float, size: float, origin: float) -> "double": + result = _lib.float_bucket(value, size, origin) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def set_compact(s: 'const Set *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.set_compact(s_converted) +def floatspan_bucket_list( + bounds: "const Span *", size: float, origin: float +) -> "Tuple['Span *', 'int']": + bounds_converted = _ffi.cast("const Span *", bounds) + count = _ffi.new("int *") + result = _lib.floatspan_bucket_list(bounds_converted, size, origin, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def set_cp(s: 'const Set *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.set_cp(s_converted) +def int_bucket(value: int, size: int, origin: int) -> "int": + result = _lib.int_bucket(value, size, origin) _check_error() return result if result != _ffi.NULL else None -def set_make(values: 'const Datum *', count: int, basetype: 'meosType', ordered: bool) -> 'Set *': - values_converted = _ffi.cast('const Datum *', values) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.set_make(values_converted, count, basetype_converted, ordered) +def intspan_bucket_list( + bounds: "const Span *", size: int, origin: int +) -> "Tuple['Span *', 'int']": + bounds_converted = _ffi.cast("const Span *", bounds) + count = _ffi.new("int *") + result = _lib.intspan_bucket_list(bounds_converted, size, origin, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def set_make_exp(values: 'const Datum *', count: int, maxcount: int, basetype: 'meosType', ordered: bool) -> 'Set *': - values_converted = _ffi.cast('const Datum *', values) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.set_make_exp(values_converted, count, maxcount, basetype_converted, ordered) +def stbox_tile( + point: "GSERIALIZED *", + t: int, + xsize: float, + ysize: float, + zsize: float, + duration: "Interval *", + sorigin: "GSERIALIZED *", + torigin: int, + hast: bool, +) -> "STBox *": + point_converted = _ffi.cast("GSERIALIZED *", point) + t_converted = _ffi.cast("TimestampTz", t) + duration_converted = _ffi.cast("Interval *", duration) + sorigin_converted = _ffi.cast("GSERIALIZED *", sorigin) + torigin_converted = _ffi.cast("TimestampTz", torigin) + result = _lib.stbox_tile( + point_converted, + t_converted, + xsize, + ysize, + zsize, + duration_converted, + sorigin_converted, + torigin_converted, + hast, + ) _check_error() return result if result != _ffi.NULL else None -def set_make_free(values: 'Datum *', count: int, basetype: 'meosType', ordered: bool) -> 'Set *': - values_converted = _ffi.cast('Datum *', values) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.set_make_free(values_converted, count, basetype_converted, ordered) +def stbox_tile_list( + bounds: "const STBox *", + xsize: float, + ysize: float, + zsize: float, + duration: "Optional['const Interval *']", + sorigin: "GSERIALIZED *", + torigin: int, +) -> "Tuple['STBox *', 'int']": + bounds_converted = _ffi.cast("const STBox *", bounds) + duration_converted = ( + _ffi.cast("const Interval *", duration) if duration is not None else _ffi.NULL + ) + sorigin_converted = _ffi.cast("GSERIALIZED *", sorigin) + torigin_converted = _ffi.cast("TimestampTz", torigin) + count = _ffi.new("int *") + result = _lib.stbox_tile_list( + bounds_converted, + xsize, + ysize, + zsize, + duration_converted, + sorigin_converted, + torigin_converted, + count, + ) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def set_out(s: 'const Set *', maxdd: int) -> str: - s_converted = _ffi.cast('const Set *', s) - result = _lib.set_out(s_converted, maxdd) +def temporal_time_split( + temp: "Temporal *", duration: "Interval *", torigin: int +) -> "Tuple['Temporal **', 'TimestampTz *', 'int']": + temp_converted = _ffi.cast("Temporal *", temp) + duration_converted = _ffi.cast("Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + time_buckets = _ffi.new("TimestampTz **") + count = _ffi.new("int *") + result = _lib.temporal_time_split( + temp_converted, duration_converted, torigin_converted, time_buckets, count + ) _check_error() - result = _ffi.string(result).decode('utf-8') - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, time_buckets[0], count[0] -def span_cp(s: 'const Span *') -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.span_cp(s_converted) +def tfloat_value_split( + temp: "Temporal *", size: float, origin: float +) -> "Tuple['Temporal **', 'double *', 'int']": + temp_converted = _ffi.cast("Temporal *", temp) + value_buckets = _ffi.new("double **") + count = _ffi.new("int *") + result = _lib.tfloat_value_split(temp_converted, size, origin, value_buckets, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, value_buckets[0], count[0] -def span_make(lower: 'Datum', upper: 'Datum', lower_inc: bool, upper_inc: bool, basetype: 'meosType') -> 'Span *': - lower_converted = _ffi.cast('Datum', lower) - upper_converted = _ffi.cast('Datum', upper) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.span_make(lower_converted, upper_converted, lower_inc, upper_inc, basetype_converted) +def tfloat_value_time_split( + temp: "Temporal *", + size: float, + duration: "Interval *", + vorigin: float, + torigin: int, +) -> "Tuple['Temporal **', 'double *', 'TimestampTz *', 'int']": + temp_converted = _ffi.cast("Temporal *", temp) + duration_converted = _ffi.cast("Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + value_buckets = _ffi.new("double **") + time_buckets = _ffi.new("TimestampTz **") + count = _ffi.new("int *") + result = _lib.tfloat_value_time_split( + temp_converted, + size, + duration_converted, + vorigin, + torigin_converted, + value_buckets, + time_buckets, + count, + ) _check_error() - return result if result != _ffi.NULL else None + return ( + result if result != _ffi.NULL else None, + value_buckets[0], + time_buckets[0], + count[0], + ) -def span_out(s: 'const Span *', maxdd: int) -> str: - s_converted = _ffi.cast('const Span *', s) - result = _lib.span_out(s_converted, maxdd) +def tfloatbox_tile( + value: float, + t: int, + vsize: float, + duration: "Interval *", + vorigin: float, + torigin: int, +) -> "TBox *": + t_converted = _ffi.cast("TimestampTz", t) + duration_converted = _ffi.cast("Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + result = _lib.tfloatbox_tile( + value, t_converted, vsize, duration_converted, vorigin, torigin_converted + ) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def span_set(lower: 'Datum', upper: 'Datum', lower_inc: bool, upper_inc: bool, basetype: 'meosType', spantype: 'meosType', s: 'Span *') -> None: - lower_converted = _ffi.cast('Datum', lower) - upper_converted = _ffi.cast('Datum', upper) - basetype_converted = _ffi.cast('meosType', basetype) - spantype_converted = _ffi.cast('meosType', spantype) - s_converted = _ffi.cast('Span *', s) - _lib.span_set(lower_converted, upper_converted, lower_inc, upper_inc, basetype_converted, spantype_converted, s_converted) +def tfloatbox_tile_list( + box: "const TBox *", + xsize: float, + duration: "const Interval *", + xorigin: "Optional[float]", + torigin: "Optional[int]", +) -> "Tuple['TBox *', 'int']": + box_converted = _ffi.cast("const TBox *", box) + duration_converted = _ffi.cast("const Interval *", duration) + xorigin_converted = xorigin if xorigin is not None else _ffi.NULL + torigin_converted = ( + _ffi.cast("TimestampTz", torigin) if torigin is not None else _ffi.NULL + ) + count = _ffi.new("int *") + result = _lib.tfloatbox_tile_list( + box_converted, + xsize, + duration_converted, + xorigin_converted, + torigin_converted, + count, + ) _check_error() + return result if result != _ffi.NULL else None, count[0] -def spanset_cp(ss: 'const SpanSet *') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.spanset_cp(ss_converted) +def timestamptz_bucket( + timestamp: int, duration: "const Interval *", origin: int +) -> "TimestampTz": + timestamp_converted = _ffi.cast("TimestampTz", timestamp) + duration_converted = _ffi.cast("const Interval *", duration) + origin_converted = _ffi.cast("TimestampTz", origin) + result = _lib.timestamptz_bucket( + timestamp_converted, duration_converted, origin_converted + ) _check_error() return result if result != _ffi.NULL else None -def spanset_compact(ss: 'SpanSet *') -> 'SpanSet *': - ss_converted = _ffi.cast('SpanSet *', ss) - result = _lib.spanset_compact(ss_converted) +def tint_value_split( + temp: "Temporal *", size: int, origin: int +) -> "Tuple['Temporal **', 'int *', 'int']": + temp_converted = _ffi.cast("Temporal *", temp) + value_buckets = _ffi.new("int **") + count = _ffi.new("int *") + result = _lib.tint_value_split(temp_converted, size, origin, value_buckets, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, value_buckets[0], count[0] -def spanset_make_exp(spans: 'Span *', count: int, maxcount: int, normalize: bool, ordered: bool) -> 'SpanSet *': - spans_converted = _ffi.cast('Span *', spans) - result = _lib.spanset_make_exp(spans_converted, count, maxcount, normalize, ordered) +def tint_value_time_split( + temp: "Temporal *", size: int, duration: "Interval *", vorigin: int, torigin: int +) -> "Tuple['Temporal **', 'int *', 'TimestampTz *', 'int']": + temp_converted = _ffi.cast("Temporal *", temp) + duration_converted = _ffi.cast("Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + value_buckets = _ffi.new("int **") + time_buckets = _ffi.new("TimestampTz **") + count = _ffi.new("int *") + result = _lib.tint_value_time_split( + temp_converted, + size, + duration_converted, + vorigin, + torigin_converted, + value_buckets, + time_buckets, + count, + ) _check_error() - return result if result != _ffi.NULL else None + return ( + result if result != _ffi.NULL else None, + value_buckets[0], + time_buckets[0], + count[0], + ) -def spanset_make_free(spans: 'Span *', count: int, normalize: bool) -> 'SpanSet *': - spans_converted = _ffi.cast('Span *', spans) - result = _lib.spanset_make_free(spans_converted, count, normalize) +def tintbox_tile( + value: int, t: int, vsize: int, duration: "Interval *", vorigin: int, torigin: int +) -> "TBox *": + t_converted = _ffi.cast("TimestampTz", t) + duration_converted = _ffi.cast("Interval *", duration) + torigin_converted = _ffi.cast("TimestampTz", torigin) + result = _lib.tintbox_tile( + value, t_converted, vsize, duration_converted, vorigin, torigin_converted + ) _check_error() return result if result != _ffi.NULL else None -def spanset_out(ss: 'const SpanSet *', maxdd: int) -> str: - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.spanset_out(ss_converted, maxdd) +def tintbox_tile_list( + box: "const TBox *", + xsize: int, + duration: "const Interval *", + xorigin: "Optional[int]", + torigin: "Optional[int]", +) -> "Tuple['TBox *', 'int']": + box_converted = _ffi.cast("const TBox *", box) + duration_converted = _ffi.cast("const Interval *", duration) + xorigin_converted = xorigin if xorigin is not None else _ffi.NULL + torigin_converted = ( + _ffi.cast("TimestampTz", torigin) if torigin is not None else _ffi.NULL + ) + count = _ffi.new("int *") + result = _lib.tintbox_tile_list( + box_converted, + xsize, + duration_converted, + xorigin_converted, + torigin_converted, + count, + ) _check_error() - result = _ffi.string(result).decode('utf-8') - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def span_spanset(s: 'const Span *') -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - result = _lib.span_spanset(s_converted) +def tpoint_space_time_split( + temp: "Temporal *", + xsize: "float", + ysize: "float", + zsize: "float", + duration: "Interval *", + sorigin: "GSERIALIZED *", + torigin: int, + bitmatrix: bool, +) -> "Tuple['Temporal **', 'GSERIALIZED ***', 'TimestampTz *', 'int']": + temp_converted = _ffi.cast("Temporal *", temp) + xsize_converted = _ffi.cast("float", xsize) + ysize_converted = _ffi.cast("float", ysize) + zsize_converted = _ffi.cast("float", zsize) + duration_converted = _ffi.cast("Interval *", duration) + sorigin_converted = _ffi.cast("GSERIALIZED *", sorigin) + torigin_converted = _ffi.cast("TimestampTz", torigin) + space_buckets = _ffi.new("GSERIALIZED ***") + time_buckets = _ffi.new("TimestampTz **") + count = _ffi.new("int *") + result = _lib.tpoint_space_time_split( + temp_converted, + xsize_converted, + ysize_converted, + zsize_converted, + duration_converted, + sorigin_converted, + torigin_converted, + bitmatrix, + space_buckets, + time_buckets, + count, + ) _check_error() - return result if result != _ffi.NULL else None + return ( + result if result != _ffi.NULL else None, + space_buckets[0], + time_buckets[0], + count[0], + ) -def value_to_set(d: 'Datum', basetype: 'meosType') -> 'Set *': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.value_to_set(d_converted, basetype_converted) +def tstzspan_bucket_list( + bounds: "const Span *", duration: "const Interval *", origin: int +) -> "Tuple['Span *', 'int']": + bounds_converted = _ffi.cast("const Span *", bounds) + duration_converted = _ffi.cast("const Interval *", duration) + origin_converted = _ffi.cast("TimestampTz", origin) + count = _ffi.new("int *") + result = _lib.tstzspan_bucket_list( + bounds_converted, duration_converted, origin_converted, count + ) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def value_to_span(d: 'Datum', basetype: 'meosType') -> 'Span *': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.value_to_span(d_converted, basetype_converted) +def temptype_subtype(subtype: "tempSubtype") -> "bool": + subtype_converted = _ffi.cast("tempSubtype", subtype) + result = _lib.temptype_subtype(subtype_converted) _check_error() return result if result != _ffi.NULL else None -def value_to_spanset(d: 'Datum', basetype: 'meosType') -> 'SpanSet *': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.value_to_spanset(d_converted, basetype_converted) +def temptype_subtype_all(subtype: "tempSubtype") -> "bool": + subtype_converted = _ffi.cast("tempSubtype", subtype) + result = _lib.temptype_subtype_all(subtype_converted) _check_error() return result if result != _ffi.NULL else None -def set_end_value(s: 'const Set *') -> 'Datum': - s_converted = _ffi.cast('const Set *', s) - result = _lib.set_end_value(s_converted) +def tempsubtype_name(subtype: "tempSubtype") -> str: + subtype_converted = _ffi.cast("tempSubtype", subtype) + result = _lib.tempsubtype_name(subtype_converted) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def set_mem_size(s: 'const Set *') -> 'int': - s_converted = _ffi.cast('const Set *', s) - result = _lib.set_mem_size(s_converted) +def tempsubtype_from_string(string: str, subtype: "int16 *") -> "bool": + string_converted = string.encode("utf-8") + subtype_converted = _ffi.cast("int16 *", subtype) + result = _lib.tempsubtype_from_string(string_converted, subtype_converted) _check_error() return result if result != _ffi.NULL else None -def set_set_span(s: 'const Set *', sp: 'Span *') -> None: - s_converted = _ffi.cast('const Set *', s) - sp_converted = _ffi.cast('Span *', sp) - _lib.set_set_span(s_converted, sp_converted) - _check_error() - - -def set_span(s: 'const Set *') -> 'Span *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.set_span(s_converted) +def meosoper_name(oper: "meosOper") -> str: + oper_converted = _ffi.cast("meosOper", oper) + result = _lib.meosoper_name(oper_converted) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def set_start_value(s: 'const Set *') -> 'Datum': - s_converted = _ffi.cast('const Set *', s) - result = _lib.set_start_value(s_converted) +def meosoper_from_string(name: str) -> "meosOper": + name_converted = name.encode("utf-8") + result = _lib.meosoper_from_string(name_converted) _check_error() return result if result != _ffi.NULL else None -def set_value_n(s: 'const Set *', n: int) -> 'Datum *': - s_converted = _ffi.cast('const Set *', s) - out_result = _ffi.new('Datum *') - result = _lib.set_value_n(s_converted, n, out_result) +def interptype_name(interp: "interpType") -> str: + interp_converted = _ffi.cast("interpType", interp) + result = _lib.interptype_name(interp_converted) _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None -def set_values(s: 'const Set *') -> 'Datum *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.set_values(s_converted) +def interptype_from_string(interp_str: str) -> "interpType": + interp_str_converted = interp_str.encode("utf-8") + result = _lib.interptype_from_string(interp_str_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_lower(ss: 'const SpanSet *') -> 'Datum': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.spanset_lower(ss_converted) +def meostype_name(type: "meosType") -> str: + type_converted = _ffi.cast("meosType", type) + result = _lib.meostype_name(type_converted) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def spanset_mem_size(ss: 'const SpanSet *') -> 'int': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.spanset_mem_size(ss_converted) +def temptype_basetype(type: "meosType") -> "meosType": + type_converted = _ffi.cast("meosType", type) + result = _lib.temptype_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_upper(ss: 'const SpanSet *') -> 'Datum': - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.spanset_upper(ss_converted) +def settype_basetype(type: "meosType") -> "meosType": + type_converted = _ffi.cast("meosType", type) + result = _lib.settype_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def spatialset_set_stbox(set: 'const Set *', box: 'STBox *') -> None: - set_converted = _ffi.cast('const Set *', set) - box_converted = _ffi.cast('STBox *', box) - _lib.spatialset_set_stbox(set_converted, box_converted) +def spantype_basetype(type: "meosType") -> "meosType": + type_converted = _ffi.cast("meosType", type) + result = _lib.spantype_basetype(type_converted) _check_error() + return result if result != _ffi.NULL else None -def value_set_span(d: 'Datum', basetype: 'meosType', s: 'Span *') -> None: - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('Span *', s) - _lib.value_set_span(d_converted, basetype_converted, s_converted) +def spantype_spansettype(type: "meosType") -> "meosType": + type_converted = _ffi.cast("meosType", type) + result = _lib.spantype_spansettype(type_converted) _check_error() + return result if result != _ffi.NULL else None -def datespan_set_tstzspan(s1: 'const Span *', s2: 'Span *') -> None: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('Span *', s2) - _lib.datespan_set_tstzspan(s1_converted, s2_converted) +def spansettype_spantype(type: "meosType") -> "meosType": + type_converted = _ffi.cast("meosType", type) + result = _lib.spansettype_spantype(type_converted) _check_error() + return result if result != _ffi.NULL else None -def floatspan_rnd(span: 'const Span *', size: 'Datum') -> 'Span *': - span_converted = _ffi.cast('const Span *', span) - size_converted = _ffi.cast('Datum', size) - out_result = _ffi.new('Span *') - _lib.floatspan_rnd(span_converted, size_converted, out_result) +def basetype_spantype(type: "meosType") -> "meosType": + type_converted = _ffi.cast("meosType", type) + result = _lib.basetype_spantype(type_converted) _check_error() - return out_result if out_result!= _ffi.NULL else None - + return result if result != _ffi.NULL else None -def floatspan_set_intspan(s1: 'const Span *', s2: 'Span *') -> None: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('Span *', s2) - _lib.floatspan_set_intspan(s1_converted, s2_converted) +def basetype_settype(type: "meosType") -> "meosType": + type_converted = _ffi.cast("meosType", type) + result = _lib.basetype_settype(type_converted) _check_error() + return result if result != _ffi.NULL else None -def floatspan_set_numspan(s1: 'const Span *', s2: 'Span *', basetype: 'meosType') -> None: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('Span *', s2) - basetype_converted = _ffi.cast('meosType', basetype) - _lib.floatspan_set_numspan(s1_converted, s2_converted, basetype_converted) +def meos_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.meos_basetype(type_converted) _check_error() + return result if result != _ffi.NULL else None -def intspan_set_floatspan(s1: 'const Span *', s2: 'Span *') -> None: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('Span *', s2) - _lib.intspan_set_floatspan(s1_converted, s2_converted) +def alpha_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.alpha_basetype(type_converted) _check_error() + return result if result != _ffi.NULL else None -def numset_shift_scale(s: 'const Set *', shift: 'Datum', width: 'Datum', hasshift: bool, haswidth: bool) -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - shift_converted = _ffi.cast('Datum', shift) - width_converted = _ffi.cast('Datum', width) - result = _lib.numset_shift_scale(s_converted, shift_converted, width_converted, hasshift, haswidth) +def tnumber_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.tnumber_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def numspan_set_floatspan(s1: 'const Span *', s2: 'Span *') -> None: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('Span *', s2) - _lib.numspan_set_floatspan(s1_converted, s2_converted) +def alphanum_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.alphanum_basetype(type_converted) _check_error() + return result if result != _ffi.NULL else None -def numspan_shift_scale(s: 'const Span *', shift: 'Datum', width: 'Datum', hasshift: bool, haswidth: bool) -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - shift_converted = _ffi.cast('Datum', shift) - width_converted = _ffi.cast('Datum', width) - result = _lib.numspan_shift_scale(s_converted, shift_converted, width_converted, hasshift, haswidth) +def geo_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.geo_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def numspanset_shift_scale(ss: 'const SpanSet *', shift: 'Datum', width: 'Datum', hasshift: bool, haswidth: bool) -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - shift_converted = _ffi.cast('Datum', shift) - width_converted = _ffi.cast('Datum', width) - result = _lib.numspanset_shift_scale(ss_converted, shift_converted, width_converted, hasshift, haswidth) +def spatial_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.spatial_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def set_compact(s: 'const Set *') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - result = _lib.set_compact(s_converted) +def time_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.time_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def span_expand(s1: 'const Span *', s2: 'Span *') -> None: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('Span *', s2) - _lib.span_expand(s1_converted, s2_converted) +def set_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.set_basetype(type_converted) _check_error() + return result if result != _ffi.NULL else None -def spanset_compact(ss: 'SpanSet *') -> 'SpanSet *': - ss_converted = _ffi.cast('SpanSet *', ss) - result = _lib.spanset_compact(ss_converted) +def set_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.set_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def tstzspan_set_datespan(s1: 'const Span *', s2: 'Span *') -> None: - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('Span *', s2) - _lib.tstzspan_set_datespan(s1_converted, s2_converted) +def numset_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.numset_type(type_converted) _check_error() + return result if result != _ffi.NULL else None -def set_cmp1(s1: 'const Set *', s2: 'const Set *') -> 'int': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.set_cmp1(s1_converted, s2_converted) +def ensure_numset_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.ensure_numset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def set_eq1(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.set_eq1(s1_converted, s2_converted) +def timeset_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.timeset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def span_cmp1(s1: 'const Span *', s2: 'const Span *') -> 'int': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.span_cmp1(s1_converted, s2_converted) +def ensure_timeset_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.ensure_timeset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def span_eq1(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.span_eq1(s1_converted, s2_converted) +def set_spantype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.set_spantype(type_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_cmp1(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'int': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.spanset_cmp1(ss1_converted, ss2_converted) +def ensure_set_spantype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.ensure_set_spantype(type_converted) _check_error() return result if result != _ffi.NULL else None -def spanset_eq1(ss1: 'const SpanSet *', ss2: 'const SpanSet *') -> 'bool': - ss1_converted = _ffi.cast('const SpanSet *', ss1) - ss2_converted = _ffi.cast('const SpanSet *', ss2) - result = _lib.spanset_eq1(ss1_converted, ss2_converted) +def alphanumset_type(settype: "meosType") -> "bool": + settype_converted = _ffi.cast("meosType", settype) + result = _lib.alphanumset_type(settype_converted) _check_error() return result if result != _ffi.NULL else None -def spanbase_extent_transfn(s: 'Span *', d: 'Datum', basetype: 'meosType') -> 'Span *': - s_converted = _ffi.cast('Span *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.spanbase_extent_transfn(s_converted, d_converted, basetype_converted) +def geoset_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.geoset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def value_union_transfn(state: 'Set *', d: 'Datum', basetype: 'meosType') -> 'Set *': - state_converted = _ffi.cast('Set *', state) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.value_union_transfn(state_converted, d_converted, basetype_converted) +def ensure_geoset_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.ensure_geoset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def adj_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.adj_span_span(s1_converted, s2_converted) +def spatialset_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.spatialset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.adjacent_span_value(s_converted, d_converted, basetype_converted) +def ensure_spatialset_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.ensure_spatialset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def adjacent_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.adjacent_spanset_value(ss_converted, d_converted, basetype_converted) +def span_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.span_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def cont_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.cont_span_span(s1_converted, s2_converted) +def span_canon_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.span_canon_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def contains_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.contains_span_value(s_converted, d_converted, basetype_converted) +def span_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.span_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def contains_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.contains_spanset_value(ss_converted, d_converted, basetype_converted) +def span_bbox_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.span_bbox_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.contains_set_value(s_converted, d_converted, basetype_converted) +def numspan_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.numspan_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def contains_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.contains_set_set(s1_converted, s2_converted) +def numspan_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.numspan_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def contained_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Span *', s) - result = _lib.contained_value_span(d_converted, basetype_converted, s_converted) +def ensure_numspan_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.ensure_numspan_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def contained_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Set *', s) - result = _lib.contained_value_set(d_converted, basetype_converted, s_converted) +def timespan_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.timespan_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def contained_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.contained_set_set(s1_converted, s2_converted) +def timespan_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.timespan_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def contained_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.contained_value_spanset(d_converted, basetype_converted, ss_converted) +def ensure_timespan_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.ensure_timespan_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def over_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.over_span_span(s1_converted, s2_converted) +def spanset_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.spanset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def over_adj_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.over_adj_span_span(s1_converted, s2_converted) +def numspanset_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.numspanset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overlaps_value_span(d_converted, basetype_converted, s_converted) +def timespanset_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.timespanset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overlaps_value_spanset(d_converted, basetype_converted, ss_converted) +def ensure_timespanset_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.ensure_timespanset_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.overlaps_span_value(s_converted, d_converted, basetype_converted) +def temporal_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.temporal_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.overlaps_spanset_value(ss_converted, d_converted, basetype_converted) +def temporal_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.temporal_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def overlaps_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.overlaps_set_set(s1_converted, s2_converted) +def temptype_continuous(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.temptype_continuous(type_converted) _check_error() return result if result != _ffi.NULL else None -def left_notadj_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.left_notadj_span_span(s1_converted, s2_converted) +def basetype_byvalue(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.basetype_byvalue(type_converted) _check_error() return result if result != _ffi.NULL else None -def left_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.left_set_set(s1_converted, s2_converted) +def basetype_varlength(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.basetype_varlength(type_converted) _check_error() return result if result != _ffi.NULL else None -def left_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.left_set_value(s_converted, d_converted, basetype_converted) +def basetype_length(type: "meosType") -> "int16": + type_converted = _ffi.cast("meosType", type) + result = _lib.basetype_length(type_converted) _check_error() return result if result != _ffi.NULL else None -def left_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.left_span_value(s_converted, d_converted, basetype_converted) +def talphanum_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.talphanum_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def left_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.left_spanset_value(ss_converted, d_converted, basetype_converted) +def talpha_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.talpha_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def left_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Set *', s) - result = _lib.left_value_set(d_converted, basetype_converted, s_converted) +def tnumber_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.tnumber_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def left_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Span *', s) - result = _lib.left_value_span(d_converted, basetype_converted, s_converted) +def ensure_tnumber_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.ensure_tnumber_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def left_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.left_value_spanset(d_converted, basetype_converted, ss_converted) +def tnumber_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.tnumber_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def lf_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.lf_span_span(s1_converted, s2_converted) +def ensure_tnumber_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.ensure_tnumber_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def ri_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.ri_span_span(s1_converted, s2_converted) +def tnumber_settype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.tnumber_settype(type_converted) _check_error() return result if result != _ffi.NULL else None -def right_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Set *', s) - result = _lib.right_value_set(d_converted, basetype_converted, s_converted) +def tnumber_spantype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.tnumber_spantype(type_converted) _check_error() return result if result != _ffi.NULL else None -def right_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.right_set_value(s_converted, d_converted, basetype_converted) +def tnumber_spansettype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.tnumber_spansettype(type_converted) _check_error() return result if result != _ffi.NULL else None -def right_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.right_set_set(s1_converted, s2_converted) +def tspatial_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.tspatial_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def right_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Span *', s) - result = _lib.right_value_span(d_converted, basetype_converted, s_converted) +def ensure_tspatial_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.ensure_tspatial_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def right_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.right_value_spanset(d_converted, basetype_converted, ss_converted) +def tspatial_basetype(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.tspatial_basetype(type_converted) _check_error() return result if result != _ffi.NULL else None -def right_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.right_span_value(s_converted, d_converted, basetype_converted) +def tgeo_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.tgeo_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def right_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.right_spanset_value(ss_converted, d_converted, basetype_converted) +def ensure_tgeo_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.ensure_tgeo_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Set *', s) - result = _lib.overleft_value_set(d_converted, basetype_converted, s_converted) +def ensure_tnumber_tgeo_type(type: "meosType") -> "bool": + type_converted = _ffi.cast("meosType", type) + result = _lib.ensure_tnumber_tgeo_type(type_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.overleft_set_value(s_converted, d_converted, basetype_converted) +def datum_hash(d: "Datum", basetype: "meosType") -> "uint32": + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.datum_hash(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.overleft_set_set(s1_converted, s2_converted) +def datum_hash_extended(d: "Datum", basetype: "meosType", seed: int) -> "uint64": + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) + seed_converted = _ffi.cast("uint64", seed) + result = _lib.datum_hash_extended(d_converted, basetype_converted, seed_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overleft_value_span(d_converted, basetype_converted, s_converted) +def set_in(string: str, basetype: "meosType") -> "Set *": + string_converted = string.encode("utf-8") + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.set_in(string_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overleft_value_spanset(d_converted, basetype_converted, ss_converted) +def set_out(s: "const Set *", maxdd: int) -> str: + s_converted = _ffi.cast("const Set *", s) + result = _lib.set_out(s_converted, maxdd) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def overleft_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.overleft_span_value(s_converted, d_converted, basetype_converted) +def span_in(string: str, spantype: "meosType") -> "Span *": + string_converted = string.encode("utf-8") + spantype_converted = _ffi.cast("meosType", spantype) + result = _lib.span_in(string_converted, spantype_converted) _check_error() return result if result != _ffi.NULL else None -def overleft_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.overleft_spanset_value(ss_converted, d_converted, basetype_converted) +def span_out(s: "const Span *", maxdd: int) -> str: + s_converted = _ffi.cast("const Span *", s) + result = _lib.span_out(s_converted, maxdd) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def overright_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Set *', s) - result = _lib.overright_value_set(d_converted, basetype_converted, s_converted) +def spanset_in(string: str, spantype: "meosType") -> "SpanSet *": + string_converted = string.encode("utf-8") + spantype_converted = _ffi.cast("meosType", spantype) + result = _lib.spanset_in(string_converted, spantype_converted) _check_error() return result if result != _ffi.NULL else None -def overright_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'bool': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.overright_set_value(s_converted, d_converted, basetype_converted) +def spanset_out(ss: "const SpanSet *", maxdd: int) -> str: + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.spanset_out(ss_converted, maxdd) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def overright_set_set(s1: 'const Set *', s2: 'const Set *') -> 'bool': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.overright_set_set(s1_converted, s2_converted) +def set_cp(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.set_cp(s_converted) _check_error() return result if result != _ffi.NULL else None -def overright_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Span *', s) - result = _lib.overright_value_span(d_converted, basetype_converted, s_converted) +def set_make( + values: "const Datum *", count: int, basetype: "meosType", ordered: bool +) -> "Set *": + values_converted = _ffi.cast("const Datum *", values) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.set_make(values_converted, count, basetype_converted, ordered) _check_error() return result if result != _ffi.NULL else None -def overright_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'bool': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.overright_value_spanset(d_converted, basetype_converted, ss_converted) +def set_make_exp( + values: "const Datum *", + count: int, + maxcount: int, + basetype: "meosType", + ordered: bool, +) -> "Set *": + values_converted = _ffi.cast("const Datum *", values) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.set_make_exp( + values_converted, count, maxcount, basetype_converted, ordered + ) _check_error() return result if result != _ffi.NULL else None -def overright_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'bool': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.overright_span_value(s_converted, d_converted, basetype_converted) +def set_make_free( + values: "Datum *", count: int, basetype: "meosType", ordered: bool +) -> "Set *": + values_converted = _ffi.cast("Datum *", values) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.set_make_free(values_converted, count, basetype_converted, ordered) _check_error() return result if result != _ffi.NULL else None -def overright_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'bool': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.overright_spanset_value(ss_converted, d_converted, basetype_converted) +def span_cp(s: "const Span *") -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.span_cp(s_converted) _check_error() return result if result != _ffi.NULL else None -def ovlf_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.ovlf_span_span(s1_converted, s2_converted) +def span_make( + lower: "Datum", + upper: "Datum", + lower_inc: bool, + upper_inc: bool, + basetype: "meosType", +) -> "Span *": + lower_converted = _ffi.cast("Datum", lower) + upper_converted = _ffi.cast("Datum", upper) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.span_make( + lower_converted, upper_converted, lower_inc, upper_inc, basetype_converted + ) _check_error() return result if result != _ffi.NULL else None -def ovri_span_span(s1: 'const Span *', s2: 'const Span *') -> 'bool': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.ovri_span_span(s1_converted, s2_converted) +def span_set( + lower: "Datum", + upper: "Datum", + lower_inc: bool, + upper_inc: bool, + basetype: "meosType", + spantype: "meosType", + s: "Span *", +) -> None: + lower_converted = _ffi.cast("Datum", lower) + upper_converted = _ffi.cast("Datum", upper) + basetype_converted = _ffi.cast("meosType", basetype) + spantype_converted = _ffi.cast("meosType", spantype) + s_converted = _ffi.cast("Span *", s) + _lib.span_set( + lower_converted, + upper_converted, + lower_inc, + upper_inc, + basetype_converted, + spantype_converted, + s_converted, + ) _check_error() - return result if result != _ffi.NULL else None -def inter_span_span(s1: 'const Span *', s2: 'const Span *') -> 'Span *': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - out_result = _ffi.new('Span *') - result = _lib.inter_span_span(s1_converted, s2_converted, out_result) +def spanset_cp(ss: "const SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.spanset_cp(ss_converted) _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None + return result if result != _ffi.NULL else None -def intersection_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.intersection_set_value(s_converted, d_converted, basetype_converted) +def spanset_make_exp( + spans: "Span *", count: int, maxcount: int, normalize: bool, ordered: bool +) -> "SpanSet *": + spans_converted = _ffi.cast("Span *", spans) + result = _lib.spanset_make_exp(spans_converted, count, maxcount, normalize, ordered) _check_error() return result if result != _ffi.NULL else None -def intersection_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'Span *': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.intersection_span_value(s_converted, d_converted, basetype_converted) +def spanset_make_free( + spans: "Span *", count: int, normalize: bool, ordered: bool +) -> "SpanSet *": + spans_converted = _ffi.cast("Span *", spans) + result = _lib.spanset_make_free(spans_converted, count, normalize, ordered) _check_error() return result if result != _ffi.NULL else None -def intersection_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.intersection_spanset_value(ss_converted, d_converted, basetype_converted) +def datespan_tstzspan(s: "const Span *") -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.datespan_tstzspan(s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.minus_set_value(s_converted, d_converted, basetype_converted) +def datespanset_tstzspanset(ss: "const SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.datespanset_tstzspanset(ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.minus_span_value(s_converted, d_converted, basetype_converted) +def intspan_floatspan(s: "const Span *") -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.intspan_floatspan(s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.minus_spanset_value(ss_converted, d_converted, basetype_converted) +def intspanset_floatspanset(ss: "const SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.intspanset_floatspanset(ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'Set *': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Set *', s) - result = _lib.minus_value_set(d_converted, basetype_converted, s_converted) +def floatspan_intspan(s: "const Span *") -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.floatspan_intspan(s_converted) _check_error() return result if result != _ffi.NULL else None -def minus_value_span(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'SpanSet *': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Span *', s) - result = _lib.minus_value_span(d_converted, basetype_converted, s_converted) +def floatspanset_intspanset(ss: "const SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.floatspanset_intspanset(ss_converted) _check_error() return result if result != _ffi.NULL else None -def minus_value_spanset(d: 'Datum', basetype: 'meosType', ss: 'const SpanSet *') -> 'SpanSet *': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.minus_value_spanset(d_converted, basetype_converted, ss_converted) +def set_span(s: "const Set *") -> "Span *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.set_span(s_converted) _check_error() return result if result != _ffi.NULL else None -def union_set_value(s: 'const Set *', d: 'const Datum', basetype: 'meosType') -> 'Set *': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('const Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.union_set_value(s_converted, d_converted, basetype_converted) +def set_spanset(s: "const Set *") -> "SpanSet *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.set_spanset(s_converted) _check_error() return result if result != _ffi.NULL else None -def union_span_value(s: 'const Span *', v: 'Datum', basetype: 'meosType') -> 'SpanSet *': - s_converted = _ffi.cast('const Span *', s) - v_converted = _ffi.cast('Datum', v) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.union_span_value(s_converted, v_converted, basetype_converted) +def span_spanset(s: "const Span *") -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.span_spanset(s_converted) _check_error() return result if result != _ffi.NULL else None -def union_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'SpanSet *': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.union_spanset_value(ss_converted, d_converted, basetype_converted) +def tstzspan_datespan(s: "const Span *") -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.tstzspan_datespan(s_converted) _check_error() return result if result != _ffi.NULL else None -def dist_set_set(s1: 'const Set *', s2: 'const Set *') -> 'double': - s1_converted = _ffi.cast('const Set *', s1) - s2_converted = _ffi.cast('const Set *', s2) - result = _lib.dist_set_set(s1_converted, s2_converted) +def tstzspanset_datespanset(ss: "const SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.tstzspanset_datespanset(ss_converted) _check_error() return result if result != _ffi.NULL else None -def dist_span_span(s1: 'const Span *', s2: 'const Span *') -> 'double': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - result = _lib.dist_span_span(s1_converted, s2_converted) +def value_set_span(value: "Datum", basetype: "meosType", s: "Span *") -> None: + value_converted = _ffi.cast("Datum", value) + basetype_converted = _ffi.cast("meosType", basetype) + s_converted = _ffi.cast("Span *", s) + _lib.value_set_span(value_converted, basetype_converted, s_converted) _check_error() - return result if result != _ffi.NULL else None -def distance_value_value(l: 'Datum', r: 'Datum', basetype: 'meosType') -> 'double': - l_converted = _ffi.cast('Datum', l) - r_converted = _ffi.cast('Datum', r) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.distance_value_value(l_converted, r_converted, basetype_converted) +def value_to_set(d: "Datum", basetype: "meosType") -> "Set *": + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.value_to_set(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def distance_span_value(s: 'const Span *', d: 'Datum', basetype: 'meosType') -> 'double': - s_converted = _ffi.cast('const Span *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.distance_span_value(s_converted, d_converted, basetype_converted) +def value_to_span(d: "Datum", basetype: "meosType") -> "Span *": + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.value_to_span(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def distance_spanset_value(ss: 'const SpanSet *', d: 'Datum', basetype: 'meosType') -> 'double': - ss_converted = _ffi.cast('const SpanSet *', ss) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.distance_spanset_value(ss_converted, d_converted, basetype_converted) +def value_to_spanset(d: "Datum", basetype: "meosType") -> "SpanSet *": + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.value_to_spanset(d_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def distance_value_set(d: 'Datum', basetype: 'meosType', s: 'const Set *') -> 'double': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Set *', s) - result = _lib.distance_value_set(d_converted, basetype_converted, s_converted) +def numspan_width(s: "const Span *") -> "Datum": + s_converted = _ffi.cast("const Span *", s) + result = _lib.numspan_width(s_converted) _check_error() return result if result != _ffi.NULL else None -def distance_set_value(s: 'const Set *', d: 'Datum', basetype: 'meosType') -> 'double': - s_converted = _ffi.cast('const Set *', s) - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.distance_set_value(s_converted, d_converted, basetype_converted) +def numspanset_width(ss: "const SpanSet *", boundspan: bool) -> "Datum": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.numspanset_width(ss_converted, boundspan) _check_error() return result if result != _ffi.NULL else None -def datum_hash(d: 'Datum', basetype: 'meosType') -> 'uint32': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.datum_hash(d_converted, basetype_converted) +def set_end_value(s: "const Set *") -> "Datum": + s_converted = _ffi.cast("const Set *", s) + result = _lib.set_end_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def datum_hash_extended(d: 'Datum', basetype: 'meosType', seed: int) -> 'uint64': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - seed_converted = _ffi.cast('uint64', seed) - result = _lib.datum_hash_extended(d_converted, basetype_converted, seed_converted) +def set_mem_size(s: "const Set *") -> "int": + s_converted = _ffi.cast("const Set *", s) + result = _lib.set_mem_size(s_converted) _check_error() return result if result != _ffi.NULL else None -def number_tstzspan_to_tbox(d: 'Datum', basetype: 'meosType', s: 'const Span *') -> 'TBox *': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - s_converted = _ffi.cast('const Span *', s) - result = _lib.number_tstzspan_to_tbox(d_converted, basetype_converted, s_converted) +def set_set_span(s: "const Set *", sp: "Span *") -> None: + s_converted = _ffi.cast("const Set *", s) + sp_converted = _ffi.cast("Span *", sp) + _lib.set_set_span(s_converted, sp_converted) _check_error() - return result if result != _ffi.NULL else None -def number_timestamptz_to_tbox(d: 'Datum', basetype: 'meosType', t: int) -> 'TBox *': - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.number_timestamptz_to_tbox(d_converted, basetype_converted, t_converted) +def set_span(s: "const Set *") -> "Span *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.set_span(s_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_cp(box: 'const STBox *') -> 'STBox *': - box_converted = _ffi.cast('const STBox *', box) - result = _lib.stbox_cp(box_converted) +def set_start_value(s: "const Set *") -> "Datum": + s_converted = _ffi.cast("const Set *", s) + result = _lib.set_start_value(s_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_set(hasx: bool, hasz: bool, geodetic: bool, srid: int, xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float, s: 'const Span *', box: 'STBox *') -> None: - srid_converted = _ffi.cast('int32', srid) - s_converted = _ffi.cast('const Span *', s) - box_converted = _ffi.cast('STBox *', box) - _lib.stbox_set(hasx, hasz, geodetic, srid_converted, xmin, xmax, ymin, ymax, zmin, zmax, s_converted, box_converted) +def set_value_n(s: "const Set *", n: int) -> "Datum *": + s_converted = _ffi.cast("const Set *", s) + out_result = _ffi.new("Datum *") + result = _lib.set_value_n(s_converted, n, out_result) _check_error() + if result: + return out_result if out_result != _ffi.NULL else None + return None -def tbox_cp(box: 'const TBox *') -> 'TBox *': - box_converted = _ffi.cast('const TBox *', box) - result = _lib.tbox_cp(box_converted) +def set_vals(s: "const Set *") -> "Datum *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.set_vals(s_converted) _check_error() return result if result != _ffi.NULL else None -def tbox_set(s: 'const Span *', p: 'const Span *', box: 'TBox *') -> None: - s_converted = _ffi.cast('const Span *', s) - p_converted = _ffi.cast('const Span *', p) - box_converted = _ffi.cast('TBox *', box) - _lib.tbox_set(s_converted, p_converted, box_converted) +def set_values(s: "const Set *") -> "Datum *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.set_values(s_converted) _check_error() + return result if result != _ffi.NULL else None -def float_set_tbox(d: float, box: 'TBox *') -> None: - box_converted = _ffi.cast('TBox *', box) - _lib.float_set_tbox(d, box_converted) +def spanset_lower(ss: "const SpanSet *") -> "Datum": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.spanset_lower(ss_converted) _check_error() + return result if result != _ffi.NULL else None -def geo_set_stbox(gs: 'const GSERIALIZED *', box: 'STBox *') -> 'bool': - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - box_converted = _ffi.cast('STBox *', box) - result = _lib.geo_set_stbox(gs_converted, box_converted) +def spanset_mem_size(ss: "const SpanSet *") -> "int": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.spanset_mem_size(ss_converted) _check_error() return result if result != _ffi.NULL else None -def geoarr_set_stbox(values: 'const Datum *', count: int, box: 'STBox *') -> None: - values_converted = _ffi.cast('const Datum *', values) - box_converted = _ffi.cast('STBox *', box) - _lib.geoarr_set_stbox(values_converted, count, box_converted) +def spanset_sps(ss: "const SpanSet *") -> "const Span **": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.spanset_sps(ss_converted) _check_error() + return result if result != _ffi.NULL else None -def int_set_tbox(i: int, box: 'TBox *') -> None: - box_converted = _ffi.cast('TBox *', box) - _lib.int_set_tbox(i, box_converted) +def spanset_upper(ss: "const SpanSet *") -> "Datum": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.spanset_upper(ss_converted) _check_error() + return result if result != _ffi.NULL else None -def number_set_tbox(d: 'Datum', basetype: 'meosType', box: 'TBox *') -> None: - d_converted = _ffi.cast('Datum', d) - basetype_converted = _ffi.cast('meosType', basetype) - box_converted = _ffi.cast('TBox *', box) - _lib.number_set_tbox(d_converted, basetype_converted, box_converted) +def datespan_set_tstzspan(s1: "const Span *", s2: "Span *") -> None: + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("Span *", s2) + _lib.datespan_set_tstzspan(s1_converted, s2_converted) _check_error() -def number_to_tbox(value: 'Datum', basetype: 'meosType') -> 'TBox *': - value_converted = _ffi.cast('Datum', value) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.number_to_tbox(value_converted, basetype_converted) +def floatspan_rnd(span: "const Span *", size: "Datum") -> "Span *": + span_converted = _ffi.cast("const Span *", span) + size_converted = _ffi.cast("Datum", size) + out_result = _ffi.new("Span *") + _lib.floatspan_rnd(span_converted, size_converted, out_result) _check_error() - return result if result != _ffi.NULL else None + return out_result if out_result != _ffi.NULL else None -def numset_set_tbox(s: 'const Set *', box: 'TBox *') -> None: - s_converted = _ffi.cast('const Set *', s) - box_converted = _ffi.cast('TBox *', box) - _lib.numset_set_tbox(s_converted, box_converted) +def floatspan_set_intspan(s1: "const Span *", s2: "Span *") -> None: + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("Span *", s2) + _lib.floatspan_set_intspan(s1_converted, s2_converted) _check_error() -def numspan_set_tbox(span: 'const Span *', box: 'TBox *') -> None: - span_converted = _ffi.cast('const Span *', span) - box_converted = _ffi.cast('TBox *', box) - _lib.numspan_set_tbox(span_converted, box_converted) +def intspan_set_floatspan(s1: "const Span *", s2: "Span *") -> None: + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("Span *", s2) + _lib.intspan_set_floatspan(s1_converted, s2_converted) _check_error() -def numspanset_set_tbox(ss: 'const SpanSet *', box: 'TBox *') -> None: - ss_converted = _ffi.cast('const SpanSet *', ss) - box_converted = _ffi.cast('TBox *', box) - _lib.numspanset_set_tbox(ss_converted, box_converted) +def numset_shift_scale( + s: "const Set *", shift: "Datum", width: "Datum", hasshift: bool, haswidth: bool +) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + shift_converted = _ffi.cast("Datum", shift) + width_converted = _ffi.cast("Datum", width) + result = _lib.numset_shift_scale( + s_converted, shift_converted, width_converted, hasshift, haswidth + ) _check_error() + return result if result != _ffi.NULL else None -def tstzspan_set_stbox(s: 'const Span *', box: 'STBox *') -> None: - s_converted = _ffi.cast('const Span *', s) - box_converted = _ffi.cast('STBox *', box) - _lib.tstzspan_set_stbox(s_converted, box_converted) +def numspan_shift_scale( + s: "const Span *", shift: "Datum", width: "Datum", hasshift: bool, haswidth: bool +) -> "Span *": + s_converted = _ffi.cast("const Span *", s) + shift_converted = _ffi.cast("Datum", shift) + width_converted = _ffi.cast("Datum", width) + result = _lib.numspan_shift_scale( + s_converted, shift_converted, width_converted, hasshift, haswidth + ) _check_error() + return result if result != _ffi.NULL else None -def tstzspan_set_tbox(s: 'const Span *', box: 'TBox *') -> None: - s_converted = _ffi.cast('const Span *', s) - box_converted = _ffi.cast('TBox *', box) - _lib.tstzspan_set_tbox(s_converted, box_converted) +def numspanset_shift_scale( + ss: "const SpanSet *", + shift: "Datum", + width: "Datum", + hasshift: bool, + haswidth: bool, +) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + shift_converted = _ffi.cast("Datum", shift) + width_converted = _ffi.cast("Datum", width) + result = _lib.numspanset_shift_scale( + ss_converted, shift_converted, width_converted, hasshift, haswidth + ) _check_error() + return result if result != _ffi.NULL else None -def tstzspanset_set_stbox(ss: 'const SpanSet *', box: 'STBox *') -> None: - ss_converted = _ffi.cast('const SpanSet *', ss) - box_converted = _ffi.cast('STBox *', box) - _lib.tstzspanset_set_stbox(ss_converted, box_converted) +def set_compact(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.set_compact(s_converted) _check_error() + return result if result != _ffi.NULL else None -def tstzspanset_set_tbox(ss: 'const SpanSet *', box: 'TBox *') -> None: - ss_converted = _ffi.cast('const SpanSet *', ss) - box_converted = _ffi.cast('TBox *', box) - _lib.tstzspanset_set_tbox(ss_converted, box_converted) +def span_expand(s1: "const Span *", s2: "Span *") -> None: + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("Span *", s2) + _lib.span_expand(s1_converted, s2_converted) _check_error() -def stbox_set_box3d(box: 'const STBox *', box3d: 'BOX3D *') -> None: - box_converted = _ffi.cast('const STBox *', box) - box3d_converted = _ffi.cast('BOX3D *', box3d) - _lib.stbox_set_box3d(box_converted, box3d_converted) +def spanset_compact(ss: "SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("SpanSet *", ss) + result = _lib.spanset_compact(ss_converted) _check_error() + return result if result != _ffi.NULL else None -def stbox_set_gbox(box: 'const STBox *', gbox: 'GBOX *') -> None: - box_converted = _ffi.cast('const STBox *', box) - gbox_converted = _ffi.cast('GBOX *', gbox) - _lib.stbox_set_gbox(box_converted, gbox_converted) +def tstzspan_set_datespan(s1: "const Span *", s2: "Span *") -> None: + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("Span *", s2) + _lib.tstzspan_set_datespan(s1_converted, s2_converted) _check_error() -def timestamptz_set_stbox(t: int, box: 'STBox *') -> None: - t_converted = _ffi.cast('TimestampTz', t) - box_converted = _ffi.cast('STBox *', box) - _lib.timestamptz_set_stbox(t_converted, box_converted) +def adj_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.adj_span_span(s1_converted, s2_converted) _check_error() + return result if result != _ffi.NULL else None -def timestamptz_set_tbox(t: int, box: 'TBox *') -> None: - t_converted = _ffi.cast('TimestampTz', t) - box_converted = _ffi.cast('TBox *', box) - _lib.timestamptz_set_tbox(t_converted, box_converted) +def adjacent_span_value(s: "const Span *", value: "Datum") -> "bool": + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.adjacent_span_value(s_converted, value_converted) _check_error() + return result if result != _ffi.NULL else None -def tstzset_set_stbox(s: 'const Set *', box: 'STBox *') -> None: - s_converted = _ffi.cast('const Set *', s) - box_converted = _ffi.cast('STBox *', box) - _lib.tstzset_set_stbox(s_converted, box_converted) +def adjacent_spanset_value(ss: "const SpanSet *", value: "Datum") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.adjacent_spanset_value(ss_converted, value_converted) _check_error() + return result if result != _ffi.NULL else None -def tstzset_set_tbox(s: 'const Set *', box: 'TBox *') -> None: - s_converted = _ffi.cast('const Set *', s) - box_converted = _ffi.cast('TBox *', box) - _lib.tstzset_set_tbox(s_converted, box_converted) +def adjacent_value_spanset(value: "Datum", ss: "const SpanSet *") -> "bool": + value_converted = _ffi.cast("Datum", value) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.adjacent_value_spanset(value_converted, ss_converted) _check_error() + return result if result != _ffi.NULL else None -def tbox_shift_scale_value(box: 'const TBox *', shift: 'Datum', width: 'Datum', basetype: 'meosType', hasshift: bool, haswidth: bool) -> 'TBox *': - box_converted = _ffi.cast('const TBox *', box) - shift_converted = _ffi.cast('Datum', shift) - width_converted = _ffi.cast('Datum', width) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.tbox_shift_scale_value(box_converted, shift_converted, width_converted, basetype_converted, hasshift, haswidth) +def cont_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.cont_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def stbox_expand(box1: 'const STBox *', box2: 'STBox *') -> None: - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('STBox *', box2) - _lib.stbox_expand(box1_converted, box2_converted) +def contained_value_set(value: "Datum", s: "const Set *") -> "bool": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Set *", s) + result = _lib.contained_value_set(value_converted, s_converted) _check_error() + return result if result != _ffi.NULL else None -def tbox_expand(box1: 'const TBox *', box2: 'TBox *') -> None: - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('TBox *', box2) - _lib.tbox_expand(box1_converted, box2_converted) +def contained_value_span(value: "Datum", s: "const Span *") -> "bool": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Span *", s) + result = _lib.contained_value_span(value_converted, s_converted) _check_error() + return result if result != _ffi.NULL else None -def bbox_union_span_span(s1: 'const Span *', s2: 'const Span *') -> 'Span *': - s1_converted = _ffi.cast('const Span *', s1) - s2_converted = _ffi.cast('const Span *', s2) - out_result = _ffi.new('Span *') - _lib.bbox_union_span_span(s1_converted, s2_converted, out_result) +def contained_value_spanset(value: "Datum", ss: "const SpanSet *") -> "bool": + value_converted = _ffi.cast("Datum", value) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.contained_value_spanset(value_converted, ss_converted) _check_error() - return out_result if out_result!= _ffi.NULL else None - + return result if result != _ffi.NULL else None -def inter_stbox_stbox(box1: 'const STBox *', box2: 'const STBox *') -> 'STBox *': - box1_converted = _ffi.cast('const STBox *', box1) - box2_converted = _ffi.cast('const STBox *', box2) - out_result = _ffi.new('STBox *') - result = _lib.inter_stbox_stbox(box1_converted, box2_converted, out_result) +def contains_set_value(s: "const Set *", value: "Datum") -> "bool": + s_converted = _ffi.cast("const Set *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.contains_set_value(s_converted, value_converted) _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None + return result if result != _ffi.NULL else None -def inter_tbox_tbox(box1: 'const TBox *', box2: 'const TBox *') -> 'TBox *': - box1_converted = _ffi.cast('const TBox *', box1) - box2_converted = _ffi.cast('const TBox *', box2) - out_result = _ffi.new('TBox *') - result = _lib.inter_tbox_tbox(box1_converted, box2_converted, out_result) +def contains_span_value(s: "const Span *", value: "Datum") -> "bool": + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.contains_span_value(s_converted, value_converted) _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None + return result if result != _ffi.NULL else None -def geoarr_as_text(geoarr: 'const Datum *', count: int, maxdd: int, extended: bool) -> 'char **': - geoarr_converted = _ffi.cast('const Datum *', geoarr) - result = _lib.geoarr_as_text(geoarr_converted, count, maxdd, extended) +def contains_spanset_value(ss: "const SpanSet *", value: "Datum") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.contains_spanset_value(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tboolinst_as_mfjson(inst: 'const TInstant *', with_bbox: bool) -> str: - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.tboolinst_as_mfjson(inst_converted, with_bbox) +def ovadj_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.ovadj_span_span(s1_converted, s2_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tboolinst_from_mfjson(mfjson: 'json_object *') -> 'TInstant *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - result = _lib.tboolinst_from_mfjson(mfjson_converted) +def over_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.over_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tboolinst_in(string: str) -> 'TInstant *': - string_converted = string.encode('utf-8') - result = _lib.tboolinst_in(string_converted) +def left_set_value(s: "const Set *", value: "Datum") -> "bool": + s_converted = _ffi.cast("const Set *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.left_set_value(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseq_as_mfjson(seq: 'const TSequence *', with_bbox: bool) -> str: - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tboolseq_as_mfjson(seq_converted, with_bbox) +def left_span_value(s: "const Span *", value: "Datum") -> "bool": + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.left_span_value(s_converted, value_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tboolseq_from_mfjson(mfjson: 'json_object *') -> 'TSequence *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - result = _lib.tboolseq_from_mfjson(mfjson_converted) +def left_spanset_value(ss: "const SpanSet *", value: "Datum") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.left_spanset_value(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseq_in(string: str, interp: 'interpType') -> 'TSequence *': - string_converted = string.encode('utf-8') - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tboolseq_in(string_converted, interp_converted) +def left_value_set(value: "Datum", s: "const Set *") -> "bool": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Set *", s) + result = _lib.left_value_set(value_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseqset_as_mfjson(ss: 'const TSequenceSet *', with_bbox: bool) -> str: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tboolseqset_as_mfjson(ss_converted, with_bbox) +def left_value_span(value: "Datum", s: "const Span *") -> "bool": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Span *", s) + result = _lib.left_value_span(value_converted, s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tboolseqset_from_mfjson(mfjson: 'json_object *') -> 'TSequenceSet *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - result = _lib.tboolseqset_from_mfjson(mfjson_converted) +def left_value_spanset(value: "Datum", ss: "const SpanSet *") -> "bool": + value_converted = _ffi.cast("Datum", value) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.left_value_spanset(value_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tboolseqset_in(string: str) -> 'TSequenceSet *': - string_converted = string.encode('utf-8') - result = _lib.tboolseqset_in(string_converted) +def lf_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.lf_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_in(string: str, temptype: 'meosType') -> 'Temporal *': - string_converted = string.encode('utf-8') - temptype_converted = _ffi.cast('meosType', temptype) - result = _lib.temporal_in(string_converted, temptype_converted) +def lfnadj_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.lfnadj_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_out(temp: 'const Temporal *', maxdd: int) -> str: - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_out(temp_converted, maxdd) +def overleft_set_value(s: "const Set *", value: "Datum") -> "bool": + s_converted = _ffi.cast("const Set *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.overleft_set_value(s_converted, value_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def temporal_values(temp: 'const Temporal *') -> "Tuple['Datum *', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - count = _ffi.new('int *') - result = _lib.temporal_values(temp_converted, count) +def overleft_span_value(s: "const Span *", value: "Datum") -> "bool": + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.overleft_span_value(s_converted, value_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def temporalarr_out(temparr: 'const Temporal **', count: int, maxdd: int) -> 'char **': - temparr_converted = [_ffi.cast('const Temporal *', x) for x in temparr] - result = _lib.temporalarr_out(temparr_converted, count, maxdd) +def overleft_spanset_value(ss: "const SpanSet *", value: "Datum") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.overleft_spanset_value(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatinst_as_mfjson(inst: 'const TInstant *', with_bbox: bool, precision: int) -> str: - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.tfloatinst_as_mfjson(inst_converted, with_bbox, precision) +def overleft_value_set(value: "Datum", s: "const Set *") -> "bool": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Set *", s) + result = _lib.overleft_value_set(value_converted, s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tfloatinst_from_mfjson(mfjson: 'json_object *') -> 'TInstant *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - result = _lib.tfloatinst_from_mfjson(mfjson_converted) +def overleft_value_span(value: "Datum", s: "const Span *") -> "bool": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overleft_value_span(value_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatinst_in(string: str) -> 'TInstant *': - string_converted = string.encode('utf-8') - result = _lib.tfloatinst_in(string_converted) +def overleft_value_spanset(value: "Datum", ss: "const SpanSet *") -> "bool": + value_converted = _ffi.cast("Datum", value) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overleft_value_spanset(value_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseq_as_mfjson(seq: 'const TSequence *', with_bbox: bool, precision: int) -> str: - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tfloatseq_as_mfjson(seq_converted, with_bbox, precision) +def overright_set_value(s: "const Set *", value: "Datum") -> "bool": + s_converted = _ffi.cast("const Set *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.overright_set_value(s_converted, value_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tfloatseq_from_mfjson(mfjson: 'json_object *', interp: 'interpType') -> 'TSequence *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tfloatseq_from_mfjson(mfjson_converted, interp_converted) +def overright_span_value(s: "const Span *", value: "Datum") -> "bool": + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.overright_span_value(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseq_in(string: str, interp: 'interpType') -> 'TSequence *': - string_converted = string.encode('utf-8') - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tfloatseq_in(string_converted, interp_converted) +def overright_spanset_value(ss: "const SpanSet *", value: "Datum") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.overright_spanset_value(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseqset_as_mfjson(ss: 'const TSequenceSet *', with_bbox: bool, precision: int) -> str: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tfloatseqset_as_mfjson(ss_converted, with_bbox, precision) +def overright_value_set(value: "Datum", s: "const Set *") -> "bool": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Set *", s) + result = _lib.overright_value_set(value_converted, s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tfloatseqset_from_mfjson(mfjson: 'json_object *', interp: 'interpType') -> 'TSequenceSet *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tfloatseqset_from_mfjson(mfjson_converted, interp_converted) +def overright_value_span(value: "Datum", s: "const Span *") -> "bool": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Span *", s) + result = _lib.overright_value_span(value_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tfloatseqset_in(string: str) -> 'TSequenceSet *': - string_converted = string.encode('utf-8') - result = _lib.tfloatseqset_in(string_converted) +def overright_value_spanset(value: "Datum", ss: "const SpanSet *") -> "bool": + value_converted = _ffi.cast("Datum", value) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.overright_value_spanset(value_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpointinst_from_mfjson(mfjson: 'json_object *', srid: int) -> 'TInstant *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - result = _lib.tgeogpointinst_from_mfjson(mfjson_converted, srid) +def ovlf_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.ovlf_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpointinst_in(string: str) -> 'TInstant *': - string_converted = string.encode('utf-8') - result = _lib.tgeogpointinst_in(string_converted) +def ovri_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.ovri_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpointseq_from_mfjson(mfjson: 'json_object *', srid: int, interp: 'interpType') -> 'TSequence *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tgeogpointseq_from_mfjson(mfjson_converted, srid, interp_converted) +def ri_span_span(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.ri_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpointseq_in(string: str, interp: 'interpType') -> 'TSequence *': - string_converted = string.encode('utf-8') - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tgeogpointseq_in(string_converted, interp_converted) +def right_value_set(value: "Datum", s: "const Set *") -> "bool": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Set *", s) + result = _lib.right_value_set(value_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpointseqset_from_mfjson(mfjson: 'json_object *', srid: int, interp: 'interpType') -> 'TSequenceSet *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tgeogpointseqset_from_mfjson(mfjson_converted, srid, interp_converted) +def right_set_value(s: "const Set *", value: "Datum") -> "bool": + s_converted = _ffi.cast("const Set *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.right_set_value(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tgeogpointseqset_in(string: str) -> 'TSequenceSet *': - string_converted = string.encode('utf-8') - result = _lib.tgeogpointseqset_in(string_converted) +def right_value_span(value: "Datum", s: "const Span *") -> "bool": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Span *", s) + result = _lib.right_value_span(value_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompointinst_from_mfjson(mfjson: 'json_object *', srid: int) -> 'TInstant *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - result = _lib.tgeompointinst_from_mfjson(mfjson_converted, srid) +def right_value_spanset(value: "Datum", ss: "const SpanSet *") -> "bool": + value_converted = _ffi.cast("Datum", value) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.right_value_spanset(value_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompointinst_in(string: str) -> 'TInstant *': - string_converted = string.encode('utf-8') - result = _lib.tgeompointinst_in(string_converted) +def right_span_value(s: "const Span *", value: "Datum") -> "bool": + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.right_span_value(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompointseq_from_mfjson(mfjson: 'json_object *', srid: int, interp: 'interpType') -> 'TSequence *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tgeompointseq_from_mfjson(mfjson_converted, srid, interp_converted) +def right_spanset_value(ss: "const SpanSet *", value: "Datum") -> "bool": + ss_converted = _ffi.cast("const SpanSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.right_spanset_value(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompointseq_in(string: str, interp: 'interpType') -> 'TSequence *': - string_converted = string.encode('utf-8') - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tgeompointseq_in(string_converted, interp_converted) +def bbox_union_span_span(s1: "const Span *", s2: "const Span *") -> "Span *": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + out_result = _ffi.new("Span *") + _lib.bbox_union_span_span(s1_converted, s2_converted, out_result) _check_error() - return result if result != _ffi.NULL else None + return out_result if out_result != _ffi.NULL else None -def tgeompointseqset_from_mfjson(mfjson: 'json_object *', srid: int, interp: 'interpType') -> 'TSequenceSet *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tgeompointseqset_from_mfjson(mfjson_converted, srid, interp_converted) +def inter_span_span(s1: "const Span *", s2: "const Span *") -> "Span *": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + out_result = _ffi.new("Span *") + result = _lib.inter_span_span(s1_converted, s2_converted, out_result) _check_error() - return result if result != _ffi.NULL else None + if result: + return out_result if out_result != _ffi.NULL else None + return None -def tgeompointseqset_in(string: str) -> 'TSequenceSet *': - string_converted = string.encode('utf-8') - result = _lib.tgeompointseqset_in(string_converted) +def intersection_set_value(s: "const Set *", value: "Datum") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.intersection_set_value(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_as_mfjson(inst: 'const TInstant *', with_bbox: bool, precision: int, srs: str) -> str: - inst_converted = _ffi.cast('const TInstant *', inst) - srs_converted = srs.encode('utf-8') - result = _lib.tinstant_as_mfjson(inst_converted, with_bbox, precision, srs_converted) +def intersection_span_value(s: "const Span *", value: "Datum") -> "Span *": + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.intersection_span_value(s_converted, value_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tinstant_from_mfjson(mfjson: 'json_object *', isgeo: bool, srid: int, temptype: 'meosType') -> 'TInstant *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - temptype_converted = _ffi.cast('meosType', temptype) - result = _lib.tinstant_from_mfjson(mfjson_converted, isgeo, srid, temptype_converted) +def intersection_spanset_value(ss: "const SpanSet *", value: "Datum") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.intersection_spanset_value(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_in(string: str, temptype: 'meosType') -> 'TInstant *': - string_converted = string.encode('utf-8') - temptype_converted = _ffi.cast('meosType', temptype) - result = _lib.tinstant_in(string_converted, temptype_converted) +def intersection_value_set(value: "Datum", s: "const Set *") -> "Set *": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Set *", s) + result = _lib.intersection_value_set(value_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_out(inst: 'const TInstant *', maxdd: int) -> str: - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.tinstant_out(inst_converted, maxdd) +def intersection_value_span(value: "Datum", s: "const Span *") -> "Span *": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Span *", s) + result = _lib.intersection_value_span(value_converted, s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tintinst_as_mfjson(inst: 'const TInstant *', with_bbox: bool) -> str: - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.tintinst_as_mfjson(inst_converted, with_bbox) +def intersection_value_spanset(value: "Datum", ss: "const SpanSet *") -> "SpanSet *": + value_converted = _ffi.cast("Datum", value) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.intersection_value_spanset(value_converted, ss_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tintinst_from_mfjson(mfjson: 'json_object *') -> 'TInstant *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - result = _lib.tintinst_from_mfjson(mfjson_converted) +def mi_span_span(s1: "const Span *", s2: "const Span *") -> "Span *": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + out_result = _ffi.new("Span *") + result = _lib.mi_span_span(s1_converted, s2_converted, out_result) _check_error() - return result if result != _ffi.NULL else None + return out_result if out_result != _ffi.NULL else None -def tintinst_in(string: str) -> 'TInstant *': - string_converted = string.encode('utf-8') - result = _lib.tintinst_in(string_converted) +def minus_set_value(s: "const Set *", value: "Datum") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.minus_set_value(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tintseq_as_mfjson(seq: 'const TSequence *', with_bbox: bool) -> str: - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tintseq_as_mfjson(seq_converted, with_bbox) +def minus_span_value(s: "const Span *", value: "Datum") -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.minus_span_value(s_converted, value_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tintseq_from_mfjson(mfjson: 'json_object *') -> 'TSequence *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - result = _lib.tintseq_from_mfjson(mfjson_converted) +def minus_spanset_value(ss: "const SpanSet *", value: "Datum") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.minus_spanset_value(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tintseq_in(string: str, interp: 'interpType') -> 'TSequence *': - string_converted = string.encode('utf-8') - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tintseq_in(string_converted, interp_converted) +def minus_value_set(value: "Datum", s: "const Set *") -> "Set *": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Set *", s) + result = _lib.minus_value_set(value_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tintseqset_as_mfjson(ss: 'const TSequenceSet *', with_bbox: bool) -> str: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tintseqset_as_mfjson(ss_converted, with_bbox) +def minus_value_span(value: "Datum", s: "const Span *") -> "SpanSet *": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Span *", s) + result = _lib.minus_value_span(value_converted, s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tintseqset_from_mfjson(mfjson: 'json_object *') -> 'TSequenceSet *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - result = _lib.tintseqset_from_mfjson(mfjson_converted) +def minus_value_spanset(value: "Datum", ss: "const SpanSet *") -> "SpanSet *": + value_converted = _ffi.cast("Datum", value) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.minus_value_spanset(value_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tintseqset_in(string: str) -> 'TSequenceSet *': - string_converted = string.encode('utf-8') - result = _lib.tintseqset_in(string_converted) +def super_union_span_span(s1: "const Span *", s2: "const Span *") -> "Span *": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.super_union_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tpointarr_as_text(temparr: 'const Temporal **', count: int, maxdd: int, extended: bool) -> 'char **': - temparr_converted = [_ffi.cast('const Temporal *', x) for x in temparr] - result = _lib.tpointarr_as_text(temparr_converted, count, maxdd, extended) +def union_set_value(s: "const Set *", value: "const Datum") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + value_converted = _ffi.cast("const Datum", value) + result = _lib.union_set_value(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointinst_as_mfjson(inst: 'const TInstant *', with_bbox: bool, precision: int, srs: str) -> str: - inst_converted = _ffi.cast('const TInstant *', inst) - srs_converted = srs.encode('utf-8') - result = _lib.tpointinst_as_mfjson(inst_converted, with_bbox, precision, srs_converted) +def union_span_value(s: "const Span *", value: "Datum") -> "SpanSet *": + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.union_span_value(s_converted, value_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tpointseq_as_mfjson(seq: 'const TSequence *', with_bbox: bool, precision: int, srs: str) -> str: - seq_converted = _ffi.cast('const TSequence *', seq) - srs_converted = srs.encode('utf-8') - result = _lib.tpointseq_as_mfjson(seq_converted, with_bbox, precision, srs_converted) +def union_spanset_value(ss: "const SpanSet *", value: "Datum") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.union_spanset_value(ss_converted, value_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tpointseqset_as_mfjson(ss: 'const TSequenceSet *', with_bbox: bool, precision: int, srs: str) -> str: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - srs_converted = srs.encode('utf-8') - result = _lib.tpointseqset_as_mfjson(ss_converted, with_bbox, precision, srs_converted) +def union_value_set(value: "const Datum", s: "const Set *") -> "Set *": + value_converted = _ffi.cast("const Datum", value) + s_converted = _ffi.cast("const Set *", s) + result = _lib.union_value_set(value_converted, s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tsequence_as_mfjson(seq: 'const TSequence *', with_bbox: bool, precision: int, srs: str) -> str: - seq_converted = _ffi.cast('const TSequence *', seq) - srs_converted = srs.encode('utf-8') - result = _lib.tsequence_as_mfjson(seq_converted, with_bbox, precision, srs_converted) +def union_value_span(value: "Datum", s: "const Span *") -> "SpanSet *": + value_converted = _ffi.cast("Datum", value) + s_converted = _ffi.cast("const Span *", s) + result = _lib.union_value_span(value_converted, s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tsequence_from_mfjson(mfjson: 'json_object *', isgeo: bool, srid: int, temptype: 'meosType', interp: 'interpType') -> 'TSequence *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - temptype_converted = _ffi.cast('meosType', temptype) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tsequence_from_mfjson(mfjson_converted, isgeo, srid, temptype_converted, interp_converted) +def union_value_spanset(value: "Datum", ss: "const SpanSet *") -> "SpanSet *": + value_converted = _ffi.cast("Datum", value) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.union_value_spanset(value_converted, ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_in(string: str, temptype: 'meosType', interp: 'interpType') -> 'TSequence *': - string_converted = string.encode('utf-8') - temptype_converted = _ffi.cast('meosType', temptype) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tsequence_in(string_converted, temptype_converted, interp_converted) +def dist_set_set(s1: "const Set *", s2: "const Set *") -> "Datum": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.dist_set_set(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_out(seq: 'const TSequence *', maxdd: int) -> str: - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_out(seq_converted, maxdd) +def dist_span_span(s1: "const Span *", s2: "const Span *") -> "Datum": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.dist_span_span(s1_converted, s2_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tsequenceset_as_mfjson(ss: 'const TSequenceSet *', with_bbox: bool, precision: int, srs: str) -> str: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - srs_converted = srs.encode('utf-8') - result = _lib.tsequenceset_as_mfjson(ss_converted, with_bbox, precision, srs_converted) +def distance_set_set(s1: "const Set *", s2: "const Set *") -> "Datum": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.distance_set_set(s1_converted, s2_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def tsequenceset_from_mfjson(mfjson: 'json_object *', isgeo: bool, srid: int, temptype: 'meosType', interp: 'interpType') -> 'TSequenceSet *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - temptype_converted = _ffi.cast('meosType', temptype) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tsequenceset_from_mfjson(mfjson_converted, isgeo, srid, temptype_converted, interp_converted) +def distance_set_value(s: "const Set *", value: "Datum") -> "Datum": + s_converted = _ffi.cast("const Set *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.distance_set_value(s_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_in(string: str, temptype: 'meosType', interp: 'interpType') -> 'TSequenceSet *': - string_converted = string.encode('utf-8') - temptype_converted = _ffi.cast('meosType', temptype) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tsequenceset_in(string_converted, temptype_converted, interp_converted) +def distance_span_span(s1: "const Span *", s2: "const Span *") -> "Datum": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.distance_span_span(s1_converted, s2_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_out(ss: 'const TSequenceSet *', maxdd: int) -> str: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_out(ss_converted, maxdd) +def distance_span_value(s: "const Span *", value: "Datum") -> "Datum": + s_converted = _ffi.cast("const Span *", s) + value_converted = _ffi.cast("Datum", value) + result = _lib.distance_span_value(s_converted, value_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def ttextinst_as_mfjson(inst: 'const TInstant *', with_bbox: bool) -> str: - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.ttextinst_as_mfjson(inst_converted, with_bbox) +def distance_spanset_span(ss: "const SpanSet *", s: "const Span *") -> "Datum": + ss_converted = _ffi.cast("const SpanSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.distance_spanset_span(ss_converted, s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def ttextinst_from_mfjson(mfjson: 'json_object *') -> 'TInstant *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - result = _lib.ttextinst_from_mfjson(mfjson_converted) +def distance_spanset_spanset(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "Datum": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.distance_spanset_spanset(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def ttextinst_in(string: str) -> 'TInstant *': - string_converted = string.encode('utf-8') - result = _lib.ttextinst_in(string_converted) +def distance_spanset_value(ss: "const SpanSet *", value: "Datum") -> "Datum": + ss_converted = _ffi.cast("const SpanSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.distance_spanset_value(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def ttextseq_as_mfjson(seq: 'const TSequence *', with_bbox: bool) -> str: - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.ttextseq_as_mfjson(seq_converted, with_bbox) +def distance_value_value(l: "Datum", r: "Datum", basetype: "meosType") -> "Datum": + l_converted = _ffi.cast("Datum", l) + r_converted = _ffi.cast("Datum", r) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.distance_value_value(l_converted, r_converted, basetype_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def ttextseq_from_mfjson(mfjson: 'json_object *') -> 'TSequence *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - result = _lib.ttextseq_from_mfjson(mfjson_converted) +def spanbase_extent_transfn( + state: "Span *", value: "Datum", basetype: "meosType" +) -> "Span *": + state_converted = _ffi.cast("Span *", state) + value_converted = _ffi.cast("Datum", value) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.spanbase_extent_transfn( + state_converted, value_converted, basetype_converted + ) _check_error() return result if result != _ffi.NULL else None -def ttextseq_in(string: str, interp: 'interpType') -> 'TSequence *': - string_converted = string.encode('utf-8') - interp_converted = _ffi.cast('interpType', interp) - result = _lib.ttextseq_in(string_converted, interp_converted) +def value_union_transfn( + state: "Set *", value: "Datum", basetype: "meosType" +) -> "Set *": + state_converted = _ffi.cast("Set *", state) + value_converted = _ffi.cast("Datum", value) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.value_union_transfn( + state_converted, value_converted, basetype_converted + ) _check_error() return result if result != _ffi.NULL else None -def ttextseqset_as_mfjson(ss: 'const TSequenceSet *', with_bbox: bool) -> str: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.ttextseqset_as_mfjson(ss_converted, with_bbox) +def number_tstzspan_to_tbox( + d: "Datum", basetype: "meosType", s: "const Span *" +) -> "TBox *": + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) + s_converted = _ffi.cast("const Span *", s) + result = _lib.number_tstzspan_to_tbox(d_converted, basetype_converted, s_converted) _check_error() - result = _ffi.string(result).decode('utf-8') return result if result != _ffi.NULL else None -def ttextseqset_from_mfjson(mfjson: 'json_object *') -> 'TSequenceSet *': - mfjson_converted = _ffi.cast('json_object *', mfjson) - result = _lib.ttextseqset_from_mfjson(mfjson_converted) +def number_timestamptz_to_tbox(d: "Datum", basetype: "meosType", t: int) -> "TBox *": + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.number_timestamptz_to_tbox( + d_converted, basetype_converted, t_converted + ) _check_error() return result if result != _ffi.NULL else None -def ttextseqset_in(string: str) -> 'TSequenceSet *': - string_converted = string.encode('utf-8') - result = _lib.ttextseqset_in(string_converted) +def stbox_cp(box: "const STBox *") -> "STBox *": + box_converted = _ffi.cast("const STBox *", box) + result = _lib.stbox_cp(box_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_cp(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_cp(temp_converted) +def stbox_set( + hasx: bool, + hasz: bool, + geodetic: bool, + srid: int, + xmin: float, + xmax: float, + ymin: float, + ymax: float, + zmin: float, + zmax: float, + s: "const Span *", + box: "STBox *", +) -> None: + srid_converted = _ffi.cast("int32", srid) + s_converted = _ffi.cast("const Span *", s) + box_converted = _ffi.cast("STBox *", box) + _lib.stbox_set( + hasx, + hasz, + geodetic, + srid_converted, + xmin, + xmax, + ymin, + ymax, + zmin, + zmax, + s_converted, + box_converted, + ) _check_error() - return result if result != _ffi.NULL else None -def temporal_from_base_temp(value: 'Datum', temptype: 'meosType', temp: 'const Temporal *') -> 'Temporal *': - value_converted = _ffi.cast('Datum', value) - temptype_converted = _ffi.cast('meosType', temptype) - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_from_base_temp(value_converted, temptype_converted, temp_converted) +def tbox_cp(box: "const TBox *") -> "TBox *": + box_converted = _ffi.cast("const TBox *", box) + result = _lib.tbox_cp(box_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_copy(inst: 'const TInstant *') -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.tinstant_copy(inst_converted) +def tbox_set(s: "const Span *", p: "const Span *", box: "TBox *") -> None: + s_converted = _ffi.cast("const Span *", s) + p_converted = _ffi.cast("const Span *", p) + box_converted = _ffi.cast("TBox *", box) + _lib.tbox_set(s_converted, p_converted, box_converted) _check_error() - return result if result != _ffi.NULL else None -def tinstant_make(value: 'Datum', temptype: 'meosType', t: int) -> 'TInstant *': - value_converted = _ffi.cast('Datum', value) - temptype_converted = _ffi.cast('meosType', temptype) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.tinstant_make(value_converted, temptype_converted, t_converted) +def box3d_to_stbox(box: "const BOX3D *") -> "STBox *": + box_converted = _ffi.cast("const BOX3D *", box) + result = _lib.box3d_to_stbox(box_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_make_coords(xcoords: 'const double *', ycoords: 'const double *', zcoords: 'const double *', times: int, count: int, srid: int, geodetic: bool, lower_inc: bool, upper_inc: bool, interp: 'interpType', normalize: bool) -> 'TSequence *': - xcoords_converted = _ffi.cast('const double *', xcoords) - ycoords_converted = _ffi.cast('const double *', ycoords) - zcoords_converted = _ffi.cast('const double *', zcoords) - times_converted = _ffi.cast('const TimestampTz *', times) - srid_converted = _ffi.cast('int32', srid) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tpointseq_make_coords(xcoords_converted, ycoords_converted, zcoords_converted, times_converted, count, srid_converted, geodetic, lower_inc, upper_inc, interp_converted, normalize) +def gbox_to_stbox(box: "const GBOX *") -> "STBox *": + box_converted = _ffi.cast("const GBOX *", box) + result = _lib.gbox_to_stbox(box_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_from_base_tstzset(value: 'Datum', temptype: 'meosType', ss: 'const Set *') -> 'TSequence *': - value_converted = _ffi.cast('Datum', value) - temptype_converted = _ffi.cast('meosType', temptype) - ss_converted = _ffi.cast('const Set *', ss) - result = _lib.tsequence_from_base_tstzset(value_converted, temptype_converted, ss_converted) +def float_set_tbox(d: float, box: "TBox *") -> None: + box_converted = _ffi.cast("TBox *", box) + _lib.float_set_tbox(d, box_converted) _check_error() - return result if result != _ffi.NULL else None -def tsequence_make_exp(instants: 'const TInstant **', count: int, maxcount: int, lower_inc: bool, upper_inc: bool, interp: 'interpType', normalize: bool) -> 'TSequence *': - instants_converted = [_ffi.cast('const TInstant *', x) for x in instants] - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tsequence_make_exp(instants_converted, count, maxcount, lower_inc, upper_inc, interp_converted, normalize) +def gbox_to_stbox(box: "const GBOX *") -> "STBox *": + box_converted = _ffi.cast("const GBOX *", box) + result = _lib.gbox_to_stbox(box_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_compact(seq: 'const TSequence *') -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_compact(seq_converted) +def geo_set_stbox(gs: "const GSERIALIZED *", box: "STBox *") -> "bool": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + box_converted = _ffi.cast("STBox *", box) + result = _lib.geo_set_stbox(gs_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_restart(seq: 'TSequence *', last: int) -> None: - seq_converted = _ffi.cast('TSequence *', seq) - _lib.tsequence_restart(seq_converted, last) +def geoarr_set_stbox(values: "const Datum *", count: int, box: "STBox *") -> None: + values_converted = _ffi.cast("const Datum *", values) + box_converted = _ffi.cast("STBox *", box) + _lib.geoarr_set_stbox(values_converted, count, box_converted) _check_error() -def tsequence_subseq(seq: 'const TSequence *', from_: int, to: int, lower_inc: bool, upper_inc: bool) -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_subseq(seq_converted, from_, to, lower_inc, upper_inc) +def int_set_tbox(i: int, box: "TBox *") -> None: + box_converted = _ffi.cast("TBox *", box) + _lib.int_set_tbox(i, box_converted) _check_error() - return result if result != _ffi.NULL else None -def tsequence_copy(seq: 'const TSequence *') -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_copy(seq_converted) +def number_set_tbox(d: "Datum", basetype: "meosType", box: "TBox *") -> None: + d_converted = _ffi.cast("Datum", d) + basetype_converted = _ffi.cast("meosType", basetype) + box_converted = _ffi.cast("TBox *", box) + _lib.number_set_tbox(d_converted, basetype_converted, box_converted) _check_error() - return result if result != _ffi.NULL else None -def tsequence_from_base_tstzspan(value: 'Datum', temptype: 'meosType', s: 'const Span *', interp: 'interpType') -> 'TSequence *': - value_converted = _ffi.cast('Datum', value) - temptype_converted = _ffi.cast('meosType', temptype) - s_converted = _ffi.cast('const Span *', s) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tsequence_from_base_tstzspan(value_converted, temptype_converted, s_converted, interp_converted) +def number_to_tbox(value: "Datum", basetype: "meosType") -> "TBox *": + value_converted = _ffi.cast("Datum", value) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.number_to_tbox(value_converted, basetype_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_make_free(instants: 'TInstant **', count: int, lower_inc: bool, upper_inc: bool, interp: 'interpType', normalize: bool) -> 'TSequence *': - instants_converted = [_ffi.cast('TInstant *', x) for x in instants] - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tsequence_make_free(instants_converted, count, lower_inc, upper_inc, interp_converted, normalize) +def numset_set_tbox(s: "const Set *", box: "TBox *") -> None: + s_converted = _ffi.cast("const Set *", s) + box_converted = _ffi.cast("TBox *", box) + _lib.numset_set_tbox(s_converted, box_converted) _check_error() - return result if result != _ffi.NULL else None -def tsequenceset_make_exp(sequences: 'const TSequence **', count: int, maxcount: int, normalize: bool) -> 'TSequenceSet *': - sequences_converted = [_ffi.cast('const TSequence *', x) for x in sequences] - result = _lib.tsequenceset_make_exp(sequences_converted, count, maxcount, normalize) +def numspan_set_tbox(span: "const Span *", box: "TBox *") -> None: + span_converted = _ffi.cast("const Span *", span) + box_converted = _ffi.cast("TBox *", box) + _lib.numspan_set_tbox(span_converted, box_converted) _check_error() - return result if result != _ffi.NULL else None -def tsequenceset_compact(ss: 'const TSequenceSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_compact(ss_converted) +def numspanset_set_tbox(ss: "const SpanSet *", box: "TBox *") -> None: + ss_converted = _ffi.cast("const SpanSet *", ss) + box_converted = _ffi.cast("TBox *", box) + _lib.numspanset_set_tbox(ss_converted, box_converted) _check_error() - return result if result != _ffi.NULL else None -def tsequenceset_make_free(sequences: 'TSequence **', count: int, normalize: bool) -> 'TSequenceSet *': - sequences_converted = [_ffi.cast('TSequence *', x) for x in sequences] - result = _lib.tsequenceset_make_free(sequences_converted, count, normalize) +def spatialset_set_stbox(set: "const Set *", box: "STBox *") -> None: + set_converted = _ffi.cast("const Set *", set) + box_converted = _ffi.cast("STBox *", box) + _lib.spatialset_set_stbox(set_converted, box_converted) _check_error() - return result if result != _ffi.NULL else None -def tsequenceset_restart(ss: 'TSequenceSet *', last: int) -> None: - ss_converted = _ffi.cast('TSequenceSet *', ss) - _lib.tsequenceset_restart(ss_converted, last) +def stbox_set_box3d(box: "const STBox *", box3d: "BOX3D *") -> None: + box_converted = _ffi.cast("const STBox *", box) + box3d_converted = _ffi.cast("BOX3D *", box3d) + _lib.stbox_set_box3d(box_converted, box3d_converted) _check_error() -def tsequenceset_copy(ss: 'const TSequenceSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_copy(ss_converted) +def stbox_set_gbox(box: "const STBox *", gbox: "GBOX *") -> None: + box_converted = _ffi.cast("const STBox *", box) + gbox_converted = _ffi.cast("GBOX *", gbox) + _lib.stbox_set_gbox(box_converted, gbox_converted) _check_error() - return result if result != _ffi.NULL else None -def tseqsetarr_to_tseqset(seqsets: 'TSequenceSet **', count: int, totalseqs: int) -> 'TSequenceSet *': - seqsets_converted = [_ffi.cast('TSequenceSet *', x) for x in seqsets] - result = _lib.tseqsetarr_to_tseqset(seqsets_converted, count, totalseqs) +def timestamptz_set_stbox(t: int, box: "STBox *") -> None: + t_converted = _ffi.cast("TimestampTz", t) + box_converted = _ffi.cast("STBox *", box) + _lib.timestamptz_set_stbox(t_converted, box_converted) _check_error() - return result if result != _ffi.NULL else None -def tsequenceset_from_base_tstzspanset(value: 'Datum', temptype: 'meosType', ss: 'const SpanSet *', interp: 'interpType') -> 'TSequenceSet *': - value_converted = _ffi.cast('Datum', value) - temptype_converted = _ffi.cast('meosType', temptype) - ss_converted = _ffi.cast('const SpanSet *', ss) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tsequenceset_from_base_tstzspanset(value_converted, temptype_converted, ss_converted, interp_converted) +def timestamptz_set_tbox(t: int, box: "TBox *") -> None: + t_converted = _ffi.cast("TimestampTz", t) + box_converted = _ffi.cast("TBox *", box) + _lib.timestamptz_set_tbox(t_converted, box_converted) _check_error() - return result if result != _ffi.NULL else None -def temporal_set_tstzspan(temp: 'const Temporal *', s: 'Span *') -> None: - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('Span *', s) - _lib.temporal_set_tstzspan(temp_converted, s_converted) +def tstzset_set_stbox(s: "const Set *", box: "STBox *") -> None: + s_converted = _ffi.cast("const Set *", s) + box_converted = _ffi.cast("STBox *", box) + _lib.tstzset_set_stbox(s_converted, box_converted) _check_error() -def tinstant_set_tstzspan(inst: 'const TInstant *', s: 'Span *') -> None: - inst_converted = _ffi.cast('const TInstant *', inst) - s_converted = _ffi.cast('Span *', s) - _lib.tinstant_set_tstzspan(inst_converted, s_converted) +def tstzset_set_tbox(s: "const Set *", box: "TBox *") -> None: + s_converted = _ffi.cast("const Set *", s) + box_converted = _ffi.cast("TBox *", box) + _lib.tstzset_set_tbox(s_converted, box_converted) _check_error() -def tnumber_span(temp: 'const Temporal *') -> 'Span *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tnumber_span(temp_converted) +def tstzspan_set_stbox(s: "const Span *", box: "STBox *") -> None: + s_converted = _ffi.cast("const Span *", s) + box_converted = _ffi.cast("STBox *", box) + _lib.tstzspan_set_stbox(s_converted, box_converted) _check_error() - return result if result != _ffi.NULL else None -def tsequence_set_tstzspan(seq: 'const TSequence *', s: 'Span *') -> None: - seq_converted = _ffi.cast('const TSequence *', seq) - s_converted = _ffi.cast('Span *', s) - _lib.tsequence_set_tstzspan(seq_converted, s_converted) +def tstzspan_set_tbox(s: "const Span *", box: "TBox *") -> None: + s_converted = _ffi.cast("const Span *", s) + box_converted = _ffi.cast("TBox *", box) + _lib.tstzspan_set_tbox(s_converted, box_converted) _check_error() -def tsequenceset_set_tstzspan(ss: 'const TSequenceSet *', s: 'Span *') -> None: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - s_converted = _ffi.cast('Span *', s) - _lib.tsequenceset_set_tstzspan(ss_converted, s_converted) +def tstzspanset_set_stbox(ss: "const SpanSet *", box: "STBox *") -> None: + ss_converted = _ffi.cast("const SpanSet *", ss) + box_converted = _ffi.cast("STBox *", box) + _lib.tstzspanset_set_stbox(ss_converted, box_converted) _check_error() -def temporal_end_value(temp: 'const Temporal *') -> 'Datum': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_end_value(temp_converted) +def tstzspanset_set_tbox(ss: "const SpanSet *", box: "TBox *") -> None: + ss_converted = _ffi.cast("const SpanSet *", ss) + box_converted = _ffi.cast("TBox *", box) + _lib.tstzspanset_set_tbox(ss_converted, box_converted) _check_error() - return result if result != _ffi.NULL else None -def temporal_max_value(temp: 'const Temporal *') -> 'Datum': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_max_value(temp_converted) +def tbox_shift_scale_value( + box: "const TBox *", + shift: "Datum", + width: "Datum", + basetype: "meosType", + hasshift: bool, + haswidth: bool, +) -> "TBox *": + box_converted = _ffi.cast("const TBox *", box) + shift_converted = _ffi.cast("Datum", shift) + width_converted = _ffi.cast("Datum", width) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.tbox_shift_scale_value( + box_converted, + shift_converted, + width_converted, + basetype_converted, + hasshift, + haswidth, + ) _check_error() return result if result != _ffi.NULL else None -def temporal_mem_size(temp: 'const Temporal *') -> 'size_t': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_mem_size(temp_converted) +def stbox_expand(box1: "const STBox *", box2: "STBox *") -> None: + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("STBox *", box2) + _lib.stbox_expand(box1_converted, box2_converted) _check_error() - return result if result != _ffi.NULL else None -def temporal_min_value(temp: 'const Temporal *') -> 'Datum': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_min_value(temp_converted) +def tbox_expand(box1: "const TBox *", box2: "TBox *") -> None: + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("TBox *", box2) + _lib.tbox_expand(box1_converted, box2_converted) _check_error() - return result if result != _ffi.NULL else None -def temporal_set_bbox(temp: 'const Temporal *', box: 'void *') -> None: - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('void *', box) - _lib.temporal_set_bbox(temp_converted, box_converted) +def inter_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "STBox *": + box1_converted = _ffi.cast("const STBox *", box1) + box2_converted = _ffi.cast("const STBox *", box2) + out_result = _ffi.new("STBox *") + result = _lib.inter_stbox_stbox(box1_converted, box2_converted, out_result) _check_error() + if result: + return out_result if out_result != _ffi.NULL else None + return None -def tfloatseq_derivative(seq: 'const TSequence *') -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tfloatseq_derivative(seq_converted) +def inter_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "TBox *": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) + out_result = _ffi.new("TBox *") + result = _lib.inter_tbox_tbox(box1_converted, box2_converted, out_result) _check_error() - return result if result != _ffi.NULL else None + if result: + return out_result if out_result != _ffi.NULL else None + return None -def tfloatseqset_derivative(ss: 'const TSequenceSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tfloatseqset_derivative(ss_converted) +def geoarr_as_text( + geoarr: "const Datum *", count: int, maxdd: int, extended: bool +) -> "char **": + geoarr_converted = _ffi.cast("const Datum *", geoarr) + result = _lib.geoarr_as_text(geoarr_converted, count, maxdd, extended) _check_error() return result if result != _ffi.NULL else None -def tnumber_set_span(temp: 'const Temporal *', span: 'Span *') -> None: - temp_converted = _ffi.cast('const Temporal *', temp) - span_converted = _ffi.cast('Span *', span) - _lib.tnumber_set_span(temp_converted, span_converted) +def tboolinst_as_mfjson(inst: "const TInstant *", with_bbox: bool) -> str: + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.tboolinst_as_mfjson(inst_converted, with_bbox) _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None -def temporal_start_value(temp: 'const Temporal *') -> 'Datum': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_start_value(temp_converted) +def tboolinst_from_mfjson(mfjson: "json_object *") -> "TInstant *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + result = _lib.tboolinst_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberinst_abs(inst: 'const TInstant *') -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.tnumberinst_abs(inst_converted) +def tboolinst_in(string: str) -> "TInstant *": + string_converted = string.encode("utf-8") + result = _lib.tboolinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_abs(seq: 'const TSequence *') -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tnumberseq_abs(seq_converted) +def tboolseq_as_mfjson(seq: "const TSequence *", with_bbox: bool) -> str: + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tboolseq_as_mfjson(seq_converted, with_bbox) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tnumberseqset_abs(ss: 'const TSequenceSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tnumberseqset_abs(ss_converted) +def tboolseq_from_mfjson(mfjson: "json_object *") -> "TSequence *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + result = _lib.tboolseq_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_angular_difference(seq: 'const TSequence *') -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tnumberseq_angular_difference(seq_converted) +def tboolseq_in(string: str, interp: "interpType") -> "TSequence *": + string_converted = string.encode("utf-8") + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tboolseq_in(string_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_angular_difference(ss: 'const TSequenceSet *') -> 'TSequence *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tnumberseqset_angular_difference(ss_converted) +def tboolseqset_as_mfjson(ss: "const TSequenceSet *", with_bbox: bool) -> str: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tboolseqset_as_mfjson(ss_converted, with_bbox) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tnumberseq_delta_value(seq: 'const TSequence *') -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tnumberseq_delta_value(seq_converted) +def tboolseqset_from_mfjson(mfjson: "json_object *") -> "TSequenceSet *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + result = _lib.tboolseqset_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_delta_value(ss: 'const TSequenceSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tnumberseqset_delta_value(ss_converted) +def tboolseqset_in(string: str) -> "TSequenceSet *": + string_converted = string.encode("utf-8") + result = _lib.tboolseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberinst_valuespans(inst: 'const TInstant *') -> 'SpanSet *': - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.tnumberinst_valuespans(inst_converted) +def temporal_in(string: str, temptype: "meosType") -> "Temporal *": + string_converted = string.encode("utf-8") + temptype_converted = _ffi.cast("meosType", temptype) + result = _lib.temporal_in(string_converted, temptype_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_valuespans(seq: 'const TSequence *') -> 'SpanSet *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tnumberseq_valuespans(seq_converted) +def temporal_out(temp: "const Temporal *", maxdd: int) -> str: + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_out(temp_converted, maxdd) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tnumberseqset_valuespans(ss: 'const TSequenceSet *') -> 'SpanSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tnumberseqset_valuespans(ss_converted) +def temparr_out(temparr: "const Temporal **", count: int, maxdd: int) -> "char **": + temparr_converted = [_ffi.cast("const Temporal *", x) for x in temparr] + result = _lib.temparr_out(temparr_converted, count, maxdd) _check_error() return result if result != _ffi.NULL else None -def tinstant_hash(inst: 'const TInstant *') -> 'uint32': - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.tinstant_hash(inst_converted) +def tfloatinst_as_mfjson( + inst: "const TInstant *", with_bbox: bool, precision: int +) -> str: + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.tfloatinst_as_mfjson(inst_converted, with_bbox, precision) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tinstant_instants(inst: 'const TInstant *') -> "Tuple['const TInstant **', 'int']": - inst_converted = _ffi.cast('const TInstant *', inst) - count = _ffi.new('int *') - result = _lib.tinstant_instants(inst_converted, count) +def tfloatinst_from_mfjson(mfjson: "json_object *") -> "TInstant *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + result = _lib.tfloatinst_from_mfjson(mfjson_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tinstant_set_bbox(inst: 'const TInstant *', box: 'void *') -> None: - inst_converted = _ffi.cast('const TInstant *', inst) - box_converted = _ffi.cast('void *', box) - _lib.tinstant_set_bbox(inst_converted, box_converted) +def tfloatinst_in(string: str) -> "TInstant *": + string_converted = string.encode("utf-8") + result = _lib.tfloatinst_in(string_converted) _check_error() + return result if result != _ffi.NULL else None -def tinstant_time(inst: 'const TInstant *') -> 'SpanSet *': - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.tinstant_time(inst_converted) +def tfloatseq_as_mfjson( + seq: "const TSequence *", with_bbox: bool, precision: int +) -> str: + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tfloatseq_as_mfjson(seq_converted, with_bbox, precision) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tinstant_timestamps(inst: 'const TInstant *') -> "Tuple['TimestampTz *', 'int']": - inst_converted = _ffi.cast('const TInstant *', inst) - count = _ffi.new('int *') - result = _lib.tinstant_timestamps(inst_converted, count) +def tfloatseq_from_mfjson( + mfjson: "json_object *", interp: "interpType" +) -> "TSequence *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tfloatseq_from_mfjson(mfjson_converted, interp_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tinstant_value(inst: 'const TInstant *') -> 'Datum': - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.tinstant_value(inst_converted) +def tfloatseq_in(string: str, interp: "interpType") -> "TSequence *": + string_converted = string.encode("utf-8") + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tfloatseq_in(string_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_value_at_timestamptz(inst: 'const TInstant *', t: int) -> 'Datum *': - inst_converted = _ffi.cast('const TInstant *', inst) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('Datum *') - result = _lib.tinstant_value_at_timestamptz(inst_converted, t_converted, out_result) +def tfloatseqset_as_mfjson( + ss: "const TSequenceSet *", with_bbox: bool, precision: int +) -> str: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tfloatseqset_as_mfjson(ss_converted, with_bbox, precision) _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None -def tinstant_value_copy(inst: 'const TInstant *') -> 'Datum': - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.tinstant_value_copy(inst_converted) +def tfloatseqset_from_mfjson( + mfjson: "json_object *", interp: "interpType" +) -> "TSequenceSet *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tfloatseqset_from_mfjson(mfjson_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_values(inst: 'const TInstant *') -> "Tuple['Datum *', 'int']": - inst_converted = _ffi.cast('const TInstant *', inst) - count = _ffi.new('int *') - result = _lib.tinstant_values(inst_converted, count) +def tfloatseqset_in(string: str) -> "TSequenceSet *": + string_converted = string.encode("utf-8") + result = _lib.tfloatseqset_in(string_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tsequence_duration(seq: 'const TSequence *') -> 'Interval *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_duration(seq_converted) +def tgeogpointinst_from_mfjson(mfjson: "json_object *", srid: int) -> "TInstant *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + result = _lib.tgeogpointinst_from_mfjson(mfjson_converted, srid) _check_error() return result if result != _ffi.NULL else None -def tsequence_end_timestamptz(seq: 'const TSequence *') -> 'TimestampTz': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_end_timestamptz(seq_converted) +def tgeogpointinst_in(string: str) -> "TInstant *": + string_converted = string.encode("utf-8") + result = _lib.tgeogpointinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_hash(seq: 'const TSequence *') -> 'uint32': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_hash(seq_converted) +def tgeogpointseq_from_mfjson( + mfjson: "json_object *", srid: int, interp: "interpType" +) -> "TSequence *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tgeogpointseq_from_mfjson(mfjson_converted, srid, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_instants(seq: 'const TSequence *') -> 'const TInstant **': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_instants(seq_converted) +def tgeogpointseq_in(string: str, interp: "interpType") -> "TSequence *": + string_converted = string.encode("utf-8") + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tgeogpointseq_in(string_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_max_instant(seq: 'const TSequence *') -> 'const TInstant *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_max_instant(seq_converted) +def tgeogpointseqset_from_mfjson( + mfjson: "json_object *", srid: int, interp: "interpType" +) -> "TSequenceSet *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tgeogpointseqset_from_mfjson(mfjson_converted, srid, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_max_value(seq: 'const TSequence *') -> 'Datum': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_max_value(seq_converted) +def tgeogpointseqset_in(string: str) -> "TSequenceSet *": + string_converted = string.encode("utf-8") + result = _lib.tgeogpointseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_min_instant(seq: 'const TSequence *') -> 'const TInstant *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_min_instant(seq_converted) +def tgeompointinst_from_mfjson(mfjson: "json_object *", srid: int) -> "TInstant *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + result = _lib.tgeompointinst_from_mfjson(mfjson_converted, srid) _check_error() return result if result != _ffi.NULL else None -def tsequence_min_value(seq: 'const TSequence *') -> 'Datum': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_min_value(seq_converted) +def tgeompointinst_in(string: str) -> "TInstant *": + string_converted = string.encode("utf-8") + result = _lib.tgeompointinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_segments(seq: 'const TSequence *') -> "Tuple['TSequence **', 'int']": - seq_converted = _ffi.cast('const TSequence *', seq) - count = _ffi.new('int *') - result = _lib.tsequence_segments(seq_converted, count) +def tgeompointseq_from_mfjson( + mfjson: "json_object *", srid: int, interp: "interpType" +) -> "TSequence *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tgeompointseq_from_mfjson(mfjson_converted, srid, interp_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tsequence_sequences(seq: 'const TSequence *') -> "Tuple['TSequence **', 'int']": - seq_converted = _ffi.cast('const TSequence *', seq) - count = _ffi.new('int *') - result = _lib.tsequence_sequences(seq_converted, count) +def tgeompointseq_in(string: str, interp: "interpType") -> "TSequence *": + string_converted = string.encode("utf-8") + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tgeompointseq_in(string_converted, interp_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tsequence_set_bbox(seq: 'const TSequence *', box: 'void *') -> None: - seq_converted = _ffi.cast('const TSequence *', seq) - box_converted = _ffi.cast('void *', box) - _lib.tsequence_set_bbox(seq_converted, box_converted) +def tgeompointseqset_from_mfjson( + mfjson: "json_object *", srid: int, interp: "interpType" +) -> "TSequenceSet *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tgeompointseqset_from_mfjson(mfjson_converted, srid, interp_converted) _check_error() + return result if result != _ffi.NULL else None -def tsequence_expand_bbox(seq: 'TSequence *', inst: 'const TInstant *') -> None: - seq_converted = _ffi.cast('TSequence *', seq) - inst_converted = _ffi.cast('const TInstant *', inst) - _lib.tsequence_expand_bbox(seq_converted, inst_converted) +def tgeompointseqset_in(string: str) -> "TSequenceSet *": + string_converted = string.encode("utf-8") + result = _lib.tgeompointseqset_in(string_converted) _check_error() + return result if result != _ffi.NULL else None -def tsequenceset_expand_bbox(ss: 'TSequenceSet *', seq: 'const TSequence *') -> None: - ss_converted = _ffi.cast('TSequenceSet *', ss) - seq_converted = _ffi.cast('const TSequence *', seq) - _lib.tsequenceset_expand_bbox(ss_converted, seq_converted) +def tinstant_as_mfjson( + inst: "const TInstant *", with_bbox: bool, precision: int, srs: str +) -> str: + inst_converted = _ffi.cast("const TInstant *", inst) + srs_converted = srs.encode("utf-8") + result = _lib.tinstant_as_mfjson( + inst_converted, with_bbox, precision, srs_converted + ) _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None -def tsequence_start_timestamptz(seq: 'const TSequence *') -> 'TimestampTz': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_start_timestamptz(seq_converted) +def tinstant_from_mfjson( + mfjson: "json_object *", isgeo: bool, srid: int, temptype: "meosType" +) -> "TInstant *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + temptype_converted = _ffi.cast("meosType", temptype) + result = _lib.tinstant_from_mfjson( + mfjson_converted, isgeo, srid, temptype_converted + ) _check_error() return result if result != _ffi.NULL else None -def tsequence_time(seq: 'const TSequence *') -> 'SpanSet *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_time(seq_converted) +def tinstant_in(string: str, temptype: "meosType") -> "TInstant *": + string_converted = string.encode("utf-8") + temptype_converted = _ffi.cast("meosType", temptype) + result = _lib.tinstant_in(string_converted, temptype_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_timestamps(seq: 'const TSequence *') -> "Tuple['TimestampTz *', 'int']": - seq_converted = _ffi.cast('const TSequence *', seq) - count = _ffi.new('int *') - result = _lib.tsequence_timestamps(seq_converted, count) +def tinstant_out(inst: "const TInstant *", maxdd: int) -> str: + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.tinstant_out(inst_converted, maxdd) _check_error() - return result if result != _ffi.NULL else None, count[0] + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None -def tsequence_value_at_timestamptz(seq: 'const TSequence *', t: int, strict: bool) -> 'Datum *': - seq_converted = _ffi.cast('const TSequence *', seq) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('Datum *') - result = _lib.tsequence_value_at_timestamptz(seq_converted, t_converted, strict, out_result) +def tintinst_as_mfjson(inst: "const TInstant *", with_bbox: bool) -> str: + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.tintinst_as_mfjson(inst_converted, with_bbox) _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None -def tsequence_values(seq: 'const TSequence *') -> "Tuple['Datum *', 'int']": - seq_converted = _ffi.cast('const TSequence *', seq) - count = _ffi.new('int *') - result = _lib.tsequence_values(seq_converted, count) +def tintinst_from_mfjson(mfjson: "json_object *") -> "TInstant *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + result = _lib.tintinst_from_mfjson(mfjson_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tsequenceset_duration(ss: 'const TSequenceSet *', boundspan: bool) -> 'Interval *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_duration(ss_converted, boundspan) +def tintinst_in(string: str) -> "TInstant *": + string_converted = string.encode("utf-8") + result = _lib.tintinst_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_end_timestamptz(ss: 'const TSequenceSet *') -> 'TimestampTz': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_end_timestamptz(ss_converted) +def tintseq_as_mfjson(seq: "const TSequence *", with_bbox: bool) -> str: + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tintseq_as_mfjson(seq_converted, with_bbox) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tsequenceset_hash(ss: 'const TSequenceSet *') -> 'uint32': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_hash(ss_converted) +def tintseq_from_mfjson(mfjson: "json_object *") -> "TSequence *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + result = _lib.tintseq_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_inst_n(ss: 'const TSequenceSet *', n: int) -> 'const TInstant *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_inst_n(ss_converted, n) +def tintseq_in(string: str, interp: "interpType") -> "TSequence *": + string_converted = string.encode("utf-8") + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tintseq_in(string_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_instants(ss: 'const TSequenceSet *') -> 'const TInstant **': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_instants(ss_converted) +def tintseqset_as_mfjson(ss: "const TSequenceSet *", with_bbox: bool) -> str: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tintseqset_as_mfjson(ss_converted, with_bbox) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tsequenceset_max_instant(ss: 'const TSequenceSet *') -> 'const TInstant *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_max_instant(ss_converted) +def tintseqset_from_mfjson(mfjson: "json_object *") -> "TSequenceSet *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + result = _lib.tintseqset_from_mfjson(mfjson_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_max_value(ss: 'const TSequenceSet *') -> 'Datum': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_max_value(ss_converted) +def tintseqset_in(string: str) -> "TSequenceSet *": + string_converted = string.encode("utf-8") + result = _lib.tintseqset_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_min_instant(ss: 'const TSequenceSet *') -> 'const TInstant *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_min_instant(ss_converted) +def tpointarr_as_text( + temparr: "const Temporal **", count: int, maxdd: int, extended: bool +) -> "char **": + temparr_converted = [_ffi.cast("const Temporal *", x) for x in temparr] + result = _lib.tpointarr_as_text(temparr_converted, count, maxdd, extended) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_min_value(ss: 'const TSequenceSet *') -> 'Datum': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_min_value(ss_converted) +def tpointinst_as_mfjson( + inst: "const TInstant *", with_bbox: bool, precision: int, srs: str +) -> str: + inst_converted = _ffi.cast("const TInstant *", inst) + srs_converted = srs.encode("utf-8") + result = _lib.tpointinst_as_mfjson( + inst_converted, with_bbox, precision, srs_converted + ) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tsequenceset_num_instants(ss: 'const TSequenceSet *') -> 'int': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_num_instants(ss_converted) +def tpointseq_as_mfjson( + seq: "const TSequence *", with_bbox: bool, precision: int, srs: str +) -> str: + seq_converted = _ffi.cast("const TSequence *", seq) + srs_converted = srs.encode("utf-8") + result = _lib.tpointseq_as_mfjson( + seq_converted, with_bbox, precision, srs_converted + ) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tsequenceset_num_timestamps(ss: 'const TSequenceSet *') -> 'int': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_num_timestamps(ss_converted) +def tpointseqset_as_mfjson( + ss: "const TSequenceSet *", with_bbox: bool, precision: int, srs: str +) -> str: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + srs_converted = srs.encode("utf-8") + result = _lib.tpointseqset_as_mfjson( + ss_converted, with_bbox, precision, srs_converted + ) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tsequenceset_segments(ss: 'const TSequenceSet *') -> "Tuple['TSequence **', 'int']": - ss_converted = _ffi.cast('const TSequenceSet *', ss) - count = _ffi.new('int *') - result = _lib.tsequenceset_segments(ss_converted, count) +def tsequence_as_mfjson( + seq: "const TSequence *", with_bbox: bool, precision: int, srs: str +) -> str: + seq_converted = _ffi.cast("const TSequence *", seq) + srs_converted = srs.encode("utf-8") + result = _lib.tsequence_as_mfjson( + seq_converted, with_bbox, precision, srs_converted + ) _check_error() - return result if result != _ffi.NULL else None, count[0] + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None -def tsequenceset_sequences(ss: 'const TSequenceSet *') -> 'TSequence **': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_sequences(ss_converted) +def tsequence_from_mfjson( + mfjson: "json_object *", + isgeo: bool, + srid: int, + temptype: "meosType", + interp: "interpType", +) -> "TSequence *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + temptype_converted = _ffi.cast("meosType", temptype) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tsequence_from_mfjson( + mfjson_converted, isgeo, srid, temptype_converted, interp_converted + ) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_sequences_p(ss: 'const TSequenceSet *') -> 'const TSequence **': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_sequences_p(ss_converted) +def tsequence_in( + string: str, temptype: "meosType", interp: "interpType" +) -> "TSequence *": + string_converted = string.encode("utf-8") + temptype_converted = _ffi.cast("meosType", temptype) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tsequence_in(string_converted, temptype_converted, interp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_set_bbox(ss: 'const TSequenceSet *', box: 'void *') -> None: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - box_converted = _ffi.cast('void *', box) - _lib.tsequenceset_set_bbox(ss_converted, box_converted) +def tsequence_out(seq: "const TSequence *", maxdd: int) -> str: + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_out(seq_converted, maxdd) _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None -def tsequenceset_start_timestamptz(ss: 'const TSequenceSet *') -> 'TimestampTz': - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_as_mfjson( + ss: "const TSequenceSet *", with_bbox: bool, precision: int, srs: str +) -> str: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + srs_converted = srs.encode("utf-8") + result = _lib.tsequenceset_as_mfjson( + ss_converted, with_bbox, precision, srs_converted + ) + _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None + + +def tsequenceset_from_mfjson( + mfjson: "json_object *", + isgeo: bool, + srid: int, + temptype: "meosType", + interp: "interpType", +) -> "TSequenceSet *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + temptype_converted = _ffi.cast("meosType", temptype) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tsequenceset_from_mfjson( + mfjson_converted, isgeo, srid, temptype_converted, interp_converted + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_in( + string: str, temptype: "meosType", interp: "interpType" +) -> "TSequenceSet *": + string_converted = string.encode("utf-8") + temptype_converted = _ffi.cast("meosType", temptype) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tsequenceset_in( + string_converted, temptype_converted, interp_converted + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_out(ss: "const TSequenceSet *", maxdd: int) -> str: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_out(ss_converted, maxdd) + _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None + + +def ttextinst_as_mfjson(inst: "const TInstant *", with_bbox: bool) -> str: + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.ttextinst_as_mfjson(inst_converted, with_bbox) + _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None + + +def ttextinst_from_mfjson(mfjson: "json_object *") -> "TInstant *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + result = _lib.ttextinst_from_mfjson(mfjson_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def ttextinst_in(string: str) -> "TInstant *": + string_converted = string.encode("utf-8") + result = _lib.ttextinst_in(string_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def ttextseq_as_mfjson(seq: "const TSequence *", with_bbox: bool) -> str: + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.ttextseq_as_mfjson(seq_converted, with_bbox) + _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None + + +def ttextseq_from_mfjson(mfjson: "json_object *") -> "TSequence *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + result = _lib.ttextseq_from_mfjson(mfjson_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def ttextseq_in(string: str, interp: "interpType") -> "TSequence *": + string_converted = string.encode("utf-8") + interp_converted = _ffi.cast("interpType", interp) + result = _lib.ttextseq_in(string_converted, interp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def ttextseqset_as_mfjson(ss: "const TSequenceSet *", with_bbox: bool) -> str: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.ttextseqset_as_mfjson(ss_converted, with_bbox) + _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None + + +def ttextseqset_from_mfjson(mfjson: "json_object *") -> "TSequenceSet *": + mfjson_converted = _ffi.cast("json_object *", mfjson) + result = _lib.ttextseqset_from_mfjson(mfjson_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def ttextseqset_in(string: str) -> "TSequenceSet *": + string_converted = string.encode("utf-8") + result = _lib.ttextseqset_in(string_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_cp(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_cp(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_from_base_temp( + value: "Datum", temptype: "meosType", temp: "const Temporal *" +) -> "Temporal *": + value_converted = _ffi.cast("Datum", value) + temptype_converted = _ffi.cast("meosType", temptype) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_from_base_temp( + value_converted, temptype_converted, temp_converted + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tinstant_copy(inst: "const TInstant *") -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.tinstant_copy(inst_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tinstant_make(value: "Datum", temptype: "meosType", t: int) -> "TInstant *": + value_converted = _ffi.cast("Datum", value) + temptype_converted = _ffi.cast("meosType", temptype) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tinstant_make(value_converted, temptype_converted, t_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tpointseq_make_coords( + xcoords: "const double *", + ycoords: "const double *", + zcoords: "const double *", + times: int, + count: int, + srid: int, + geodetic: bool, + lower_inc: bool, + upper_inc: bool, + interp: "interpType", + normalize: bool, +) -> "TSequence *": + xcoords_converted = _ffi.cast("const double *", xcoords) + ycoords_converted = _ffi.cast("const double *", ycoords) + zcoords_converted = _ffi.cast("const double *", zcoords) + times_converted = _ffi.cast("const TimestampTz *", times) + srid_converted = _ffi.cast("int32", srid) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tpointseq_make_coords( + xcoords_converted, + ycoords_converted, + zcoords_converted, + times_converted, + count, + srid_converted, + geodetic, + lower_inc, + upper_inc, + interp_converted, + normalize, + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_copy(seq: "const TSequence *") -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_copy(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_from_base_tstzset( + value: "Datum", temptype: "meosType", ss: "const Set *" +) -> "TSequence *": + value_converted = _ffi.cast("Datum", value) + temptype_converted = _ffi.cast("meosType", temptype) + ss_converted = _ffi.cast("const Set *", ss) + result = _lib.tsequence_from_base_tstzset( + value_converted, temptype_converted, ss_converted + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_from_base_tstzspan( + value: "Datum", temptype: "meosType", s: "const Span *", interp: "interpType" +) -> "TSequence *": + value_converted = _ffi.cast("Datum", value) + temptype_converted = _ffi.cast("meosType", temptype) + s_converted = _ffi.cast("const Span *", s) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tsequence_from_base_tstzspan( + value_converted, temptype_converted, s_converted, interp_converted + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_make_exp( + instants: "const TInstant **", + count: int, + maxcount: int, + lower_inc: bool, + upper_inc: bool, + interp: "interpType", + normalize: bool, +) -> "TSequence *": + instants_converted = [_ffi.cast("const TInstant *", x) for x in instants] + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tsequence_make_exp( + instants_converted, + count, + maxcount, + lower_inc, + upper_inc, + interp_converted, + normalize, + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_make_free( + instants: "TInstant **", + count: int, + lower_inc: bool, + upper_inc: bool, + interp: "interpType", + normalize: bool, +) -> "TSequence *": + instants_converted = [_ffi.cast("TInstant *", x) for x in instants] + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tsequence_make_free( + instants_converted, count, lower_inc, upper_inc, interp_converted, normalize + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_copy(ss: "const TSequenceSet *") -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_copy(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tseqsetarr_to_tseqset( + seqsets: "TSequenceSet **", count: int, totalseqs: int +) -> "TSequenceSet *": + seqsets_converted = [_ffi.cast("TSequenceSet *", x) for x in seqsets] + result = _lib.tseqsetarr_to_tseqset(seqsets_converted, count, totalseqs) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_from_base_tstzspanset( + value: "Datum", temptype: "meosType", ss: "const SpanSet *", interp: "interpType" +) -> "TSequenceSet *": + value_converted = _ffi.cast("Datum", value) + temptype_converted = _ffi.cast("meosType", temptype) + ss_converted = _ffi.cast("const SpanSet *", ss) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tsequenceset_from_base_tstzspanset( + value_converted, temptype_converted, ss_converted, interp_converted + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_make_exp( + sequences: "const TSequence **", count: int, maxcount: int, normalize: bool +) -> "TSequenceSet *": + sequences_converted = [_ffi.cast("const TSequence *", x) for x in sequences] + result = _lib.tsequenceset_make_exp(sequences_converted, count, maxcount, normalize) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_make_free( + sequences: "TSequence **", count: int, normalize: bool +) -> "TSequenceSet *": + sequences_converted = [_ffi.cast("TSequence *", x) for x in sequences] + result = _lib.tsequenceset_make_free(sequences_converted, count, normalize) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_set_tstzspan(temp: "const Temporal *", s: "Span *") -> None: + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("Span *", s) + _lib.temporal_set_tstzspan(temp_converted, s_converted) + _check_error() + + +def tinstant_set_tstzspan(inst: "const TInstant *", s: "Span *") -> None: + inst_converted = _ffi.cast("const TInstant *", inst) + s_converted = _ffi.cast("Span *", s) + _lib.tinstant_set_tstzspan(inst_converted, s_converted) + _check_error() + + +def tnumber_span(temp: "const Temporal *") -> "Span *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tnumber_span(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_set_tstzspan(seq: "const TSequence *", s: "Span *") -> None: + seq_converted = _ffi.cast("const TSequence *", seq) + s_converted = _ffi.cast("Span *", s) + _lib.tsequence_set_tstzspan(seq_converted, s_converted) + _check_error() + + +def tsequenceset_set_tstzspan(ss: "const TSequenceSet *", s: "Span *") -> None: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + s_converted = _ffi.cast("Span *", s) + _lib.tsequenceset_set_tstzspan(ss_converted, s_converted) + _check_error() + + +def temporal_end_value(temp: "const Temporal *") -> "Datum": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_end_value(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_insts(temp: "const Temporal *") -> "Tuple['const TInstant **', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") + result = _lib.temporal_insts(temp_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def temporal_max_value(temp: "const Temporal *") -> "Datum": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_max_value(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_mem_size(temp: "const Temporal *") -> "size_t": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_mem_size(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_min_value(temp: "const Temporal *") -> "Datum": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_min_value(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_seqs(temp: "const Temporal *") -> "Tuple['const TSequence **', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") + result = _lib.temporal_seqs(temp_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def temporal_set_bbox(temp: "const Temporal *", box: "void *") -> None: + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("void *", box) + _lib.temporal_set_bbox(temp_converted, box_converted) + _check_error() + + +def temporal_set_tstzspan(temp: "const Temporal *", s: "Span *") -> None: + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("Span *", s) + _lib.temporal_set_tstzspan(temp_converted, s_converted) + _check_error() + + +def temporal_seqs(temp: "const Temporal *") -> "Tuple['const TSequence **', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") + result = _lib.temporal_seqs(temp_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def temporal_vals(temp: "const Temporal *") -> "Tuple['Datum *', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") + result = _lib.temporal_vals(temp_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def temporal_values(temp: "const Temporal *") -> "Tuple['Datum *', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + count = _ffi.new("int *") + result = _lib.temporal_values(temp_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def tinstant_hash(inst: "const TInstant *") -> "uint32": + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.tinstant_hash(inst_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tinstant_insts(inst: "const TInstant *") -> "Tuple['const TInstant **', 'int']": + inst_converted = _ffi.cast("const TInstant *", inst) + count = _ffi.new("int *") + result = _lib.tinstant_insts(inst_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def tinstant_set_bbox(inst: "const TInstant *", box: "void *") -> None: + inst_converted = _ffi.cast("const TInstant *", inst) + box_converted = _ffi.cast("void *", box) + _lib.tinstant_set_bbox(inst_converted, box_converted) + _check_error() + + +def tinstant_set_tstzspan(inst: "const TInstant *", s: "Span *") -> None: + inst_converted = _ffi.cast("const TInstant *", inst) + s_converted = _ffi.cast("Span *", s) + _lib.tinstant_set_tstzspan(inst_converted, s_converted) + _check_error() + + +def tinstant_time(inst: "const TInstant *") -> "SpanSet *": + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.tinstant_time(inst_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tinstant_timestamps(inst: "const TInstant *") -> "Tuple['TimestampTz *', 'int']": + inst_converted = _ffi.cast("const TInstant *", inst) + count = _ffi.new("int *") + result = _lib.tinstant_timestamps(inst_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def tinstant_val(inst: "const TInstant *") -> "Datum": + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.tinstant_val(inst_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tinstant_value(inst: "const TInstant *") -> "Datum": + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.tinstant_value(inst_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tinstant_value_at_timestamptz(inst: "const TInstant *", t: int) -> "Datum *": + inst_converted = _ffi.cast("const TInstant *", inst) + t_converted = _ffi.cast("TimestampTz", t) + out_result = _ffi.new("Datum *") + result = _lib.tinstant_value_at_timestamptz(inst_converted, t_converted, out_result) + _check_error() + if result: + return out_result if out_result != _ffi.NULL else None + return None + + +def tinstant_vals(inst: "const TInstant *") -> "Tuple['Datum *', 'int']": + inst_converted = _ffi.cast("const TInstant *", inst) + count = _ffi.new("int *") + result = _lib.tinstant_vals(inst_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def tnumber_set_span(temp: "const Temporal *", span: "Span *") -> None: + temp_converted = _ffi.cast("const Temporal *", temp) + span_converted = _ffi.cast("Span *", span) + _lib.tnumber_set_span(temp_converted, span_converted) + _check_error() + + +def tnumberinst_valuespans(inst: "const TInstant *") -> "SpanSet *": + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.tnumberinst_valuespans(inst_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tnumberseq_valuespans(seq: "const TSequence *") -> "SpanSet *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tnumberseq_valuespans(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tnumberseqset_valuespans(ss: "const TSequenceSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tnumberseqset_valuespans(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_duration(seq: "const TSequence *") -> "Interval *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_duration(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_end_timestamptz(seq: "const TSequence *") -> "TimestampTz": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_end_timestamptz(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_hash(seq: "const TSequence *") -> "uint32": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_hash(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_insts(seq: "const TSequence *") -> "const TInstant **": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_insts(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_max_inst(seq: "const TSequence *") -> "const TInstant *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_max_inst(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_max_val(seq: "const TSequence *") -> "Datum": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_max_val(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_min_inst(seq: "const TSequence *") -> "const TInstant *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_min_inst(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_min_val(seq: "const TSequence *") -> "Datum": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_min_val(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_segments(seq: "const TSequence *") -> "Tuple['TSequence **', 'int']": + seq_converted = _ffi.cast("const TSequence *", seq) + count = _ffi.new("int *") + result = _lib.tsequence_segments(seq_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def tsequence_seqs(seq: "const TSequence *") -> "Tuple['const TSequence **', 'int']": + seq_converted = _ffi.cast("const TSequence *", seq) + count = _ffi.new("int *") + result = _lib.tsequence_seqs(seq_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def tsequence_set_bbox(seq: "const TSequence *", box: "void *") -> None: + seq_converted = _ffi.cast("const TSequence *", seq) + box_converted = _ffi.cast("void *", box) + _lib.tsequence_set_bbox(seq_converted, box_converted) + _check_error() + + +def tsequence_expand_bbox(seq: "TSequence *", inst: "const TInstant *") -> None: + seq_converted = _ffi.cast("TSequence *", seq) + inst_converted = _ffi.cast("const TInstant *", inst) + _lib.tsequence_expand_bbox(seq_converted, inst_converted) + _check_error() + + +def tsequence_start_timestamptz(seq: "const TSequence *") -> "TimestampTz": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_start_timestamptz(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_time(seq: "const TSequence *") -> "SpanSet *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_time(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_timestamps(seq: "const TSequence *") -> "Tuple['TimestampTz *', 'int']": + seq_converted = _ffi.cast("const TSequence *", seq) + count = _ffi.new("int *") + result = _lib.tsequence_timestamps(seq_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def tsequence_value_at_timestamptz( + seq: "const TSequence *", t: int, strict: bool +) -> "Datum *": + seq_converted = _ffi.cast("const TSequence *", seq) + t_converted = _ffi.cast("TimestampTz", t) + out_result = _ffi.new("Datum *") + result = _lib.tsequence_value_at_timestamptz( + seq_converted, t_converted, strict, out_result + ) + _check_error() + if result: + return out_result if out_result != _ffi.NULL else None + return None + + +def tsequence_vals(seq: "const TSequence *") -> "Tuple['Datum *', 'int']": + seq_converted = _ffi.cast("const TSequence *", seq) + count = _ffi.new("int *") + result = _lib.tsequence_vals(seq_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def tsequenceset_duration(ss: "const TSequenceSet *", boundspan: bool) -> "Interval *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_duration(ss_converted, boundspan) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_end_timestamptz(ss: "const TSequenceSet *") -> "TimestampTz": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_end_timestamptz(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_hash(ss: "const TSequenceSet *") -> "uint32": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_hash(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_inst_n(ss: "const TSequenceSet *", n: int) -> "const TInstant *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_inst_n(ss_converted, n) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_insts(ss: "const TSequenceSet *") -> "const TInstant **": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_insts(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_max_inst(ss: "const TSequenceSet *") -> "const TInstant *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_max_inst(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_max_val(ss: "const TSequenceSet *") -> "Datum": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_max_val(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_min_inst(ss: "const TSequenceSet *") -> "const TInstant *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_min_inst(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_min_val(ss: "const TSequenceSet *") -> "Datum": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_min_val(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_num_instants(ss: "const TSequenceSet *") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_num_instants(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_num_timestamps(ss: "const TSequenceSet *") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_num_timestamps(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_segments(ss: "const TSequenceSet *") -> "Tuple['TSequence **', 'int']": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + count = _ffi.new("int *") + result = _lib.tsequenceset_segments(ss_converted, count) + _check_error() + return result if result != _ffi.NULL else None, count[0] + + +def tsequenceset_seqs(ss: "const TSequenceSet *") -> "const TSequence **": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_seqs(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_set_bbox(ss: "const TSequenceSet *", box: "void *") -> None: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + box_converted = _ffi.cast("void *", box) + _lib.tsequenceset_set_bbox(ss_converted, box_converted) + _check_error() + + +def tsequenceset_start_timestamptz(ss: "const TSequenceSet *") -> "TimestampTz": + ss_converted = _ffi.cast("const TSequenceSet *", ss) result = _lib.tsequenceset_start_timestamptz(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_time(ss: 'const TSequenceSet *') -> 'SpanSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_time(ss: "const TSequenceSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) result = _lib.tsequenceset_time(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_timespan(ss: 'const TSequenceSet *') -> 'Interval *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) +def tsequenceset_timespan(ss: "const TSequenceSet *") -> "Interval *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) result = _lib.tsequenceset_timespan(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_timestamptz_n(ss: 'const TSequenceSet *', n: int) -> int: - ss_converted = _ffi.cast('const TSequenceSet *', ss) - out_result = _ffi.new('TimestampTz *') +def tsequenceset_timestamptz_n(ss: "const TSequenceSet *", n: int) -> int: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + out_result = _ffi.new("TimestampTz *") result = _lib.tsequenceset_timestamptz_n(ss_converted, n, out_result) _check_error() if result: @@ -13303,1486 +15340,2048 @@ def tsequenceset_timestamptz_n(ss: 'const TSequenceSet *', n: int) -> int: return None -def tsequenceset_timestamps(ss: 'const TSequenceSet *') -> "Tuple['TimestampTz *', 'int']": - ss_converted = _ffi.cast('const TSequenceSet *', ss) - count = _ffi.new('int *') +def tsequenceset_timestamps( + ss: "const TSequenceSet *", +) -> "Tuple['TimestampTz *', 'int']": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + count = _ffi.new("int *") result = _lib.tsequenceset_timestamps(ss_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tsequenceset_value_at_timestamptz(ss: 'const TSequenceSet *', t: int, strict: bool) -> 'Datum *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('Datum *') - result = _lib.tsequenceset_value_at_timestamptz(ss_converted, t_converted, strict, out_result) +def tsequenceset_value_at_timestamptz( + ss: "const TSequenceSet *", t: int, strict: bool +) -> "Datum *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + out_result = _ffi.new("Datum *") + result = _lib.tsequenceset_value_at_timestamptz( + ss_converted, t_converted, strict, out_result + ) _check_error() if result: return out_result if out_result != _ffi.NULL else None return None -def tsequenceset_values(ss: 'const TSequenceSet *') -> "Tuple['Datum *', 'int']": - ss_converted = _ffi.cast('const TSequenceSet *', ss) - count = _ffi.new('int *') - result = _lib.tsequenceset_values(ss_converted, count) +def tsequenceset_vals(ss: "const TSequenceSet *") -> "Tuple['Datum *', 'int']": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + count = _ffi.new("int *") + result = _lib.tsequenceset_vals(ss_converted, count) _check_error() return result if result != _ffi.NULL else None, count[0] -def tinstant_merge(inst1: 'const TInstant *', inst2: 'const TInstant *') -> 'Temporal *': - inst1_converted = _ffi.cast('const TInstant *', inst1) - inst2_converted = _ffi.cast('const TInstant *', inst2) +def temporal_compact(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_compact(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_restart(temp: "Temporal *", count: int) -> None: + temp_converted = _ffi.cast("Temporal *", temp) + _lib.temporal_restart(temp_converted, count) + _check_error() + + +def temporal_tsequence(temp: "const Temporal *", interp: "interpType") -> "TSequence *": + temp_converted = _ffi.cast("const Temporal *", temp) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.temporal_tsequence(temp_converted, interp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def temporal_tsequenceset( + temp: "const Temporal *", interp: "interpType" +) -> "TSequenceSet *": + temp_converted = _ffi.cast("const Temporal *", temp) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.temporal_tsequenceset(temp_converted, interp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tinstant_shift_time( + inst: "const TInstant *", interv: "const Interval *" +) -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + interv_converted = _ffi.cast("const Interval *", interv) + result = _lib.tinstant_shift_time(inst_converted, interv_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tinstant_to_tsequence( + inst: "const TInstant *", interp: "interpType" +) -> "TSequence *": + inst_converted = _ffi.cast("const TInstant *", inst) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tinstant_to_tsequence(inst_converted, interp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tinstant_to_tsequenceset( + inst: "const TInstant *", interp: "interpType" +) -> "TSequenceSet *": + inst_converted = _ffi.cast("const TInstant *", inst) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tinstant_to_tsequenceset(inst_converted, interp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tnumber_shift_scale_value( + temp: "const Temporal *", + shift: "Datum", + width: "Datum", + hasshift: bool, + haswidth: bool, +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + shift_converted = _ffi.cast("Datum", shift) + width_converted = _ffi.cast("Datum", width) + result = _lib.tnumber_shift_scale_value( + temp_converted, shift_converted, width_converted, hasshift, haswidth + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tnumberinst_shift_value(inst: "const TInstant *", shift: "Datum") -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + shift_converted = _ffi.cast("Datum", shift) + result = _lib.tnumberinst_shift_value(inst_converted, shift_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tnumberseq_shift_scale_value( + seq: "const TSequence *", + shift: "Datum", + width: "Datum", + hasshift: bool, + haswidth: bool, +) -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + shift_converted = _ffi.cast("Datum", shift) + width_converted = _ffi.cast("Datum", width) + result = _lib.tnumberseq_shift_scale_value( + seq_converted, shift_converted, width_converted, hasshift, haswidth + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tnumberseqset_shift_scale_value( + ss: "const TSequenceSet *", + start: "Datum", + width: "Datum", + hasshift: bool, + haswidth: bool, +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + start_converted = _ffi.cast("Datum", start) + width_converted = _ffi.cast("Datum", width) + result = _lib.tnumberseqset_shift_scale_value( + ss_converted, start_converted, width_converted, hasshift, haswidth + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_compact(seq: "const TSequence *") -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_compact(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_restart(seq: "TSequence *", count: int) -> None: + seq_converted = _ffi.cast("TSequence *", seq) + _lib.tsequence_restart(seq_converted, count) + _check_error() + + +def tsequence_set_interp( + seq: "const TSequence *", interp: "interpType" +) -> "Temporal *": + seq_converted = _ffi.cast("const TSequence *", seq) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tsequence_set_interp(seq_converted, interp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_shift_scale_time( + seq: "const TSequence *", shift: "const Interval *", duration: "const Interval *" +) -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + shift_converted = _ffi.cast("const Interval *", shift) + duration_converted = _ffi.cast("const Interval *", duration) + result = _lib.tsequence_shift_scale_time( + seq_converted, shift_converted, duration_converted + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_subseq( + seq: "const TSequence *", from_: int, to: int, lower_inc: bool, upper_inc: bool +) -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_subseq(seq_converted, from_, to, lower_inc, upper_inc) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_to_tinstant(seq: "const TSequence *") -> "TInstant *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_to_tinstant(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_to_tsequenceset(seq: "const TSequence *") -> "TSequenceSet *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_to_tsequenceset(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_to_tsequenceset_interp( + seq: "const TSequence *", interp: "interpType" +) -> "TSequenceSet *": + seq_converted = _ffi.cast("const TSequence *", seq) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tsequence_to_tsequenceset_interp(seq_converted, interp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_compact(ss: "const TSequenceSet *") -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_compact(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_restart(ss: "TSequenceSet *", count: int) -> None: + ss_converted = _ffi.cast("TSequenceSet *", ss) + _lib.tsequenceset_restart(ss_converted, count) + _check_error() + + +def tsequenceset_set_interp( + ss: "const TSequenceSet *", interp: "interpType" +) -> "Temporal *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tsequenceset_set_interp(ss_converted, interp_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_shift_scale_time( + ss: "const TSequenceSet *", start: "const Interval *", duration: "const Interval *" +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + start_converted = _ffi.cast("const Interval *", start) + duration_converted = _ffi.cast("const Interval *", duration) + result = _lib.tsequenceset_shift_scale_time( + ss_converted, start_converted, duration_converted + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_to_discrete(ss: "const TSequenceSet *") -> "TSequence *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_to_discrete(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_to_linear(ss: "const TSequenceSet *") -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_to_linear(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_to_step(ss: "const TSequenceSet *") -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_to_step(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_to_tinstant(ss: "const TSequenceSet *") -> "TInstant *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_to_tinstant(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_to_tsequence(ss: "const TSequenceSet *") -> "TSequence *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_to_tsequence(ss_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tinstant_merge( + inst1: "const TInstant *", inst2: "const TInstant *" +) -> "Temporal *": + inst1_converted = _ffi.cast("const TInstant *", inst1) + inst2_converted = _ffi.cast("const TInstant *", inst2) result = _lib.tinstant_merge(inst1_converted, inst2_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_merge_array(instants: 'const TInstant **', count: int) -> 'Temporal *': - instants_converted = [_ffi.cast('const TInstant *', x) for x in instants] - result = _lib.tinstant_merge_array(instants_converted, count) +def tinstant_merge_array(instants: "const TInstant **", count: int) -> "Temporal *": + instants_converted = [_ffi.cast("const TInstant *", x) for x in instants] + result = _lib.tinstant_merge_array(instants_converted, count) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_append_tinstant( + seq: "TSequence *", + inst: "const TInstant *", + maxdist: float, + maxt: "const Interval *", + expand: bool, +) -> "Temporal *": + seq_converted = _ffi.cast("TSequence *", seq) + inst_converted = _ffi.cast("const TInstant *", inst) + maxt_converted = _ffi.cast("const Interval *", maxt) + result = _lib.tsequence_append_tinstant( + seq_converted, inst_converted, maxdist, maxt_converted, expand + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_append_tsequence( + seq1: "TSequence *", seq2: "const TSequence *", expand: bool +) -> "Temporal *": + seq1_converted = _ffi.cast("TSequence *", seq1) + seq2_converted = _ffi.cast("const TSequence *", seq2) + result = _lib.tsequence_append_tsequence(seq1_converted, seq2_converted, expand) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_delete_timestamptz( + seq: "const TSequence *", t: int, connect: bool +) -> "Temporal *": + seq_converted = _ffi.cast("const TSequence *", seq) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tsequence_delete_timestamptz(seq_converted, t_converted, connect) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_delete_tstzset( + seq: "const TSequence *", s: "const Set *", connect: bool +) -> "Temporal *": + seq_converted = _ffi.cast("const TSequence *", seq) + s_converted = _ffi.cast("const Set *", s) + result = _lib.tsequence_delete_tstzset(seq_converted, s_converted, connect) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_delete_tstzspan( + seq: "const TSequence *", s: "const Span *", connect: bool +) -> "Temporal *": + seq_converted = _ffi.cast("const TSequence *", seq) + s_converted = _ffi.cast("const Span *", s) + result = _lib.tsequence_delete_tstzspan(seq_converted, s_converted, connect) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_delete_tstzspanset( + seq: "const TSequence *", ss: "const SpanSet *", connect: bool +) -> "Temporal *": + seq_converted = _ffi.cast("const TSequence *", seq) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.tsequence_delete_tstzspanset(seq_converted, ss_converted, connect) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_insert( + seq1: "const TSequence *", seq2: "const TSequence *", connect: bool +) -> "Temporal *": + seq1_converted = _ffi.cast("const TSequence *", seq1) + seq2_converted = _ffi.cast("const TSequence *", seq2) + result = _lib.tsequence_insert(seq1_converted, seq2_converted, connect) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_merge( + seq1: "const TSequence *", seq2: "const TSequence *" +) -> "Temporal *": + seq1_converted = _ffi.cast("const TSequence *", seq1) + seq2_converted = _ffi.cast("const TSequence *", seq2) + result = _lib.tsequence_merge(seq1_converted, seq2_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequence_merge_array(sequences: "const TSequence **", count: int) -> "Temporal *": + sequences_converted = [_ffi.cast("const TSequence *", x) for x in sequences] + result = _lib.tsequence_merge_array(sequences_converted, count) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_append_tinstant( + ss: "TSequenceSet *", + inst: "const TInstant *", + maxdist: float, + maxt: "const Interval *", + expand: bool, +) -> "TSequenceSet *": + ss_converted = _ffi.cast("TSequenceSet *", ss) + inst_converted = _ffi.cast("const TInstant *", inst) + maxt_converted = _ffi.cast("const Interval *", maxt) + result = _lib.tsequenceset_append_tinstant( + ss_converted, inst_converted, maxdist, maxt_converted, expand + ) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_append_tsequence( + ss: "TSequenceSet *", seq: "const TSequence *", expand: bool +) -> "TSequenceSet *": + ss_converted = _ffi.cast("TSequenceSet *", ss) + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequenceset_append_tsequence(ss_converted, seq_converted, expand) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_delete_timestamptz( + ss: "const TSequenceSet *", t: int +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tsequenceset_delete_timestamptz(ss_converted, t_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tsequenceset_delete_tstzset( + ss: "const TSequenceSet *", s: "const Set *" +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + s_converted = _ffi.cast("const Set *", s) + result = _lib.tsequenceset_delete_tstzset(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_shift_time(inst: 'const TInstant *', interval: 'const Interval *') -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - interval_converted = _ffi.cast('const Interval *', interval) - result = _lib.tinstant_shift_time(inst_converted, interval_converted) +def tsequenceset_delete_tstzspan( + ss: "const TSequenceSet *", s: "const Span *" +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.tsequenceset_delete_tstzspan(ss_converted, s_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_to_tsequence(inst: 'const TInstant *', interp: 'interpType') -> 'TSequence *': - inst_converted = _ffi.cast('const TInstant *', inst) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tinstant_to_tsequence(inst_converted, interp_converted) +def tsequenceset_delete_tstzspanset( + ss: "const TSequenceSet *", ps: "const SpanSet *" +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + ps_converted = _ffi.cast("const SpanSet *", ps) + result = _lib.tsequenceset_delete_tstzspanset(ss_converted, ps_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_to_tsequenceset(inst: 'const TInstant *', interp: 'interpType') -> 'TSequenceSet *': - inst_converted = _ffi.cast('const TInstant *', inst) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tinstant_to_tsequenceset(inst_converted, interp_converted) +def tsequenceset_insert( + ss1: "const TSequenceSet *", ss2: "const TSequenceSet *" +) -> "TSequenceSet *": + ss1_converted = _ffi.cast("const TSequenceSet *", ss1) + ss2_converted = _ffi.cast("const TSequenceSet *", ss2) + result = _lib.tsequenceset_insert(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_shift_scale_value(temp: 'const Temporal *', shift: 'Datum', width: 'Datum', hasshift: bool, haswidth: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - shift_converted = _ffi.cast('Datum', shift) - width_converted = _ffi.cast('Datum', width) - result = _lib.tnumber_shift_scale_value(temp_converted, shift_converted, width_converted, hasshift, haswidth) +def tsequenceset_merge( + ss1: "const TSequenceSet *", ss2: "const TSequenceSet *" +) -> "TSequenceSet *": + ss1_converted = _ffi.cast("const TSequenceSet *", ss1) + ss2_converted = _ffi.cast("const TSequenceSet *", ss2) + result = _lib.tsequenceset_merge(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def tnuminst_shift_value(inst: 'const TInstant *', shift: 'Datum') -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - shift_converted = _ffi.cast('Datum', shift) - result = _lib.tnuminst_shift_value(inst_converted, shift_converted) +def tsequenceset_merge_array( + seqsets: "const TSequenceSet **", count: int +) -> "TSequenceSet *": + seqsets_converted = [_ffi.cast("const TSequenceSet *", x) for x in seqsets] + result = _lib.tsequenceset_merge_array(seqsets_converted, count) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_shift_scale_value(seq: 'const TSequence *', shift: 'Datum', width: 'Datum', hasshift: bool, haswidth: bool) -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - shift_converted = _ffi.cast('Datum', shift) - width_converted = _ffi.cast('Datum', width) - result = _lib.tnumberseq_shift_scale_value(seq_converted, shift_converted, width_converted, hasshift, haswidth) +def tsequence_expand_bbox(seq: "TSequence *", inst: "const TInstant *") -> None: + seq_converted = _ffi.cast("TSequence *", seq) + inst_converted = _ffi.cast("const TInstant *", inst) + _lib.tsequence_expand_bbox(seq_converted, inst_converted) _check_error() - return result if result != _ffi.NULL else None -def tsequence_append_tinstant(seq: 'TSequence *', inst: 'const TInstant *', maxdist: float, maxt: 'const Interval *', expand: bool) -> 'Temporal *': - seq_converted = _ffi.cast('TSequence *', seq) - inst_converted = _ffi.cast('const TInstant *', inst) - maxt_converted = _ffi.cast('const Interval *', maxt) - result = _lib.tsequence_append_tinstant(seq_converted, inst_converted, maxdist, maxt_converted, expand) +def tsequence_set_bbox(seq: "const TSequence *", box: "void *") -> None: + seq_converted = _ffi.cast("const TSequence *", seq) + box_converted = _ffi.cast("void *", box) + _lib.tsequence_set_bbox(seq_converted, box_converted) _check_error() - return result if result != _ffi.NULL else None -def tsequence_append_tsequence(seq1: 'TSequence *', seq2: 'const TSequence *', expand: bool) -> 'Temporal *': - seq1_converted = _ffi.cast('TSequence *', seq1) - seq2_converted = _ffi.cast('const TSequence *', seq2) - result = _lib.tsequence_append_tsequence(seq1_converted, seq2_converted, expand) +def tsequenceset_expand_bbox(ss: "TSequenceSet *", seq: "const TSequence *") -> None: + ss_converted = _ffi.cast("TSequenceSet *", ss) + seq_converted = _ffi.cast("const TSequence *", seq) + _lib.tsequenceset_expand_bbox(ss_converted, seq_converted) _check_error() - return result if result != _ffi.NULL else None -def tsequence_merge(seq1: 'const TSequence *', seq2: 'const TSequence *') -> 'Temporal *': - seq1_converted = _ffi.cast('const TSequence *', seq1) - seq2_converted = _ffi.cast('const TSequence *', seq2) - result = _lib.tsequence_merge(seq1_converted, seq2_converted) +def tsequenceset_set_bbox(ss: "const TSequenceSet *", box: "void *") -> None: + ss_converted = _ffi.cast("const TSequenceSet *", ss) + box_converted = _ffi.cast("void *", box) + _lib.tsequenceset_set_bbox(ss_converted, box_converted) _check_error() - return result if result != _ffi.NULL else None -def tsequence_merge_array(sequences: 'const TSequence **', count: int) -> 'Temporal *': - sequences_converted = [_ffi.cast('const TSequence *', x) for x in sequences] - result = _lib.tsequence_merge_array(sequences_converted, count) +def tdiscseq_restrict_minmax( + seq: "const TSequence *", min: bool, atfunc: bool +) -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tdiscseq_restrict_minmax(seq_converted, min, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequence_set_interp(seq: 'const TSequence *', interp: 'interpType') -> 'Temporal *': - seq_converted = _ffi.cast('const TSequence *', seq) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tsequence_set_interp(seq_converted, interp_converted) +def tcontseq_restrict_minmax( + seq: "const TSequence *", min: bool, atfunc: bool +) -> "TSequenceSet *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tcontseq_restrict_minmax(seq_converted, min, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequence_shift_scale_time(seq: 'const TSequence *', shift: 'const Interval *', duration: 'const Interval *') -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - shift_converted = _ffi.cast('const Interval *', shift) - duration_converted = _ffi.cast('const Interval *', duration) - result = _lib.tsequence_shift_scale_time(seq_converted, shift_converted, duration_converted) +def temporal_bbox_restrict_set(temp: "const Temporal *", set: "const Set *") -> "bool": + temp_converted = _ffi.cast("const Temporal *", temp) + set_converted = _ffi.cast("const Set *", set) + result = _lib.temporal_bbox_restrict_set(temp_converted, set_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_to_tinstant(seq: 'const TSequence *') -> 'TInstant *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_to_tinstant(seq_converted) +def temporal_restrict_minmax( + temp: "const Temporal *", min: bool, atfunc: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_restrict_minmax(temp_converted, min, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequence_to_tdiscseq(seq: 'const TSequence *') -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_to_tdiscseq(seq_converted) +def temporal_restrict_timestamptz( + temp: "const Temporal *", t: int, atfunc: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.temporal_restrict_timestamptz(temp_converted, t_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequence_to_tcontseq(seq: 'const TSequence *', interp: 'interpType') -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tsequence_to_tcontseq(seq_converted, interp_converted) +def temporal_restrict_tstzset( + temp: "const Temporal *", s: "const Set *", atfunc: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Set *", s) + result = _lib.temporal_restrict_tstzset(temp_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequence_to_tsequenceset(seq: 'const TSequence *') -> 'TSequenceSet *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_to_tsequenceset(seq_converted) +def temporal_restrict_tstzspan( + temp: "const Temporal *", s: "const Span *", atfunc: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + s_converted = _ffi.cast("const Span *", s) + result = _lib.temporal_restrict_tstzspan(temp_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequence_to_tsequenceset_interp(seq: 'const TSequence *', interp: 'interpType') -> 'TSequenceSet *': - seq_converted = _ffi.cast('const TSequence *', seq) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tsequence_to_tsequenceset_interp(seq_converted, interp_converted) +def temporal_restrict_tstzspanset( + temp: "const Temporal *", ss: "const SpanSet *", atfunc: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.temporal_restrict_tstzspanset(temp_converted, ss_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_append_tinstant(ss: 'TSequenceSet *', inst: 'const TInstant *', maxdist: float, maxt: 'const Interval *', expand: bool) -> 'TSequenceSet *': - ss_converted = _ffi.cast('TSequenceSet *', ss) - inst_converted = _ffi.cast('const TInstant *', inst) - maxt_converted = _ffi.cast('const Interval *', maxt) - result = _lib.tsequenceset_append_tinstant(ss_converted, inst_converted, maxdist, maxt_converted, expand) +def temporal_restrict_value( + temp: "const Temporal *", value: "Datum", atfunc: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + result = _lib.temporal_restrict_value(temp_converted, value_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_append_tsequence(ss: 'TSequenceSet *', seq: 'const TSequence *', expand: bool) -> 'TSequenceSet *': - ss_converted = _ffi.cast('TSequenceSet *', ss) - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequenceset_append_tsequence(ss_converted, seq_converted, expand) +def temporal_restrict_values( + temp: "const Temporal *", set: "const Set *", atfunc: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + set_converted = _ffi.cast("const Set *", set) + result = _lib.temporal_restrict_values(temp_converted, set_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_merge(ss1: 'const TSequenceSet *', ss2: 'const TSequenceSet *') -> 'TSequenceSet *': - ss1_converted = _ffi.cast('const TSequenceSet *', ss1) - ss2_converted = _ffi.cast('const TSequenceSet *', ss2) - result = _lib.tsequenceset_merge(ss1_converted, ss2_converted) +def temporal_value_at_timestamptz( + temp: "const Temporal *", t: int, strict: bool +) -> "Datum *": + temp_converted = _ffi.cast("const Temporal *", temp) + t_converted = _ffi.cast("TimestampTz", t) + out_result = _ffi.new("Datum *") + result = _lib.temporal_value_at_timestamptz( + temp_converted, t_converted, strict, out_result + ) _check_error() - return result if result != _ffi.NULL else None + if result: + return out_result if out_result != _ffi.NULL else None + return None -def tsequenceset_merge_array(seqsets: 'const TSequenceSet **', count: int) -> 'TSequenceSet *': - seqsets_converted = [_ffi.cast('const TSequenceSet *', x) for x in seqsets] - result = _lib.tsequenceset_merge_array(seqsets_converted, count) +def tinstant_restrict_tstzspan( + inst: "const TInstant *", period: "const Span *", atfunc: bool +) -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + period_converted = _ffi.cast("const Span *", period) + result = _lib.tinstant_restrict_tstzspan(inst_converted, period_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_set_interp(ss: 'const TSequenceSet *', interp: 'interpType') -> 'Temporal *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - interp_converted = _ffi.cast('interpType', interp) - result = _lib.tsequenceset_set_interp(ss_converted, interp_converted) +def tinstant_restrict_tstzspanset( + inst: "const TInstant *", ss: "const SpanSet *", atfunc: bool +) -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.tinstant_restrict_tstzspanset(inst_converted, ss_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_shift_scale_value(ss: 'const TSequenceSet *', start: 'Datum', width: 'Datum', hasshift: bool, haswidth: bool) -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - start_converted = _ffi.cast('Datum', start) - width_converted = _ffi.cast('Datum', width) - result = _lib.tnumberseqset_shift_scale_value(ss_converted, start_converted, width_converted, hasshift, haswidth) +def tinstant_restrict_timestamptz( + inst: "const TInstant *", t: int, atfunc: bool +) -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tinstant_restrict_timestamptz(inst_converted, t_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_shift_scale_time(ss: 'const TSequenceSet *', start: 'const Interval *', duration: 'const Interval *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - start_converted = _ffi.cast('const Interval *', start) - duration_converted = _ffi.cast('const Interval *', duration) - result = _lib.tsequenceset_shift_scale_time(ss_converted, start_converted, duration_converted) +def tinstant_restrict_tstzset( + inst: "const TInstant *", s: "const Set *", atfunc: bool +) -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + s_converted = _ffi.cast("const Set *", s) + result = _lib.tinstant_restrict_tstzset(inst_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_to_tinstant(ss: 'const TSequenceSet *') -> 'TInstant *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_to_tinstant(ss_converted) +def tinstant_restrict_value( + inst: "const TInstant *", value: "Datum", atfunc: bool +) -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.tinstant_restrict_value(inst_converted, value_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_to_discrete(ss: 'const TSequenceSet *') -> 'TSequence *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_to_discrete(ss_converted) +def tinstant_restrict_values( + inst: "const TInstant *", set: "const Set *", atfunc: bool +) -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + set_converted = _ffi.cast("const Set *", set) + result = _lib.tinstant_restrict_values(inst_converted, set_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_to_step(ss: 'const TSequenceSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_to_step(ss_converted) +def tnumber_restrict_span( + temp: "const Temporal *", span: "const Span *", atfunc: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + span_converted = _ffi.cast("const Span *", span) + result = _lib.tnumber_restrict_span(temp_converted, span_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_to_linear(ss: 'const TSequenceSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_to_linear(ss_converted) +def tnumber_restrict_spanset( + temp: "const Temporal *", ss: "const SpanSet *", atfunc: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.tnumber_restrict_spanset(temp_converted, ss_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_to_tsequence(ss: 'const TSequenceSet *') -> 'TSequence *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_to_tsequence(ss_converted) +def tnumberinst_restrict_span( + inst: "const TInstant *", span: "const Span *", atfunc: bool +) -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + span_converted = _ffi.cast("const Span *", span) + result = _lib.tnumberinst_restrict_span(inst_converted, span_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def temporal_bbox_restrict_set(temp: 'const Temporal *', set: 'const Set *') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - set_converted = _ffi.cast('const Set *', set) - result = _lib.temporal_bbox_restrict_set(temp_converted, set_converted) +def tnumberinst_restrict_spanset( + inst: "const TInstant *", ss: "const SpanSet *", atfunc: bool +) -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.tnumberinst_restrict_spanset(inst_converted, ss_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_minmax(temp: 'const Temporal *', min: bool, atfunc: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_restrict_minmax(temp_converted, min, atfunc) +def tnumberseqset_restrict_span( + ss: "const TSequenceSet *", span: "const Span *", atfunc: bool +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + span_converted = _ffi.cast("const Span *", span) + result = _lib.tnumberseqset_restrict_span(ss_converted, span_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_tstzspan(temp: 'const Temporal *', s: 'const Span *', atfunc: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Span *', s) - result = _lib.temporal_restrict_tstzspan(temp_converted, s_converted, atfunc) +def tnumberseqset_restrict_spanset( + ss: "const TSequenceSet *", spanset: "const SpanSet *", atfunc: bool +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + spanset_converted = _ffi.cast("const SpanSet *", spanset) + result = _lib.tnumberseqset_restrict_spanset( + ss_converted, spanset_converted, atfunc + ) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_tstzspanset(temp: 'const Temporal *', ss: 'const SpanSet *', atfunc: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.temporal_restrict_tstzspanset(temp_converted, ss_converted, atfunc) +def tpoint_restrict_geom_time( + temp: "const Temporal *", + gs: "const GSERIALIZED *", + zspan: "const Span *", + period: "const Span *", + atfunc: bool, +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + zspan_converted = _ffi.cast("const Span *", zspan) + period_converted = _ffi.cast("const Span *", period) + result = _lib.tpoint_restrict_geom_time( + temp_converted, gs_converted, zspan_converted, period_converted, atfunc + ) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_timestamptz(temp: 'const Temporal *', t: int, atfunc: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.temporal_restrict_timestamptz(temp_converted, t_converted, atfunc) +def tpoint_restrict_stbox( + temp: "const Temporal *", box: "const STBox *", border_inc: bool, atfunc: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.tpoint_restrict_stbox( + temp_converted, box_converted, border_inc, atfunc + ) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_tstzset(temp: 'const Temporal *', s: 'const Set *', atfunc: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - s_converted = _ffi.cast('const Set *', s) - result = _lib.temporal_restrict_tstzset(temp_converted, s_converted, atfunc) +def tpointinst_restrict_geom_time( + inst: "const TInstant *", + gs: "const GSERIALIZED *", + zspan: "const Span *", + period: "const Span *", + atfunc: bool, +) -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + zspan_converted = _ffi.cast("const Span *", zspan) + period_converted = _ffi.cast("const Span *", period) + result = _lib.tpointinst_restrict_geom_time( + inst_converted, gs_converted, zspan_converted, period_converted, atfunc + ) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_value(temp: 'const Temporal *', value: 'Datum', atfunc: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) - result = _lib.temporal_restrict_value(temp_converted, value_converted, atfunc) +def tpointinst_restrict_stbox( + inst: "const TInstant *", box: "const STBox *", border_inc: bool, atfunc: bool +) -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.tpointinst_restrict_stbox( + inst_converted, box_converted, border_inc, atfunc + ) _check_error() return result if result != _ffi.NULL else None -def temporal_restrict_values(temp: 'const Temporal *', set: 'const Set *', atfunc: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - set_converted = _ffi.cast('const Set *', set) - result = _lib.temporal_restrict_values(temp_converted, set_converted, atfunc) +def tpointseq_restrict_geom_time( + seq: "const TSequence *", + gs: "const GSERIALIZED *", + zspan: "const Span *", + period: "const Span *", + atfunc: bool, +) -> "Temporal *": + seq_converted = _ffi.cast("const TSequence *", seq) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + zspan_converted = _ffi.cast("const Span *", zspan) + period_converted = _ffi.cast("const Span *", period) + result = _lib.tpointseq_restrict_geom_time( + seq_converted, gs_converted, zspan_converted, period_converted, atfunc + ) _check_error() return result if result != _ffi.NULL else None -def temporal_value_at_timestamptz(temp: 'const Temporal *', t: int, strict: bool) -> 'Datum *': - temp_converted = _ffi.cast('const Temporal *', temp) - t_converted = _ffi.cast('TimestampTz', t) - out_result = _ffi.new('Datum *') - result = _lib.temporal_value_at_timestamptz(temp_converted, t_converted, strict, out_result) +def tpointseq_restrict_stbox( + seq: "const TSequence *", box: "const STBox *", border_inc: bool, atfunc: bool +) -> "Temporal *": + seq_converted = _ffi.cast("const TSequence *", seq) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.tpointseq_restrict_stbox( + seq_converted, box_converted, border_inc, atfunc + ) _check_error() - if result: - return out_result if out_result != _ffi.NULL else None - return None + return result if result != _ffi.NULL else None -def tinstant_restrict_tstzspan(inst: 'const TInstant *', period: 'const Span *', atfunc: bool) -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - period_converted = _ffi.cast('const Span *', period) - result = _lib.tinstant_restrict_tstzspan(inst_converted, period_converted, atfunc) +def tpointseqset_restrict_geom_time( + ss: "const TSequenceSet *", + gs: "const GSERIALIZED *", + zspan: "const Span *", + period: "const Span *", + atfunc: bool, +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + zspan_converted = _ffi.cast("const Span *", zspan) + period_converted = _ffi.cast("const Span *", period) + result = _lib.tpointseqset_restrict_geom_time( + ss_converted, gs_converted, zspan_converted, period_converted, atfunc + ) _check_error() return result if result != _ffi.NULL else None -def tinstant_restrict_tstzspanset(inst: 'const TInstant *', ss: 'const SpanSet *', atfunc: bool) -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.tinstant_restrict_tstzspanset(inst_converted, ss_converted, atfunc) +def tpointseqset_restrict_stbox( + ss: "const TSequenceSet *", box: "const STBox *", border_inc: bool, atfunc: bool +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + box_converted = _ffi.cast("const STBox *", box) + result = _lib.tpointseqset_restrict_stbox( + ss_converted, box_converted, border_inc, atfunc + ) _check_error() return result if result != _ffi.NULL else None -def tinstant_restrict_timestamptz(inst: 'const TInstant *', t: int, atfunc: bool) -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.tinstant_restrict_timestamptz(inst_converted, t_converted, atfunc) +def tsequence_at_timestamptz(seq: "const TSequence *", t: int) -> "TInstant *": + seq_converted = _ffi.cast("const TSequence *", seq) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tsequence_at_timestamptz(seq_converted, t_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_restrict_tstzset(inst: 'const TInstant *', s: 'const Set *', atfunc: bool) -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - s_converted = _ffi.cast('const Set *', s) - result = _lib.tinstant_restrict_tstzset(inst_converted, s_converted, atfunc) +def tsequence_restrict_tstzspan( + seq: "const TSequence *", s: "const Span *", atfunc: bool +) -> "Temporal *": + seq_converted = _ffi.cast("const TSequence *", seq) + s_converted = _ffi.cast("const Span *", s) + result = _lib.tsequence_restrict_tstzspan(seq_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tinstant_restrict_value(inst: 'const TInstant *', value: 'Datum', atfunc: bool) -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - value_converted = _ffi.cast('Datum', value) - result = _lib.tinstant_restrict_value(inst_converted, value_converted, atfunc) +def tsequence_restrict_tstzspanset( + seq: "const TSequence *", ss: "const SpanSet *", atfunc: bool +) -> "Temporal *": + seq_converted = _ffi.cast("const TSequence *", seq) + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.tsequence_restrict_tstzspanset(seq_converted, ss_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tinstant_restrict_values(inst: 'const TInstant *', set: 'const Set *', atfunc: bool) -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - set_converted = _ffi.cast('const Set *', set) - result = _lib.tinstant_restrict_values(inst_converted, set_converted, atfunc) +def tsequenceset_restrict_minmax( + ss: "const TSequenceSet *", min: bool, atfunc: bool +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_restrict_minmax(ss_converted, min, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumber_restrict_span(temp: 'const Temporal *', span: 'const Span *', atfunc: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - span_converted = _ffi.cast('const Span *', span) - result = _lib.tnumber_restrict_span(temp_converted, span_converted, atfunc) +def tsequenceset_restrict_tstzspan( + ss: "const TSequenceSet *", s: "const Span *", atfunc: bool +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + s_converted = _ffi.cast("const Span *", s) + result = _lib.tsequenceset_restrict_tstzspan(ss_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumber_restrict_spanset(temp: 'const Temporal *', ss: 'const SpanSet *', atfunc: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.tnumber_restrict_spanset(temp_converted, ss_converted, atfunc) +def tsequenceset_restrict_tstzspanset( + ss: "const TSequenceSet *", ps: "const SpanSet *", atfunc: bool +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + ps_converted = _ffi.cast("const SpanSet *", ps) + result = _lib.tsequenceset_restrict_tstzspanset(ss_converted, ps_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumberinst_restrict_span(inst: 'const TInstant *', span: 'const Span *', atfunc: bool) -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - span_converted = _ffi.cast('const Span *', span) - result = _lib.tnumberinst_restrict_span(inst_converted, span_converted, atfunc) +def tsequenceset_restrict_timestamptz( + ss: "const TSequenceSet *", t: int, atfunc: bool +) -> "Temporal *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tsequenceset_restrict_timestamptz(ss_converted, t_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumberinst_restrict_spanset(inst: 'const TInstant *', ss: 'const SpanSet *', atfunc: bool) -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.tnumberinst_restrict_spanset(inst_converted, ss_converted, atfunc) +def tsequenceset_restrict_tstzset( + ss: "const TSequenceSet *", s: "const Set *", atfunc: bool +) -> "Temporal *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + s_converted = _ffi.cast("const Set *", s) + result = _lib.tsequenceset_restrict_tstzset(ss_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_restrict_span(ss: 'const TSequenceSet *', span: 'const Span *', atfunc: bool) -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - span_converted = _ffi.cast('const Span *', span) - result = _lib.tnumberseqset_restrict_span(ss_converted, span_converted, atfunc) +def tsequenceset_restrict_value( + ss: "const TSequenceSet *", value: "Datum", atfunc: bool +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.tsequenceset_restrict_value(ss_converted, value_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_restrict_spanset(ss: 'const TSequenceSet *', spanset: 'const SpanSet *', atfunc: bool) -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - spanset_converted = _ffi.cast('const SpanSet *', spanset) - result = _lib.tnumberseqset_restrict_spanset(ss_converted, spanset_converted, atfunc) +def tsequenceset_restrict_values( + ss: "const TSequenceSet *", s: "const Set *", atfunc: bool +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + s_converted = _ffi.cast("const Set *", s) + result = _lib.tsequenceset_restrict_values(ss_converted, s_converted, atfunc) _check_error() return result if result != _ffi.NULL else None -def tpoint_restrict_geom_time(temp: 'const Temporal *', gs: 'const GSERIALIZED *', zspan: 'const Span *', period: 'const Span *', atfunc: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - zspan_converted = _ffi.cast('const Span *', zspan) - period_converted = _ffi.cast('const Span *', period) - result = _lib.tpoint_restrict_geom_time(temp_converted, gs_converted, zspan_converted, period_converted, atfunc) +def tinstant_cmp(inst1: "const TInstant *", inst2: "const TInstant *") -> "int": + inst1_converted = _ffi.cast("const TInstant *", inst1) + inst2_converted = _ffi.cast("const TInstant *", inst2) + result = _lib.tinstant_cmp(inst1_converted, inst2_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_restrict_stbox(temp: 'const Temporal *', box: 'const STBox *', border_inc: bool, atfunc: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.tpoint_restrict_stbox(temp_converted, box_converted, border_inc, atfunc) +def tinstant_eq(inst1: "const TInstant *", inst2: "const TInstant *") -> "bool": + inst1_converted = _ffi.cast("const TInstant *", inst1) + inst2_converted = _ffi.cast("const TInstant *", inst2) + result = _lib.tinstant_eq(inst1_converted, inst2_converted) _check_error() return result if result != _ffi.NULL else None -def tpointinst_restrict_geom_time(inst: 'const TInstant *', gs: 'const GSERIALIZED *', zspan: 'const Span *', period: 'const Span *', atfunc: bool) -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - zspan_converted = _ffi.cast('const Span *', zspan) - period_converted = _ffi.cast('const Span *', period) - result = _lib.tpointinst_restrict_geom_time(inst_converted, gs_converted, zspan_converted, period_converted, atfunc) +def tsequence_cmp(seq1: "const TSequence *", seq2: "const TSequence *") -> "int": + seq1_converted = _ffi.cast("const TSequence *", seq1) + seq2_converted = _ffi.cast("const TSequence *", seq2) + result = _lib.tsequence_cmp(seq1_converted, seq2_converted) _check_error() return result if result != _ffi.NULL else None -def tpointinst_restrict_stbox(inst: 'const TInstant *', box: 'const STBox *', border_inc: bool, atfunc: bool) -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.tpointinst_restrict_stbox(inst_converted, box_converted, border_inc, atfunc) +def tsequence_eq(seq1: "const TSequence *", seq2: "const TSequence *") -> "bool": + seq1_converted = _ffi.cast("const TSequence *", seq1) + seq2_converted = _ffi.cast("const TSequence *", seq2) + result = _lib.tsequence_eq(seq1_converted, seq2_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_restrict_geom_time(seq: 'const TSequence *', gs: 'const GSERIALIZED *', zspan: 'const Span *', period: 'const Span *', atfunc: bool) -> 'Temporal *': - seq_converted = _ffi.cast('const TSequence *', seq) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - zspan_converted = _ffi.cast('const Span *', zspan) - period_converted = _ffi.cast('const Span *', period) - result = _lib.tpointseq_restrict_geom_time(seq_converted, gs_converted, zspan_converted, period_converted, atfunc) +def tsequenceset_cmp(ss1: "const TSequenceSet *", ss2: "const TSequenceSet *") -> "int": + ss1_converted = _ffi.cast("const TSequenceSet *", ss1) + ss2_converted = _ffi.cast("const TSequenceSet *", ss2) + result = _lib.tsequenceset_cmp(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_restrict_stbox(seq: 'const TSequence *', box: 'const STBox *', border_inc: bool, atfunc: bool) -> 'Temporal *': - seq_converted = _ffi.cast('const TSequence *', seq) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.tpointseq_restrict_stbox(seq_converted, box_converted, border_inc, atfunc) +def tsequenceset_eq(ss1: "const TSequenceSet *", ss2: "const TSequenceSet *") -> "bool": + ss1_converted = _ffi.cast("const TSequenceSet *", ss1) + ss2_converted = _ffi.cast("const TSequenceSet *", ss2) + result = _lib.tsequenceset_eq(ss1_converted, ss2_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_restrict_geom_time(ss: 'const TSequenceSet *', gs: 'const GSERIALIZED *', zspan: 'const Span *', period: 'const Span *', atfunc: bool) -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - gs_converted = _ffi.cast('const GSERIALIZED *', gs) - zspan_converted = _ffi.cast('const Span *', zspan) - period_converted = _ffi.cast('const Span *', period) - result = _lib.tpointseqset_restrict_geom_time(ss_converted, gs_converted, zspan_converted, period_converted, atfunc) +def always_eq_base_temporal(value: "Datum", temp: "const Temporal *") -> "int": + value_converted = _ffi.cast("Datum", value) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_eq_base_temporal(value_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_restrict_stbox(ss: 'const TSequenceSet *', box: 'const STBox *', border_inc: bool, atfunc: bool) -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - box_converted = _ffi.cast('const STBox *', box) - result = _lib.tpointseqset_restrict_stbox(ss_converted, box_converted, border_inc, atfunc) +def always_eq_temporal_base(temp: "const Temporal *", value: "Datum") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_eq_temporal_base(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_at_tstzspan(seq: 'const TSequence *', s: 'const Span *') -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - s_converted = _ffi.cast('const Span *', s) - result = _lib.tsequence_at_tstzspan(seq_converted, s_converted) +def always_eq_tinstant_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_eq_tinstant_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_at_timestamptz(seq: 'const TSequence *', t: int) -> 'TInstant *': - seq_converted = _ffi.cast('const TSequence *', seq) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.tsequence_at_timestamptz(seq_converted, t_converted) +def always_eq_tpointinst_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_eq_tpointinst_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_minmax(seq: 'const TSequence *', min: bool, atfunc: bool) -> 'TSequenceSet *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_restrict_minmax(seq_converted, min, atfunc) +def always_eq_tpointseq_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_eq_tpointseq_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_tstzspan(seq: 'const TSequence *', s: 'const Span *', atfunc: bool) -> 'Temporal *': - seq_converted = _ffi.cast('const TSequence *', seq) - s_converted = _ffi.cast('const Span *', s) - result = _lib.tsequence_restrict_tstzspan(seq_converted, s_converted, atfunc) +def always_eq_tpointseqset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_eq_tpointseqset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_tstzspanset(seq: 'const TSequence *', ss: 'const SpanSet *', atfunc: bool) -> 'Temporal *': - seq_converted = _ffi.cast('const TSequence *', seq) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.tsequence_restrict_tstzspanset(seq_converted, ss_converted, atfunc) +def always_eq_tsequence_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_eq_tsequence_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_timestamptz(seq: 'const TSequence *', t: int, atfunc: bool) -> 'TInstant *': - seq_converted = _ffi.cast('const TSequence *', seq) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.tsequence_restrict_timestamptz(seq_converted, t_converted, atfunc) +def always_eq_tsequenceset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_eq_tsequenceset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_tstzset(seq: 'const TSequence *', s: 'const Set *', atfunc: bool) -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - s_converted = _ffi.cast('const Set *', s) - result = _lib.tsequence_restrict_tstzset(seq_converted, s_converted, atfunc) +def always_ne_base_temporal(value: "Datum", temp: "const Temporal *") -> "int": + value_converted = _ffi.cast("Datum", value) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ne_base_temporal(value_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_value(seq: 'const TSequence *', value: 'Datum', atfunc: bool) -> 'TSequenceSet *': - seq_converted = _ffi.cast('const TSequence *', seq) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequence_restrict_value(seq_converted, value_converted, atfunc) +def always_ne_temporal_base(temp: "const Temporal *", value: "Datum") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_ne_temporal_base(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_restrict_values(seq: 'const TSequence *', s: 'const Set *', atfunc: bool) -> 'TSequenceSet *': - seq_converted = _ffi.cast('const TSequence *', seq) - s_converted = _ffi.cast('const Set *', s) - result = _lib.tsequence_restrict_values(seq_converted, s_converted, atfunc) +def always_ne_tinstant_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_ne_tinstant_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_minmax(ss: 'const TSequenceSet *', min: bool, atfunc: bool) -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_restrict_minmax(ss_converted, min, atfunc) +def always_ne_tpointinst_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_ne_tpointinst_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_tstzspan(ss: 'const TSequenceSet *', s: 'const Span *', atfunc: bool) -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.tsequenceset_restrict_tstzspan(ss_converted, s_converted, atfunc) +def always_ne_tpointseq_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_ne_tpointseq_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_tstzspanset(ss: 'const TSequenceSet *', ps: 'const SpanSet *', atfunc: bool) -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - ps_converted = _ffi.cast('const SpanSet *', ps) - result = _lib.tsequenceset_restrict_tstzspanset(ss_converted, ps_converted, atfunc) +def always_ne_tpointseqset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_ne_tpointseqset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_timestamptz(ss: 'const TSequenceSet *', t: int, atfunc: bool) -> 'Temporal *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.tsequenceset_restrict_timestamptz(ss_converted, t_converted, atfunc) +def always_ne_tsequence_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_ne_tsequence_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_tstzset(ss: 'const TSequenceSet *', s: 'const Set *', atfunc: bool) -> 'Temporal *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - s_converted = _ffi.cast('const Set *', s) - result = _lib.tsequenceset_restrict_tstzset(ss_converted, s_converted, atfunc) +def always_ne_tsequenceset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_ne_tsequenceset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_value(ss: 'const TSequenceSet *', value: 'Datum', atfunc: bool) -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequenceset_restrict_value(ss_converted, value_converted, atfunc) +def always_ge_base_temporal(value: "Datum", temp: "const Temporal *") -> "int": + value_converted = _ffi.cast("Datum", value) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_ge_base_temporal(value_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_restrict_values(ss: 'const TSequenceSet *', s: 'const Set *', atfunc: bool) -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - s_converted = _ffi.cast('const Set *', s) - result = _lib.tsequenceset_restrict_values(ss_converted, s_converted, atfunc) +def always_ge_temporal_base(temp: "const Temporal *", value: "Datum") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_ge_temporal_base(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_derivative(seq: 'const TSequence *') -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tnumberseq_derivative(seq_converted) +def always_ge_tinstant_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_ge_tinstant_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_derivative(ss: 'const TSequenceSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tnumberseqset_derivative(ss_converted) +def always_ge_tsequence_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_ge_tsequence_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def distance_tnumber_number(temp: 'const Temporal *', value: 'Datum', valuetype: 'meosType', restype: 'meosType') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) - valuetype_converted = _ffi.cast('meosType', valuetype) - restype_converted = _ffi.cast('meosType', restype) - result = _lib.distance_tnumber_number(temp_converted, value_converted, valuetype_converted, restype_converted) +def always_ge_tsequenceset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_ge_tsequenceset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnumber_number(temp: 'const Temporal *', value: 'Datum', basetype: 'meosType') -> 'double': - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) - basetype_converted = _ffi.cast('meosType', basetype) - result = _lib.nad_tnumber_number(temp_converted, value_converted, basetype_converted) +def always_gt_base_temporal(value: "Datum", temp: "const Temporal *") -> "int": + value_converted = _ffi.cast("Datum", value) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_gt_base_temporal(value_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_always_eq(temp: 'const Temporal *', value: 'Datum') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) - result = _lib.temporal_always_eq(temp_converted, value_converted) +def always_gt_temporal_base(temp: "const Temporal *", value: "Datum") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_gt_temporal_base(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_always_le(temp: 'const Temporal *', value: 'Datum') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) - result = _lib.temporal_always_le(temp_converted, value_converted) +def always_gt_tinstant_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_gt_tinstant_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_always_lt(temp: 'const Temporal *', value: 'Datum') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) - result = _lib.temporal_always_lt(temp_converted, value_converted) +def always_gt_tsequence_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_gt_tsequence_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_ever_eq(temp: 'const Temporal *', value: 'Datum') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) - result = _lib.temporal_ever_eq(temp_converted, value_converted) +def always_gt_tsequenceset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_gt_tsequenceset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_ever_le(temp: 'const Temporal *', value: 'Datum') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) - result = _lib.temporal_ever_le(temp_converted, value_converted) +def always_le_base_temporal(value: "Datum", temp: "const Temporal *") -> "int": + value_converted = _ffi.cast("Datum", value) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_le_base_temporal(value_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_ever_lt(temp: 'const Temporal *', value: 'Datum') -> 'bool': - temp_converted = _ffi.cast('const Temporal *', temp) - value_converted = _ffi.cast('Datum', value) - result = _lib.temporal_ever_lt(temp_converted, value_converted) +def always_le_temporal_base(temp: "const Temporal *", value: "Datum") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_le_temporal_base(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_always_eq(inst: 'const TInstant *', value: 'Datum') -> 'bool': - inst_converted = _ffi.cast('const TInstant *', inst) - value_converted = _ffi.cast('Datum', value) - result = _lib.tinstant_always_eq(inst_converted, value_converted) +def always_le_tinstant_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_le_tinstant_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_always_le(inst: 'const TInstant *', value: 'Datum') -> 'bool': - inst_converted = _ffi.cast('const TInstant *', inst) - value_converted = _ffi.cast('Datum', value) - result = _lib.tinstant_always_le(inst_converted, value_converted) +def always_le_tsequence_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_le_tsequence_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_always_lt(inst: 'const TInstant *', value: 'Datum') -> 'bool': - inst_converted = _ffi.cast('const TInstant *', inst) - value_converted = _ffi.cast('Datum', value) - result = _lib.tinstant_always_lt(inst_converted, value_converted) +def always_le_tsequenceset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_le_tsequenceset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_ever_eq(inst: 'const TInstant *', value: 'Datum') -> 'bool': - inst_converted = _ffi.cast('const TInstant *', inst) - value_converted = _ffi.cast('Datum', value) - result = _lib.tinstant_ever_eq(inst_converted, value_converted) +def always_lt_base_temporal(value: "Datum", temp: "const Temporal *") -> "int": + value_converted = _ffi.cast("Datum", value) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.always_lt_base_temporal(value_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_ever_le(inst: 'const TInstant *', value: 'Datum') -> 'bool': - inst_converted = _ffi.cast('const TInstant *', inst) - value_converted = _ffi.cast('Datum', value) - result = _lib.tinstant_ever_le(inst_converted, value_converted) +def always_lt_temporal_base(temp: "const Temporal *", value: "Datum") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_lt_temporal_base(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_ever_lt(inst: 'const TInstant *', value: 'Datum') -> 'bool': - inst_converted = _ffi.cast('const TInstant *', inst) - value_converted = _ffi.cast('Datum', value) - result = _lib.tinstant_ever_lt(inst_converted, value_converted) +def always_lt_tinstant_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_lt_tinstant_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointinst_always_eq(inst: 'const TInstant *', value: 'Datum') -> 'bool': - inst_converted = _ffi.cast('const TInstant *', inst) - value_converted = _ffi.cast('Datum', value) - result = _lib.tpointinst_always_eq(inst_converted, value_converted) +def always_lt_tsequence_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_lt_tsequence_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointinst_ever_eq(inst: 'const TInstant *', value: 'Datum') -> 'bool': - inst_converted = _ffi.cast('const TInstant *', inst) - value_converted = _ffi.cast('Datum', value) - result = _lib.tpointinst_ever_eq(inst_converted, value_converted) +def always_lt_tsequenceset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.always_lt_tsequenceset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_always_eq(seq: 'const TSequence *', value: 'Datum') -> 'bool': - seq_converted = _ffi.cast('const TSequence *', seq) - value_converted = _ffi.cast('Datum', value) - result = _lib.tpointseq_always_eq(seq_converted, value_converted) +def ever_eq_base_temporal(value: "Datum", temp: "const Temporal *") -> "int": + value_converted = _ffi.cast("Datum", value) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_eq_base_temporal(value_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_ever_eq(seq: 'const TSequence *', value: 'Datum') -> 'bool': - seq_converted = _ffi.cast('const TSequence *', seq) - value_converted = _ffi.cast('Datum', value) - result = _lib.tpointseq_ever_eq(seq_converted, value_converted) +def ever_eq_temporal_base(temp: "const Temporal *", value: "Datum") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_eq_temporal_base(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_always_eq(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - value_converted = _ffi.cast('Datum', value) - result = _lib.tpointseqset_always_eq(ss_converted, value_converted) +def ever_eq_tinstant_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_eq_tinstant_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_ever_eq(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - value_converted = _ffi.cast('Datum', value) - result = _lib.tpointseqset_ever_eq(ss_converted, value_converted) +def ever_eq_tpointinst_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_eq_tpointinst_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_always_eq(seq: 'const TSequence *', value: 'Datum') -> 'bool': - seq_converted = _ffi.cast('const TSequence *', seq) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequence_always_eq(seq_converted, value_converted) +def ever_eq_tpointseq_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_eq_tpointseq_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_always_le(seq: 'const TSequence *', value: 'Datum') -> 'bool': - seq_converted = _ffi.cast('const TSequence *', seq) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequence_always_le(seq_converted, value_converted) +def ever_eq_tpointseqset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_eq_tpointseqset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_always_lt(seq: 'const TSequence *', value: 'Datum') -> 'bool': - seq_converted = _ffi.cast('const TSequence *', seq) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequence_always_lt(seq_converted, value_converted) +def ever_eq_tsequence_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_eq_tsequence_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_ever_eq(seq: 'const TSequence *', value: 'Datum') -> 'bool': - seq_converted = _ffi.cast('const TSequence *', seq) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequence_ever_eq(seq_converted, value_converted) +def ever_eq_tsequenceset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_eq_tsequenceset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_ever_le(seq: 'const TSequence *', value: 'Datum') -> 'bool': - seq_converted = _ffi.cast('const TSequence *', seq) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequence_ever_le(seq_converted, value_converted) +def ever_ne_base_temporal(value: "Datum", temp: "const Temporal *") -> "int": + value_converted = _ffi.cast("Datum", value) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ne_base_temporal(value_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_ever_lt(seq: 'const TSequence *', value: 'Datum') -> 'bool': - seq_converted = _ffi.cast('const TSequence *', seq) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequence_ever_lt(seq_converted, value_converted) +def ever_ne_temporal_base(temp: "const Temporal *", value: "Datum") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_ne_temporal_base(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_always_eq(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequenceset_always_eq(ss_converted, value_converted) +def ever_ne_tinstant_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_ne_tinstant_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_always_le(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequenceset_always_le(ss_converted, value_converted) +def ever_ne_tpointinst_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_ne_tpointinst_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_always_lt(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequenceset_always_lt(ss_converted, value_converted) +def ever_ne_tpointseq_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_ne_tpointseq_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_ever_eq(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequenceset_ever_eq(ss_converted, value_converted) +def ever_ne_tpointseqset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_ne_tpointseqset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_ever_le(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequenceset_ever_le(ss_converted, value_converted) +def ever_ne_tsequence_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_ne_tsequence_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_ever_lt(ss: 'const TSequenceSet *', value: 'Datum') -> 'bool': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - value_converted = _ffi.cast('Datum', value) - result = _lib.tsequenceset_ever_lt(ss_converted, value_converted) +def ever_ne_tsequenceset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_ne_tsequenceset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_cmp(inst1: 'const TInstant *', inst2: 'const TInstant *') -> 'int': - inst1_converted = _ffi.cast('const TInstant *', inst1) - inst2_converted = _ffi.cast('const TInstant *', inst2) - result = _lib.tinstant_cmp(inst1_converted, inst2_converted) +def ever_ge_base_temporal(value: "Datum", temp: "const Temporal *") -> "int": + value_converted = _ffi.cast("Datum", value) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_ge_base_temporal(value_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tinstant_eq(inst1: 'const TInstant *', inst2: 'const TInstant *') -> 'bool': - inst1_converted = _ffi.cast('const TInstant *', inst1) - inst2_converted = _ffi.cast('const TInstant *', inst2) - result = _lib.tinstant_eq(inst1_converted, inst2_converted) +def ever_ge_temporal_base(temp: "const Temporal *", value: "Datum") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_ge_temporal_base(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_cmp(seq1: 'const TSequence *', seq2: 'const TSequence *') -> 'int': - seq1_converted = _ffi.cast('const TSequence *', seq1) - seq2_converted = _ffi.cast('const TSequence *', seq2) - result = _lib.tsequence_cmp(seq1_converted, seq2_converted) +def ever_ge_tinstant_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_ge_tinstant_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_eq(seq1: 'const TSequence *', seq2: 'const TSequence *') -> 'bool': - seq1_converted = _ffi.cast('const TSequence *', seq1) - seq2_converted = _ffi.cast('const TSequence *', seq2) - result = _lib.tsequence_eq(seq1_converted, seq2_converted) +def ever_ge_tsequence_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_ge_tsequence_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_cmp(ss1: 'const TSequenceSet *', ss2: 'const TSequenceSet *') -> 'int': - ss1_converted = _ffi.cast('const TSequenceSet *', ss1) - ss2_converted = _ffi.cast('const TSequenceSet *', ss2) - result = _lib.tsequenceset_cmp(ss1_converted, ss2_converted) +def ever_ge_tsequenceset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_ge_tsequenceset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_eq(ss1: 'const TSequenceSet *', ss2: 'const TSequenceSet *') -> 'bool': - ss1_converted = _ffi.cast('const TSequenceSet *', ss1) - ss2_converted = _ffi.cast('const TSequenceSet *', ss2) - result = _lib.tsequenceset_eq(ss1_converted, ss2_converted) +def ever_gt_base_temporal(value: "Datum", temp: "const Temporal *") -> "int": + value_converted = _ffi.cast("Datum", value) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_gt_base_temporal(value_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpointinst_srid(inst: 'const TInstant *') -> 'int': - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.tpointinst_srid(inst_converted) +def ever_gt_temporal_base(temp: "const Temporal *", value: "Datum") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_gt_temporal_base(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_trajectory(seq: 'const TSequence *') -> 'GSERIALIZED *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tpointseq_trajectory(seq_converted) +def ever_gt_tinstant_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_gt_tinstant_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_azimuth(seq: 'const TSequence *') -> 'TSequenceSet *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tpointseq_azimuth(seq_converted) +def ever_gt_tsequence_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_gt_tsequence_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_cumulative_length(seq: 'const TSequence *', prevlength: float) -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tpointseq_cumulative_length(seq_converted, prevlength) +def ever_gt_tsequenceset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_gt_tsequenceset_base(ss_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_is_simple(seq: 'const TSequence *') -> 'bool': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tpointseq_is_simple(seq_converted) +def ever_le_base_temporal(value: "Datum", temp: "const Temporal *") -> "int": + value_converted = _ffi.cast("Datum", value) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_le_base_temporal(value_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_length(seq: 'const TSequence *') -> 'double': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tpointseq_length(seq_converted) +def ever_le_temporal_base(temp: "const Temporal *", value: "Datum") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_le_temporal_base(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_speed(seq: 'const TSequence *') -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tpointseq_speed(seq_converted) +def ever_le_tinstant_base(inst: "const TInstant *", value: "Datum") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_le_tinstant_base(inst_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_srid(seq: 'const TSequence *') -> 'int': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tpointseq_srid(seq_converted) +def ever_le_tsequence_base(seq: "const TSequence *", value: "Datum") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_le_tsequence_base(seq_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_stboxes(seq: 'const TSequence *') -> "Tuple['STBox *', 'int']": - seq_converted = _ffi.cast('const TSequence *', seq) - count = _ffi.new('int *') - result = _lib.tpointseq_stboxes(seq_converted, count) +def ever_le_tsequenceset_base(ss: "const TSequenceSet *", value: "Datum") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_le_tsequenceset_base(ss_converted, value_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tpointseqset_azimuth(ss: 'const TSequenceSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tpointseqset_azimuth(ss_converted) +def ever_lt_base_temporal(value: "Datum", temp: "const Temporal *") -> "int": + value_converted = _ffi.cast("Datum", value) + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ever_lt_base_temporal(value_converted, temp_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_cumulative_length(ss: 'const TSequenceSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tpointseqset_cumulative_length(ss_converted) +def ever_lt_temporal_base(temp: "const Temporal *", value: "Datum") -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + result = _lib.ever_lt_temporal_base(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_is_simple(ss: 'const TSequenceSet *') -> 'bool': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tpointseqset_is_simple(ss_converted) +def tfloatseq_derivative(seq: "const TSequence *") -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tfloatseq_derivative(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_length(ss: 'const TSequenceSet *') -> 'double': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tpointseqset_length(ss_converted) +def tfloatseqset_derivative(ss: "const TSequenceSet *") -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tfloatseqset_derivative(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_speed(ss: 'const TSequenceSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tpointseqset_speed(ss_converted) +def tnumberinst_abs(inst: "const TInstant *") -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.tnumberinst_abs(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_srid(ss: 'const TSequenceSet *') -> 'int': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tpointseqset_srid(ss_converted) +def tnumberseq_abs(seq: "const TSequence *") -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tnumberseq_abs(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_stboxes(ss: 'const TSequenceSet *') -> "Tuple['STBox *', 'int']": - ss_converted = _ffi.cast('const TSequenceSet *', ss) - count = _ffi.new('int *') - result = _lib.tpointseqset_stboxes(ss_converted, count) +def tnumberseq_angular_difference(seq: "const TSequence *") -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tnumberseq_angular_difference(seq_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tpointseqset_trajectory(ss: 'const TSequenceSet *') -> 'GSERIALIZED *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tpointseqset_trajectory(ss_converted) +def tnumberseq_delta_value(seq: "const TSequence *") -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tnumberseq_delta_value(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tpoint_get_coord(temp: 'const Temporal *', coord: int) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tpoint_get_coord(temp_converted, coord) +def tnumberseqset_abs(ss: "const TSequenceSet *") -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tnumberseqset_abs(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompointinst_tgeogpointinst(inst: 'const TInstant *', oper: bool) -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - result = _lib.tgeompointinst_tgeogpointinst(inst_converted, oper) +def tnumberseqset_angular_difference(ss: "const TSequenceSet *") -> "TSequence *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tnumberseqset_angular_difference(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompointseq_tgeogpointseq(seq: 'const TSequence *', oper: bool) -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tgeompointseq_tgeogpointseq(seq_converted, oper) +def tnumberseqset_delta_value(ss: "const TSequenceSet *") -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tnumberseqset_delta_value(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompointseqset_tgeogpointseqset(ss: 'const TSequenceSet *', oper: bool) -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tgeompointseqset_tgeogpointseqset(ss_converted, oper) +def distance_tnumber_number( + temp: "const Temporal *", value: "Datum", valuetype: "meosType", restype: "meosType" +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + valuetype_converted = _ffi.cast("meosType", valuetype) + restype_converted = _ffi.cast("meosType", restype) + result = _lib.distance_tnumber_number( + temp_converted, value_converted, valuetype_converted, restype_converted + ) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_tgeogpoint(temp: 'const Temporal *', oper: bool) -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tgeompoint_tgeogpoint(temp_converted, oper) +def nad_tnumber_number( + temp: "const Temporal *", value: "Datum", basetype: "meosType" +) -> "double": + temp_converted = _ffi.cast("const Temporal *", temp) + value_converted = _ffi.cast("Datum", value) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.nad_tnumber_number( + temp_converted, value_converted, basetype_converted + ) _check_error() return result if result != _ffi.NULL else None -def tpointinst_set_srid(inst: 'const TInstant *', srid: int) -> 'TInstant *': - inst_converted = _ffi.cast('const TInstant *', inst) - srid_converted = _ffi.cast('int32', srid) - result = _lib.tpointinst_set_srid(inst_converted, srid_converted) +def tpointinst_srid(inst: "const TInstant *") -> "int": + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.tpointinst_srid(inst_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseq_make_simple(seq: 'const TSequence *') -> "Tuple['TSequence **', 'int']": - seq_converted = _ffi.cast('const TSequence *', seq) - count = _ffi.new('int *') - result = _lib.tpointseq_make_simple(seq_converted, count) +def tpointseq_trajectory(seq: "const TSequence *") -> "GSERIALIZED *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tpointseq_trajectory(seq_converted) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tpointseq_set_srid(seq: 'const TSequence *', srid: int) -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - srid_converted = _ffi.cast('int32', srid) - result = _lib.tpointseq_set_srid(seq_converted, srid_converted) +def tpointseq_azimuth(seq: "const TSequence *") -> "TSequenceSet *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tpointseq_azimuth(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_make_simple(ss: 'const TSequenceSet *') -> "Tuple['TSequence **', 'int']": - ss_converted = _ffi.cast('const TSequenceSet *', ss) - count = _ffi.new('int *') - result = _lib.tpointseqset_make_simple(ss_converted, count) +def tpointseq_cumulative_length( + seq: "const TSequence *", prevlength: float +) -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tpointseq_cumulative_length(seq_converted, prevlength) _check_error() - return result if result != _ffi.NULL else None, count[0] + return result if result != _ffi.NULL else None -def tpointseqset_set_srid(ss: 'const TSequenceSet *', srid: int) -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - srid_converted = _ffi.cast('int32', srid) - result = _lib.tpointseqset_set_srid(ss_converted, srid_converted) +def tpointseq_is_simple(seq: "const TSequence *") -> "bool": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tpointseq_is_simple(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_insert(seq1: 'const TSequence *', seq2: 'const TSequence *', connect: bool) -> 'Temporal *': - seq1_converted = _ffi.cast('const TSequence *', seq1) - seq2_converted = _ffi.cast('const TSequence *', seq2) - result = _lib.tsequence_insert(seq1_converted, seq2_converted, connect) +def tpointseq_length(seq: "const TSequence *") -> "double": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tpointseq_length(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_insert(ss1: 'const TSequenceSet *', ss2: 'const TSequenceSet *') -> 'TSequenceSet *': - ss1_converted = _ffi.cast('const TSequenceSet *', ss1) - ss2_converted = _ffi.cast('const TSequenceSet *', ss2) - result = _lib.tsequenceset_insert(ss1_converted, ss2_converted) +def tpointseq_speed(seq: "const TSequence *") -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tpointseq_speed(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_delete_timestamptz(seq: 'const TSequence *', t: int, connect: bool) -> 'Temporal *': - seq_converted = _ffi.cast('const TSequence *', seq) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.tsequence_delete_timestamptz(seq_converted, t_converted, connect) +def tpointseq_srid(seq: "const TSequence *") -> "int": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tpointseq_srid(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_delete_tstzset(seq: 'const TSequence *', s: 'const Set *', connect: bool) -> 'Temporal *': - seq_converted = _ffi.cast('const TSequence *', seq) - s_converted = _ffi.cast('const Set *', s) - result = _lib.tsequence_delete_tstzset(seq_converted, s_converted, connect) +def tpointseq_stboxes(seq: "const TSequence *") -> "Tuple['STBox *', 'int']": + seq_converted = _ffi.cast("const TSequence *", seq) + count = _ffi.new("int *") + result = _lib.tpointseq_stboxes(seq_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tsequence_delete_tstzspan(seq: 'const TSequence *', s: 'const Span *', connect: bool) -> 'Temporal *': - seq_converted = _ffi.cast('const TSequence *', seq) - s_converted = _ffi.cast('const Span *', s) - result = _lib.tsequence_delete_tstzspan(seq_converted, s_converted, connect) +def tpointseqset_azimuth(ss: "const TSequenceSet *") -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tpointseqset_azimuth(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequence_delete_tstzspanset(seq: 'const TSequence *', ss: 'const SpanSet *', connect: bool) -> 'Temporal *': - seq_converted = _ffi.cast('const TSequence *', seq) - ss_converted = _ffi.cast('const SpanSet *', ss) - result = _lib.tsequence_delete_tstzspanset(seq_converted, ss_converted, connect) +def tpointseqset_cumulative_length(ss: "const TSequenceSet *") -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tpointseqset_cumulative_length(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_delete_timestamptz(ss: 'const TSequenceSet *', t: int) -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - t_converted = _ffi.cast('TimestampTz', t) - result = _lib.tsequenceset_delete_timestamptz(ss_converted, t_converted) +def tpointseqset_is_simple(ss: "const TSequenceSet *") -> "bool": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tpointseqset_is_simple(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_delete_tstzset(ss: 'const TSequenceSet *', s: 'const Set *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - s_converted = _ffi.cast('const Set *', s) - result = _lib.tsequenceset_delete_tstzset(ss_converted, s_converted) +def tpointseqset_length(ss: "const TSequenceSet *") -> "double": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tpointseqset_length(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_delete_tstzspan(ss: 'const TSequenceSet *', s: 'const Span *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - s_converted = _ffi.cast('const Span *', s) - result = _lib.tsequenceset_delete_tstzspan(ss_converted, s_converted) +def tpointseqset_speed(ss: "const TSequenceSet *") -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tpointseqset_speed(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_delete_tstzspanset(ss: 'const TSequenceSet *', ps: 'const SpanSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - ps_converted = _ffi.cast('const SpanSet *', ps) - result = _lib.tsequenceset_delete_tstzspanset(ss_converted, ps_converted) +def tpointseqset_srid(ss: "const TSequenceSet *") -> "int": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tpointseqset_srid(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseq_integral(seq: 'const TSequence *') -> 'double': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tnumberseq_integral(seq_converted) +def tpointseqset_stboxes(ss: "const TSequenceSet *") -> "Tuple['STBox *', 'int']": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + count = _ffi.new("int *") + result = _lib.tpointseqset_stboxes(ss_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tnumberseq_twavg(seq: 'const TSequence *') -> 'double': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tnumberseq_twavg(seq_converted) +def tpointseqset_trajectory(ss: "const TSequenceSet *") -> "GSERIALIZED *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tpointseqset_trajectory(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_integral(ss: 'const TSequenceSet *') -> 'double': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tnumberseqset_integral(ss_converted) +def tpoint_get_coord(temp: "const Temporal *", coord: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_get_coord(temp_converted, coord) _check_error() return result if result != _ffi.NULL else None -def tnumberseqset_twavg(ss: 'const TSequenceSet *') -> 'double': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tnumberseqset_twavg(ss_converted) +def tgeompointinst_tgeogpointinst(inst: "const TInstant *", oper: bool) -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + result = _lib.tgeompointinst_tgeogpointinst(inst_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tpointseq_twcentroid(seq: 'const TSequence *') -> 'GSERIALIZED *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tpointseq_twcentroid(seq_converted) +def tgeompointseq_tgeogpointseq(seq: "const TSequence *", oper: bool) -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tgeompointseq_tgeogpointseq(seq_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tpointseqset_twcentroid(ss: 'const TSequenceSet *') -> 'GSERIALIZED *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tpointseqset_twcentroid(ss_converted) +def tgeompointseqset_tgeogpointseqset( + ss: "const TSequenceSet *", oper: bool +) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tgeompointseqset_tgeogpointseqset(ss_converted, oper) _check_error() return result if result != _ffi.NULL else None -def temporal_compact(temp: 'const Temporal *') -> 'Temporal *': - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_compact(temp_converted) +def tgeompoint_tgeogpoint(temp: "const Temporal *", oper: bool) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tgeompoint_tgeogpoint(temp_converted, oper) _check_error() return result if result != _ffi.NULL else None -def tsequence_compact(seq: 'const TSequence *') -> 'TSequence *': - seq_converted = _ffi.cast('const TSequence *', seq) - result = _lib.tsequence_compact(seq_converted) +def tpointinst_set_srid(inst: "const TInstant *", srid: int) -> "TInstant *": + inst_converted = _ffi.cast("const TInstant *", inst) + srid_converted = _ffi.cast("int32", srid) + result = _lib.tpointinst_set_srid(inst_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def tsequenceset_compact(ss: 'const TSequenceSet *') -> 'TSequenceSet *': - ss_converted = _ffi.cast('const TSequenceSet *', ss) - result = _lib.tsequenceset_compact(ss_converted) +def tpointseq_make_simple(seq: "const TSequence *") -> "Tuple['TSequence **', 'int']": + seq_converted = _ffi.cast("const TSequence *", seq) + count = _ffi.new("int *") + result = _lib.tpointseq_make_simple(seq_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def tbool_tand_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tbool_tand_transfn(state_converted, temp_converted) +def tpointseq_set_srid(seq: "const TSequence *", srid: int) -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + srid_converted = _ffi.cast("int32", srid) + result = _lib.tpointseq_set_srid(seq_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def tbool_tor_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tbool_tor_transfn(state_converted, temp_converted) +def tpointseqset_make_simple( + ss: "const TSequenceSet *", +) -> "Tuple['TSequence **', 'int']": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + count = _ffi.new("int *") + result = _lib.tpointseqset_make_simple(ss_converted, count) _check_error() - return result if result != _ffi.NULL else None + return result if result != _ffi.NULL else None, count[0] -def temporal_tagg_finalfn(state: 'SkipList *') -> 'Temporal *': - state_converted = _ffi.cast('SkipList *', state) - result = _lib.temporal_tagg_finalfn(state_converted) +def tpointseqset_set_srid(ss: "const TSequenceSet *", srid: int) -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + srid_converted = _ffi.cast("int32", srid) + result = _lib.tpointseqset_set_srid(ss_converted, srid_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_tcount_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.temporal_tcount_transfn(state_converted, temp_converted) +def tnumberseq_integral(seq: "const TSequence *") -> "double": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tnumberseq_integral(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_tmax_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_tmax_transfn(state_converted, temp_converted) +def tnumberseq_twavg(seq: "const TSequence *") -> "double": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tnumberseq_twavg(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_tmin_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_tmin_transfn(state_converted, temp_converted) +def tnumberseqset_integral(ss: "const TSequenceSet *") -> "double": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tnumberseqset_integral(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_tsum_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tfloat_tsum_transfn(state_converted, temp_converted) +def tnumberseqset_twavg(ss: "const TSequenceSet *") -> "double": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tnumberseqset_twavg(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_wmax_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interval_converted = _ffi.cast('const Interval *', interval) - result = _lib.tfloat_wmax_transfn(state_converted, temp_converted, interval_converted) +def tpointseq_twcentroid(seq: "const TSequence *") -> "GSERIALIZED *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tpointseq_twcentroid(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_wmin_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interval_converted = _ffi.cast('const Interval *', interval) - result = _lib.tfloat_wmin_transfn(state_converted, temp_converted, interval_converted) +def tpointseqset_twcentroid(ss: "const TSequenceSet *") -> "GSERIALIZED *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tpointseqset_twcentroid(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_wsum_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interval_converted = _ffi.cast('const Interval *', interval) - result = _lib.tfloat_wsum_transfn(state_converted, temp_converted, interval_converted) +def temporal_compact(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.temporal_compact(temp_converted) _check_error() return result if result != _ffi.NULL else None -def tint_tmin_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tint_tmin_transfn(state_converted, temp_converted) +def tsequence_compact(seq: "const TSequence *") -> "TSequence *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tsequence_compact(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tint_tmax_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tint_tmax_transfn(state_converted, temp_converted) +def tsequenceset_compact(ss: "const TSequenceSet *") -> "TSequenceSet *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tsequenceset_compact(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tint_tsum_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tint_tsum_transfn(state_converted, temp_converted) +def skiplist_free(list: "SkipList *") -> None: + list_converted = _ffi.cast("SkipList *", list) + _lib.skiplist_free(list_converted) _check_error() - return result if result != _ffi.NULL else None -def tint_wmax_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interval_converted = _ffi.cast('const Interval *', interval) - result = _lib.tint_wmax_transfn(state_converted, temp_converted, interval_converted) +def temporal_app_tinst_transfn( + state: "Temporal *", inst: "const TInstant *", maxdist: float, maxt: "Interval *" +) -> "Temporal *": + state_converted = _ffi.cast("Temporal *", state) + inst_converted = _ffi.cast("const TInstant *", inst) + maxt_converted = _ffi.cast("Interval *", maxt) + result = _lib.temporal_app_tinst_transfn( + state_converted, inst_converted, maxdist, maxt_converted + ) _check_error() return result if result != _ffi.NULL else None -def tint_wmin_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interval_converted = _ffi.cast('const Interval *', interval) - result = _lib.tint_wmin_transfn(state_converted, temp_converted, interval_converted) +def temporal_app_tseq_transfn( + state: "Temporal *", seq: "const TSequence *" +) -> "Temporal *": + state_converted = _ffi.cast("Temporal *", state) + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.temporal_app_tseq_transfn(state_converted, seq_converted) _check_error() return result if result != _ffi.NULL else None -def tint_wsum_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interval_converted = _ffi.cast('const Interval *', interval) - result = _lib.tint_wsum_transfn(state_converted, temp_converted, interval_converted) +def tnumberseq_integral(seq: "const TSequence *") -> "double": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tnumberseq_integral(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_tavg_finalfn(state: 'SkipList *') -> 'Temporal *': - state_converted = _ffi.cast('SkipList *', state) - result = _lib.tnumber_tavg_finalfn(state_converted) +def tnumberseq_twavg(seq: "const TSequence *") -> "double": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tnumberseq_twavg(seq_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_tavg_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.tnumber_tavg_transfn(state_converted, temp_converted) +def tnumberseqset_integral(ss: "const TSequenceSet *") -> "double": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tnumberseqset_integral(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_wavg_transfn(state: 'SkipList *', temp: 'const Temporal *', interval: 'const Interval *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) - temp_converted = _ffi.cast('const Temporal *', temp) - interval_converted = _ffi.cast('const Interval *', interval) - result = _lib.tnumber_wavg_transfn(state_converted, temp_converted, interval_converted) +def tnumberseqset_twavg(ss: "const TSequenceSet *") -> "double": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tnumberseqset_twavg(ss_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_tmin_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.ttext_tmin_transfn(state_converted, temp_converted) +def tpointseq_twcentroid(seq: "const TSequence *") -> "GSERIALIZED *": + seq_converted = _ffi.cast("const TSequence *", seq) + result = _lib.tpointseq_twcentroid(seq_converted) _check_error() return result if result != _ffi.NULL else None -def ttext_tmax_transfn(state: "Optional['SkipList *']", temp: 'const Temporal *') -> 'SkipList *': - state_converted = _ffi.cast('SkipList *', state) if state is not None else _ffi.NULL - temp_converted = _ffi.cast('const Temporal *', temp) - result = _lib.ttext_tmax_transfn(state_converted, temp_converted) +def tpointseqset_twcentroid(ss: "const TSequenceSet *") -> "GSERIALIZED *": + ss_converted = _ffi.cast("const TSequenceSet *", ss) + result = _lib.tpointseqset_twcentroid(ss_converted) _check_error() return result if result != _ffi.NULL else None -def tnumber_value_split(temp: 'const Temporal *', size: 'Datum', origin: 'Datum', buckets: 'Datum **') -> "Tuple['Temporal **', 'int']": - temp_converted = _ffi.cast('const Temporal *', temp) - size_converted = _ffi.cast('Datum', size) - origin_converted = _ffi.cast('Datum', origin) - buckets_converted = [_ffi.cast('Datum *', x) for x in buckets] - count = _ffi.new('int *') - result = _lib.tnumber_value_split(temp_converted, size_converted, origin_converted, buckets_converted, count) +def tnumber_value_split( + temp: "const Temporal *", size: "Datum", origin: "Datum", buckets: "Datum **" +) -> "Tuple['Temporal **', 'int']": + temp_converted = _ffi.cast("const Temporal *", temp) + size_converted = _ffi.cast("Datum", size) + origin_converted = _ffi.cast("Datum", origin) + buckets_converted = [_ffi.cast("Datum *", x) for x in buckets] + count = _ffi.new("int *") + result = _lib.tnumber_value_split( + temp_converted, size_converted, origin_converted, buckets_converted, count + ) _check_error() return result if result != _ffi.NULL else None, count[0] +def tbox_tile( + value: "Datum", + t: int, + vsize: "Datum", + duration: "Interval *", + vorigin: "Datum", + torigin: int, + basetype: "meosType", +) -> "TBox *": + value_converted = _ffi.cast("Datum", value) + t_converted = _ffi.cast("TimestampTz", t) + vsize_converted = _ffi.cast("Datum", vsize) + duration_converted = _ffi.cast("Interval *", duration) + vorigin_converted = _ffi.cast("Datum", vorigin) + torigin_converted = _ffi.cast("TimestampTz", torigin) + basetype_converted = _ffi.cast("meosType", basetype) + result = _lib.tbox_tile( + value_converted, + t_converted, + vsize_converted, + duration_converted, + vorigin_converted, + torigin_converted, + basetype_converted, + ) + _check_error() + return result if result != _ffi.NULL else None From 7898bd7a0ec4af3a3d7189b8afcc53fff18079ea Mon Sep 17 00:00:00 2001 From: Diviloper Date: Fri, 12 Jan 2024 23:39:58 +0100 Subject: [PATCH 19/37] Update aggregators names --- .../pymeos/aggregators/general_aggregators.py | 20 +++++++++++++++---- pymeos/pymeos/aggregators/time_aggregators.py | 11 ++++++++-- 2 files changed, 25 insertions(+), 6 deletions(-) diff --git a/pymeos/pymeos/aggregators/general_aggregators.py b/pymeos/pymeos/aggregators/general_aggregators.py index 33f2557f..d50d4486 100644 --- a/pymeos/pymeos/aggregators/general_aggregators.py +++ b/pymeos/pymeos/aggregators/general_aggregators.py @@ -1,13 +1,25 @@ from datetime import datetime from typing import Union -from pymeos_cffi import * +from pymeos_cffi import ( + timestamptz_tcount_transfn, + datetime_to_timestamptz, + tstzset_tcount_transfn, + temporal_tcount_transfn, + tstzspan_tcount_transfn, + tstzspanset_tcount_transfn, + temporal_extent_transfn, + timestamptz_extent_transfn, + set_extent_transfn, + span_extent_transfn, + spanset_extent_transfn, +) from .aggregator import BaseAggregator from ..boxes import Box +from ..collections import Time, TsTzSet, TsTzSpan, TsTzSpanSet from ..main import TIntSeq, TIntSeqSet from ..temporal import Temporal, TInterpolation -from ..collections import Time, TsTzSet, TsTzSpan, TsTzSpanSet class TemporalInstantCountAggregator( @@ -27,7 +39,7 @@ class TemporalInstantCountAggregator( @classmethod def _add(cls, state, temporal): if isinstance(temporal, datetime): - state = timestamp_tcount_transfn(state, datetime_to_timestamptz(temporal)) + state = timestamptz_tcount_transfn(state, datetime_to_timestamptz(temporal)) elif isinstance(temporal, TsTzSet): state = tstzset_tcount_transfn(state, temporal._inner) elif ( @@ -85,7 +97,7 @@ def _add(cls, state, temporal): if isinstance(temporal, Temporal): state = temporal_extent_transfn(state, temporal._inner) elif isinstance(temporal, datetime): - state = timestamp_extent_transfn(state, datetime_to_timestamptz(temporal)) + state = timestamptz_extent_transfn(state, datetime_to_timestamptz(temporal)) elif isinstance(temporal, TsTzSet): state = set_extent_transfn(state, temporal._inner) elif isinstance(temporal, TsTzSpan): diff --git a/pymeos/pymeos/aggregators/time_aggregators.py b/pymeos/pymeos/aggregators/time_aggregators.py index ca519369..72a88a6b 100644 --- a/pymeos/pymeos/aggregators/time_aggregators.py +++ b/pymeos/pymeos/aggregators/time_aggregators.py @@ -1,7 +1,14 @@ from datetime import datetime from typing import Union -from pymeos_cffi import * +from pymeos_cffi import ( + timestamptz_union_transfn, + datetime_to_timestamptz, + set_union_transfn, + set_union_finalfn, + union_spanset_span, + union_spanset_spanset, +) from .aggregator import BaseAggregator from ..collections import TsTzSet, TsTzSpan, TsTzSpanSet @@ -21,7 +28,7 @@ class TimeInstantaneousUnionAggregator( @classmethod def _add(cls, state, temporal): if isinstance(temporal, datetime): - state = timestamp_union_transfn(state, datetime_to_timestamptz(temporal)) + state = timestamptz_union_transfn(state, datetime_to_timestamptz(temporal)) elif isinstance(temporal, TsTzSet): state = set_union_transfn(state, temporal._inner) else: From 0ba8c309be1fca93c801420e159ee2070c90c2fb Mon Sep 17 00:00:00 2001 From: Diviloper Date: Fri, 12 Jan 2024 23:40:29 +0100 Subject: [PATCH 20/37] Update span to tbox constructor functions --- pymeos/pymeos/boxes/tbox.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/pymeos/pymeos/boxes/tbox.py b/pymeos/pymeos/boxes/tbox.py index f6de84b8..53efc6b6 100644 --- a/pymeos/pymeos/boxes/tbox.py +++ b/pymeos/pymeos/boxes/tbox.py @@ -159,9 +159,9 @@ def from_value(value: Union[int, float, IntSpan, FloatSpan]) -> TBox: elif isinstance(value, float): result = float_to_tbox(value) elif isinstance(value, IntSpan): - result = numspan_to_tbox(value._inner) + result = span_to_tbox(value._inner) elif isinstance(value, FloatSpan): - result = numspan_to_tbox(value._inner) + result = span_to_tbox(value._inner) else: raise TypeError(f"Operation not supported with type {value.__class__}") return TBox(_inner=result) @@ -185,11 +185,11 @@ def from_time(time: Time) -> TBox: if isinstance(time, datetime): result = timestamptz_to_tbox(datetime_to_timestamptz(time)) elif isinstance(time, TsTzSet): - result = tstzset_to_tbox(time._inner) + result = set_to_tbox(time._inner) elif isinstance(time, TsTzSpan): - result = tstzspan_to_tbox(time._inner) + result = span_to_tbox(time._inner) elif isinstance(time, TsTzSpanSet): - result = tstzspanset_to_tbox(time._inner) + result = spanset_to_tbox(time._inner) else: raise TypeError(f"Operation not supported with type {time.__class__}") return TBox(_inner=result) From be52cc62e5d18dac05f98484429f9cf2d82a8ee6 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Fri, 12 Jan 2024 23:41:29 +0100 Subject: [PATCH 21/37] Update always and ever comparisons to use new API, as well as add temporal values as compared values --- pymeos/pymeos/main/tbool.py | 28 ++-- pymeos/pymeos/main/tfloat.py | 212 ++++++++++++++++++---------- pymeos/pymeos/main/tint.py | 168 ++++++++++++++-------- pymeos/pymeos/main/tpoint.py | 136 +++++++++++------- pymeos/pymeos/main/ttext.py | 262 +++++++++++++++++++++-------------- 5 files changed, 515 insertions(+), 291 deletions(-) diff --git a/pymeos/pymeos/main/tbool.py b/pymeos/pymeos/main/tbool.py index 9de4c1fb..6d70798d 100644 --- a/pymeos/pymeos/main/tbool.py +++ b/pymeos/pymeos/main/tbool.py @@ -153,7 +153,7 @@ def value_at_timestamp(self, timestamp) -> bool: ) # ------------------------- Ever and Always Comparisons ------------------- - def always_eq(self, value: bool) -> bool: + def always_eq(self, value: Union[bool, TBool]) -> bool: """ Returns whether `self` is always equal to `value`. @@ -164,11 +164,16 @@ def always_eq(self, value: bool) -> bool: True if `self` is always equal to `value`, False otherwise. MEOS Function: - tbool_always_eq + always_eq_tbool_bool, always_eq_temporal_temporal """ - return tbool_always_eq(self._inner, value) + if isinstance(value, bool): + return always_eq_tbool_bool(self._inner, value) > 0 + elif isinstance(value, TBool): + return always_eq_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_eq(self, value: bool) -> bool: + def ever_eq(self, value: Union[bool, TBool]) -> bool: """ Returns whether `self` is ever equal to `value`. @@ -179,11 +184,16 @@ def ever_eq(self, value: bool) -> bool: True if `self` is ever equal to `value`, False otherwise. MEOS Function: - tbool_ever_eq + ever_eq_tbool_bool, ever_eq_temporal_temporal """ - return tbool_ever_eq(self._inner, value) + if isinstance(value, bool): + return ever_eq_tbool_bool(self._inner, value) > 0 + elif isinstance(value, TBool): + return ever_eq_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def never_eq(self, value: bool) -> bool: + def never_eq(self, value: Union[bool, TBool]) -> bool: """ Returns whether `self` is never equal to `value`. @@ -194,9 +204,9 @@ def never_eq(self, value: bool) -> bool: True if `self` is never equal to `value`, False otherwise. MEOS Function: - tbool_ever_eq + ever_eq_tbool_bool, ever_eq_temporal_temporal """ - return not tbool_ever_eq(self._inner, value) + return not self.ever_eq(value) # ------------------------- Temporal Comparisons -------------------------- def temporal_equal(self, other: Union[bool, TBool]) -> TBool: diff --git a/pymeos/pymeos/main/tfloat.py b/pymeos/pymeos/main/tfloat.py index 8329c0b9..a2394c95 100644 --- a/pymeos/pymeos/main/tfloat.py +++ b/pymeos/pymeos/main/tfloat.py @@ -272,72 +272,92 @@ def max_value(self) -> float: return tfloat_max_value(self._inner) # ------------------------- Ever and Always Comparisons ------------------- - def always_equal(self, value: float) -> bool: + def always_less(self, value: Union[float, TFloat]) -> bool: """ - Returns whether the values of `self` are always equal to `value`. + Returns whether the values of `self` are always less than `value`. Args: value: :class:`float` to compare. Returns: - `True` if the values of `self` are always equal to `value`, + `True` if the values of `self` are always less than `value`, `False` otherwise. MEOS Functions: - tfloat_always_eq + always_lt_tfloat_float, always_lt_temporal_temporal """ - return tfloat_always_eq(self._inner, value) + if isinstance(value, float): + return always_lt_tfloat_float(self._inner, value) > 0 + elif isinstance(value, TFloat): + return always_lt_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_not_equal(self, value: float) -> bool: + def always_less_or_equal(self, value: Union[float, TFloat]) -> bool: """ - Returns whether the values of `self` are always not equal to `value`. + Returns whether the values of `self` are always less than or equal to + `value`. Args: value: :class:`float` to compare. Returns: - `True` if the values of `self` are always not equal to `value`, - `False` otherwise. + `True` if the values of `self` are always less than or equal to + `value`, `False` otherwise. MEOS Functions: - tfloat_ever_eq + always_le_tfloat_float, always_le_temporal_temporal """ - return not tfloat_ever_eq(self._inner, value) + if isinstance(value, float): + return always_le_tfloat_float(self._inner, value) > 0 + elif isinstance(value, TFloat): + return always_le_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_less(self, value: float) -> bool: + def always_equal(self, value: Union[float, TFloat]) -> bool: """ - Returns whether the values of `self` are always less than `value`. + Returns whether the values of `self` are always equal to `value`. Args: value: :class:`float` to compare. Returns: - `True` if the values of `self` are always less than `value`, + `True` if the values of `self` are always equal to `value`, `False` otherwise. MEOS Functions: - tfloat_always_lt + always_eq_tfloat_float, always_eq_temporal_temporal """ - return tfloat_always_lt(self._inner, value) + if isinstance(value, float): + return always_eq_tfloat_float(self._inner, value) > 0 + elif isinstance(value, TFloat): + return always_eq_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_less_or_equal(self, value: float) -> bool: + def always_not_equal(self, value: Union[float, TFloat]) -> bool: """ - Returns whether the values of `self` are always less than or equal to - `value`. + Returns whether the values of `self` are always not equal to `value`. Args: value: :class:`float` to compare. Returns: - `True` if the values of `self` are always less than or equal to - `value`, `False` otherwise. + `True` if the values of `self` are always not equal to `value`, + `False` otherwise. MEOS Functions: - tfloat_always_le + always_ne_tfloat_float, always_ne_temporal_temporal """ - return tfloat_always_le(self._inner, value) + if isinstance(value, float): + return always_ne_tfloat_float(self._inner, value) > 0 + elif isinstance(value, TFloat): + return always_ne_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_greater_or_equal(self, value: float) -> bool: + def always_greater_or_equal(self, value: Union[float, TFloat]) -> bool: """ Returns whether the values of `self` are always greater than or equal to `value`. @@ -350,11 +370,16 @@ def always_greater_or_equal(self, value: float) -> bool: `value`, `False` otherwise. MEOS Functions: - tfloat_ever_lt + always_ge_tfloat_float, always_ge_temporal_temporal """ - return not tfloat_ever_lt(self._inner, value) + if isinstance(value, float): + return always_ge_tfloat_float(self._inner, value) > 0 + elif isinstance(value, TFloat): + return always_ge_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_greater(self, value: float) -> bool: + def always_greater(self, value: Union[float, TFloat]) -> bool: """ Returns whether the values of `self` are always greater than `value`. @@ -366,11 +391,16 @@ def always_greater(self, value: float) -> bool: `False` otherwise. MEOS Functions: - tfloat_ever_le + always_gt_tfloat_float, always_gt_temporal_temporal """ - return not tfloat_ever_le(self._inner, value) + if isinstance(value, float): + return always_gt_tfloat_float(self._inner, value) > 0 + elif isinstance(value, TFloat): + return always_gt_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_less(self, value: float) -> bool: + def ever_less(self, value: Union[float, TFloat]) -> bool: """ Returns whether the values of `self` are ever less than `value`. @@ -382,11 +412,16 @@ def ever_less(self, value: float) -> bool: `False` otherwise. MEOS Functions: - tfloat_ever_lt + ever_lt_tfloat_float, ever_lt_temporal_temporal """ - return tfloat_ever_lt(self._inner, value) + if isinstance(value, float): + return ever_lt_tfloat_float(self._inner, value) > 0 + elif isinstance(value, TFloat): + return ever_lt_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_less_or_equal(self, value: float) -> bool: + def ever_less_or_equal(self, value: Union[float, TFloat]) -> bool: """ Returns whether the values of `self` are ever less than or equal to `value`. @@ -399,11 +434,16 @@ def ever_less_or_equal(self, value: float) -> bool: `value`, `False` otherwise. MEOS Functions: - tfloat_ever_le + ever_le_tfloat_float, ever_le_temporal_temporal """ - return tfloat_ever_le(self._inner, value) + if isinstance(value, float): + return ever_le_tfloat_float(self._inner, value) > 0 + elif isinstance(value, TFloat): + return ever_le_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_equal(self, value: float) -> bool: + def ever_equal(self, value: Union[float, TFloat]) -> bool: """ Returns whether the values of `self` are ever equal to `value`. @@ -415,11 +455,16 @@ def ever_equal(self, value: float) -> bool: otherwise. MEOS Functions: - tfloat_ever_eq + ever_eq_tfloat_float, ever_eq_temporal_temporal """ - return tfloat_ever_eq(self._inner, value) + if isinstance(value, float): + return ever_eq_tfloat_float(self._inner, value) > 0 + elif isinstance(value, TFloat): + return ever_eq_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_not_equal(self, value: float) -> bool: + def ever_not_equal(self, value: Union[float, TFloat]) -> bool: """ Returns whether the values of `self` are ever not equal to `value`. @@ -431,11 +476,16 @@ def ever_not_equal(self, value: float) -> bool: `False` otherwise. MEOS Functions: - tfloat_always_eq + ever_ne_tfloat_float, ever_ne_temporal_temporal """ - return not tfloat_always_eq(self._inner, value) + if isinstance(value, float): + return ever_ne_tfloat_float(self._inner, value) > 0 + elif isinstance(value, TFloat): + return ever_ne_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_greater_or_equal(self, value: float) -> bool: + def ever_greater_or_equal(self, value: Union[float, TFloat]) -> bool: """ Returns whether the values of `self` are ever greater than or equal to `value`. @@ -448,11 +498,16 @@ def ever_greater_or_equal(self, value: float) -> bool: `value`, `False` otherwise. MEOS Functions: - tfloat_always_lt + ever_ge_tfloat_float, ever_ge_temporal_temporal """ - return not tfloat_always_lt(self._inner, value) + if isinstance(value, float): + return ever_ge_tfloat_float(self._inner, value) > 0 + elif isinstance(value, TFloat): + return ever_ge_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_greater(self, value: float) -> bool: + def ever_greater(self, value: Union[float, TFloat]) -> bool: """ Returns whether the values of `self` are ever greater than `value`. @@ -464,76 +519,81 @@ def ever_greater(self, value: float) -> bool: `False` otherwise. MEOS Functions: - tfloat_always_le + ever_gt_tfloat_float, ever_gt_temporal_temporal """ - return not tfloat_always_le(self._inner, value) + if isinstance(value, float): + return ever_gt_tfloat_float(self._inner, value) > 0 + elif isinstance(value, TFloat): + return ever_gt_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def never_equal(self, value: float) -> bool: + def never_less(self, value: Union[float, TFloat]) -> bool: """ - Returns whether the values of `self` are never equal to `value`. + Returns whether the values of `self` are never less than `value`. Args: value: :class:`float` value to compare. Returns: - `True` if the values of `self` are never equal to `value`, + `True` if the values of `self` are never less than `value`, `False` otherwise. MEOS Functions: - tfloat_ever_eq + ever_lt_tfloat_float, ever_lt_temporal_temporal """ - return not tfloat_ever_eq(self._inner, value) + return not self.ever_less(value) - def never_not_equal(self, value: float) -> bool: + def never_less_or_equal(self, value: Union[float, TFloat]) -> bool: """ - Returns whether the values of `self` are never not equal to `value`. + Returns whether the values of `self` are never less than or equal to + `value`. Args: value: :class:`float` value to compare. Returns: - `True` if the values of `self` are never not equal to `value`, - `False` otherwise. + `True` if the values of `self` are never less than or equal to + `value`, `False` otherwise. MEOS Functions: - tfloat_always_eq + ever_le_tfloat_float, ever_le_temporal_temporal """ - return tfloat_always_eq(self._inner, value) + return not self.ever_less_or_equal(value) - def never_less(self, value: float) -> bool: + def never_equal(self, value: Union[float, TFloat]) -> bool: """ - Returns whether the values of `self` are never less than `value`. + Returns whether the values of `self` are never equal to `value`. Args: value: :class:`float` value to compare. Returns: - `True` if the values of `self` are never less than `value`, + `True` if the values of `self` are never equal to `value`, `False` otherwise. MEOS Functions: - tfloat_ever_lt + ever_eq_tfloat_float, ever_eq_temporal_temporal """ - return not tfloat_ever_lt(self._inner, value) + return not self.ever_equal(value) - def never_less_or_equal(self, value: float) -> bool: + def never_not_equal(self, value: Union[float, TFloat]) -> bool: """ - Returns whether the values of `self` are never less than or equal to - `value`. + Returns whether the values of `self` are never not equal to `value`. Args: value: :class:`float` value to compare. Returns: - `True` if the values of `self` are never less than or equal to - `value`, `False` otherwise. + `True` if the values of `self` are never not equal to `value`, + `False` otherwise. MEOS Functions: - tfloat_ever_le + ever_ne_tfloat_float, ever_ne_temporal_temporal """ - return not tfloat_ever_le(self._inner, value) + return not self.ever_not_equal(value) - def never_greater_or_equal(self, value: float) -> bool: + def never_greater_or_equal(self, value: Union[float, TFloat]) -> bool: """ Returns whether the values of `self` are never greater than or equal to `value`. @@ -546,11 +606,11 @@ def never_greater_or_equal(self, value: float) -> bool: `value`, `False` otherwise. MEOS Functions: - tfloat_always_lt + ever_ge_tfloat_float, ever_ge_temporal_temporal """ - return tfloat_always_lt(self._inner, value) + return not self.ever_greater_or_equal(value) - def never_greater(self, value: float) -> bool: + def never_greater(self, value: Union[float, TFloat]) -> bool: """ Returns whether the values of `self` are never greater than `value`. @@ -562,9 +622,9 @@ def never_greater(self, value: float) -> bool: `False` otherwise. MEOS Functions: - tfloat_always_le + ever_gt_tfloat_float, ever_gt_temporal_temporal """ - return tfloat_always_le(self._inner, value) + return not self.ever_greater(value) # ------------------------- Temporal Comparisons -------------------------- def temporal_equal(self, other: Union[int, float, TFloat]) -> TBool: diff --git a/pymeos/pymeos/main/tint.py b/pymeos/pymeos/main/tint.py index bb3c4b30..030cc73a 100644 --- a/pymeos/pymeos/main/tint.py +++ b/pymeos/pymeos/main/tint.py @@ -246,7 +246,7 @@ def value_at_timestamp(self, timestamp) -> int: ) # ------------------------- Ever and Always Comparisons ------------------- - def always_less(self, value: int) -> bool: + def always_less(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are always less than `value`. @@ -258,11 +258,16 @@ def always_less(self, value: int) -> bool: `False` otherwise. MEOS Functions: - tint_always_lt + always_lt_tint_int, always_lt_temporal_temporal """ - return tint_always_lt(self._inner, value) + if isinstance(value, int): + return always_lt_tint_int(self._inner, value) > 0 + elif isinstance(value, TInt): + return always_lt_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_less_or_equal(self, value: int) -> bool: + def always_less_or_equal(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are always less than or equal to `value`. @@ -275,11 +280,16 @@ def always_less_or_equal(self, value: int) -> bool: `value`, `False` otherwise. MEOS Functions: - tint_always_le + always_le_tint_int, always_le_temporal_temporal """ - return tint_always_le(self._inner, value) + if isinstance(value, int): + return always_le_tint_int(self._inner, value) > 0 + elif isinstance(value, TInt): + return always_le_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_equal(self, value: int) -> bool: + def always_equal(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are always equal to `value`. @@ -291,11 +301,16 @@ def always_equal(self, value: int) -> bool: `False` otherwise. MEOS Functions: - tint_always_eq + always_eq_tint_int, always_eq_temporal_temporal """ - return tint_always_eq(self._inner, value) + if isinstance(value, int): + return always_eq_tint_int(self._inner, value) > 0 + elif isinstance(value, TInt): + return always_eq_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_not_equal(self, value: int) -> bool: + def always_not_equal(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are always not equal to `value`. @@ -307,11 +322,16 @@ def always_not_equal(self, value: int) -> bool: `False` otherwise. MEOS Functions: - tint_ever_eq + always_ne_tint_int, always_ne_temporal_temporal """ - return not tint_ever_eq(self._inner, value) + if isinstance(value, int): + return always_ne_tint_int(self._inner, value) > 0 + elif isinstance(value, TInt): + return always_ne_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_greater_or_equal(self, value: int) -> bool: + def always_greater_or_equal(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are always greater than or equal to `value`. @@ -324,11 +344,16 @@ def always_greater_or_equal(self, value: int) -> bool: `value`, `False` otherwise. MEOS Functions: - tint_ever_lt + always_ge_tint_int, always_ge_temporal_temporal """ - return not tint_ever_lt(self._inner, value) + if isinstance(value, int): + return always_ge_tint_int(self._inner, value) > 0 + elif isinstance(value, TInt): + return always_ge_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_greater(self, value: int) -> bool: + def always_greater(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are always greater than `value`. @@ -340,11 +365,16 @@ def always_greater(self, value: int) -> bool: `False` otherwise. MEOS Functions: - tint_ever_le + always_gt_tint_int, always_gt_temporal_temporal """ - return not tint_ever_le(self._inner, value) + if isinstance(value, int): + return always_gt_tint_int(self._inner, value) > 0 + elif isinstance(value, TInt): + return always_gt_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_less(self, value: int) -> bool: + def ever_less(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are ever less than `value`. @@ -356,11 +386,16 @@ def ever_less(self, value: int) -> bool: `False` otherwise. MEOS Functions: - tint_ever_lt + ever_lt_tint_int, ever_lt_temporal_temporal """ - return tint_ever_lt(self._inner, value) + if isinstance(value, int): + return ever_lt_tint_int(self._inner, value) > 0 + elif isinstance(value, TInt): + return ever_lt_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_less_or_equal(self, value: int) -> bool: + def ever_less_or_equal(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are ever less than or equal to `value`. @@ -373,11 +408,16 @@ def ever_less_or_equal(self, value: int) -> bool: `value`, `False` otherwise. MEOS Functions: - tint_ever_le + ever_le_tint_int, ever_le_temporal_temporal """ - return tint_ever_le(self._inner, value) + if isinstance(value, int): + return ever_le_tint_int(self._inner, value) > 0 + elif isinstance(value, TInt): + return ever_le_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_equal(self, value: int) -> bool: + def ever_equal(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are ever equal to `value`. @@ -389,11 +429,16 @@ def ever_equal(self, value: int) -> bool: `False` otherwise. MEOS Functions: - tint_ever_eq + ever_eq_tint_int, ever_eq_temporal_temporal """ - return tint_ever_eq(self._inner, value) + if isinstance(value, int): + return ever_eq_tint_int(self._inner, value) > 0 + elif isinstance(value, TInt): + return ever_eq_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_not_equal(self, value: int) -> bool: + def ever_not_equal(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are ever not equal to `value`. @@ -405,11 +450,16 @@ def ever_not_equal(self, value: int) -> bool: `False` otherwise. MEOS Functions: - tint_always_eq + ever_ne_tint_int, ever_ne_temporal_temporal """ - return not tint_always_eq(self._inner, value) + if isinstance(value, int): + return ever_ne_tint_int(self._inner, value) > 0 + elif isinstance(value, TInt): + return ever_ne_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_greater_or_equal(self, value: int) -> bool: + def ever_greater_or_equal(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are ever greater than or equal to `value`. @@ -422,11 +472,16 @@ def ever_greater_or_equal(self, value: int) -> bool: `value`, `False` otherwise. MEOS Functions: - tint_always_lt + ever_ge_tint_int, ever_ge_temporal_temporal """ - return not tint_always_lt(self._inner, value) + if isinstance(value, int): + return ever_ge_tint_int(self._inner, value) > 0 + elif isinstance(value, TInt): + return ever_ge_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_greater(self, value: int) -> bool: + def ever_greater(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are ever greater than `value`. @@ -438,11 +493,16 @@ def ever_greater(self, value: int) -> bool: `False` otherwise. MEOS Functions: - tint_always_le + ever_gt_tint_int, ever_gt_temporal_temporal """ - return not tint_always_le(self._inner, value) + if isinstance(value, int): + return ever_gt_tint_int(self._inner, value) > 0 + elif isinstance(value, TInt): + return ever_gt_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def never_less(self, value: int) -> bool: + def never_less(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are never less than `value`. @@ -454,11 +514,11 @@ def never_less(self, value: int) -> bool: `False` otherwise. MEOS Functions: - tint_ever_lt + ever_lt_tint_int, ever_lt_temporal_temporal """ - return not tint_ever_lt(self._inner, value) + return not self.ever_less(value) - def never_less_or_equal(self, value: int) -> bool: + def never_less_or_equal(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are never less than or equal to `value`. @@ -471,11 +531,11 @@ def never_less_or_equal(self, value: int) -> bool: `value`, `False` otherwise. MEOS Functions: - tint_ever_le + ever_le_tint_int, ever_le_temporal_temporal """ - return not tint_ever_le(self._inner, value) + return not self.ever_less_or_equal(value) - def never_equal(self, value: int) -> bool: + def never_equal(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are never equal to `value`. @@ -487,11 +547,11 @@ def never_equal(self, value: int) -> bool: `False` otherwise. MEOS Functions: - tint_ever_eq + ever_eq_tint_int, ever_eq_temporal_temporal """ - return not tint_ever_eq(self._inner, value) + return not self.ever_equal(value) - def never_not_equal(self, value: int) -> bool: + def never_not_equal(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are never not equal to `value`. @@ -503,11 +563,11 @@ def never_not_equal(self, value: int) -> bool: `False` otherwise. MEOS Functions: - tint_always_eq + ever_ne_tint_int, ever_ne_temporal_temporal """ - return tint_always_eq(self._inner, value) + return not self.ever_not_equal(value) - def never_greater_or_equal(self, value: int) -> bool: + def never_greater_or_equal(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are never greater than or equal to `value`. @@ -520,11 +580,11 @@ def never_greater_or_equal(self, value: int) -> bool: `value`, `False` otherwise. MEOS Functions: - tint_always_lt + ever_ge_tint_int, ever_ge_temporal_temporal """ - return tint_always_lt(self._inner, value) + return not self.ever_greater_or_equal(value) - def never_greater(self, value: int) -> bool: + def never_greater(self, value: Union[int, TInt]) -> bool: """ Returns whether the values of `self` are never greater than `value`. @@ -536,9 +596,9 @@ def never_greater(self, value: int) -> bool: `False` otherwise. MEOS Functions: - tint_always_le + ever_gt_tint_int, ever_gt_temporal_temporal """ - return tint_always_le(self._inner, value) + return not self.ever_greater(value) # ------------------------- Temporal Comparisons -------------------------- def temporal_equal(self, other: Union[int, TInt]) -> TBool: diff --git a/pymeos/pymeos/main/tpoint.py b/pymeos/pymeos/main/tpoint.py index 71e39975..456cf9ca 100644 --- a/pymeos/pymeos/main/tpoint.py +++ b/pymeos/pymeos/main/tpoint.py @@ -120,9 +120,7 @@ def as_geojson( MEOS Functions: gserialized_as_geojson """ - return gserialized_as_geojson( - tpoint_trajectory(self._inner), option, precision, srs - ) + return geo_as_geojson(tpoint_trajectory(self._inner), option, precision, srs) def to_shapely_geometry(self, precision: int = 15) -> shpb.BaseGeometry: """ @@ -1503,7 +1501,7 @@ def to_dataframe(self) -> GeoDataFrame: return gpd.GeoDataFrame(data, crs=self.srid()).set_index(keys=["time"]) # ------------------------- Ever and Always Comparisons ------------------- - def always_equal(self, value: shpb.BaseGeometry) -> bool: + def always_equal(self, value: Union[shpb.BaseGeometry, TGeomPoint]) -> bool: """ Returns whether `self` is always equal to `value`. @@ -1514,12 +1512,17 @@ def always_equal(self, value: shpb.BaseGeometry) -> bool: True if `self` is always equal to `value`, False otherwise. MEOS Functions: - tpoint_always_eq + always_eq_tpoint_point, always_eq_temporal_temporal """ - gs = geometry_to_gserialized(value) - return tpoint_always_eq(self._inner, gs) + if isinstance(value, shpb.BaseGeometry): + gs = geometry_to_gserialized(value) + return always_eq_tpoint_point(self._inner, gs) > 0 + elif isinstance(value, TGeomPoint): + return always_eq_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_not_equal(self, value: shpb.BaseGeometry) -> bool: + def always_not_equal(self, value: Union[shpb.BaseGeometry, TGeomPoint]) -> bool: """ Returns whether `self` is always different to `value`. @@ -1530,12 +1533,17 @@ def always_not_equal(self, value: shpb.BaseGeometry) -> bool: True if `self` is always different to `value`, False otherwise. MEOS Functions: - tpoint_ever_eq + always_ne_tpoint_point, always_ne_temporal_temporal """ - gs = geometry_to_gserialized(value) - return not tpoint_ever_eq(self._inner, gs) + if isinstance(value, shpb.BaseGeometry): + gs = geometry_to_gserialized(value) + return always_ne_tpoint_point(self._inner, gs) > 0 + elif isinstance(value, TGeomPoint): + return always_ne_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_equal(self, value: shpb.BaseGeometry) -> bool: + def ever_equal(self, value: Union[shpb.BaseGeometry, TGeomPoint]) -> bool: """ Returns whether `self` is ever equal to `value`. @@ -1546,12 +1554,17 @@ def ever_equal(self, value: shpb.BaseGeometry) -> bool: True if `self` is ever equal to `value`, False otherwise. MEOS Functions: - tpoint_ever_eq + ever_eq_tpoint_point, ever_eq_temporal_temporal """ - gs = geometry_to_gserialized(value) - return tpoint_ever_eq(self._inner, gs) + if isinstance(value, shpb.BaseGeometry): + gs = geometry_to_gserialized(value) + return ever_eq_tpoint_point(self._inner, gs) > 0 + elif isinstance(value, TGeomPoint): + return ever_eq_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_not_equal(self, value: shpb.BaseGeometry) -> bool: + def ever_not_equal(self, value: Union[shpb.BaseGeometry, TGeomPoint]) -> bool: """ Returns whether `self` is ever different to `value`. @@ -1562,12 +1575,17 @@ def ever_not_equal(self, value: shpb.BaseGeometry) -> bool: True if `self` is ever different to `value`, False otherwise. MEOS Functions: - tpoint_always_eq + ever_ne_tpoint_point, ever_ne_temporal_temporal """ - gs = geometry_to_gserialized(value) - return not tpoint_always_eq(self._inner, gs) + if isinstance(value, shpb.BaseGeometry): + gs = geometry_to_gserialized(value) + return ever_ne_tpoint_point(self._inner, gs) > 0 + elif isinstance(value, TGeomPoint): + return ever_ne_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def never_equal(self, value: shpb.BaseGeometry) -> bool: + def never_equal(self, value: Union[shpb.BaseGeometry, TGeomPoint]) -> bool: """ Returns whether `self` is never equal to `value`. @@ -1578,12 +1596,11 @@ def never_equal(self, value: shpb.BaseGeometry) -> bool: True if `self` is never equal to `value`, False otherwise. MEOS Functions: - tpoint_ever_eq + ever_eq_tpoint_point, ever_eq_temporal_temporal """ - gs = geometry_to_gserialized(value) - return not tpoint_ever_eq(self._inner, gs) + return not self.ever_equal(value) - def never_not_equal(self, value: shpb.BaseGeometry) -> bool: + def never_not_equal(self, value: Union[shpb.BaseGeometry, TGeomPoint]) -> bool: """ Returns whether `self` is never different to `value`. @@ -1594,10 +1611,9 @@ def never_not_equal(self, value: shpb.BaseGeometry) -> bool: True if `self` is never different to `value`, False otherwise. MEOS Functions: - tpoint_always_eq + ever_ne_tpoint_point, ever_ne_temporal_temporal """ - gs = geometry_to_gserialized(value) - return tpoint_always_eq(self._inner, gs) + return not self.ever_not_equal(value) # ------------------------- Temporal Comparisons -------------------------- def temporal_equal(self, other: Union[shp.Point, TGeomPoint]) -> TBool: @@ -1784,7 +1800,7 @@ def to_geometric(self) -> TGeomPoint: return Temporal._factory(result) # ------------------------- Ever and Always Comparisons ------------------- - def always_equal(self, value: shpb.BaseGeometry) -> bool: + def always_equal(self, value: Union[shpb.BaseGeometry, TGeogPoint]) -> bool: """ Returns whether `self` is always equal to `value`. @@ -1795,12 +1811,17 @@ def always_equal(self, value: shpb.BaseGeometry) -> bool: True if `self` is always equal to `value`, False otherwise. MEOS Functions: - tpoint_always_eq + always_eq_tpoint_point, always_eq_temporal_temporal """ - gs = geography_to_gserialized(value) - return tpoint_always_eq(self._inner, gs) + if isinstance(value, shpb.BaseGeometry): + gs = geography_to_gserialized(value) + return always_eq_tpoint_point(self._inner, gs) > 0 + elif isinstance(value, TGeogPoint): + return always_eq_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_not_equal(self, value: shpb.BaseGeometry) -> bool: + def always_not_equal(self, value: Union[shpb.BaseGeometry, TGeogPoint]) -> bool: """ Returns whether `self` is always different to `value`. @@ -1811,12 +1832,17 @@ def always_not_equal(self, value: shpb.BaseGeometry) -> bool: True if `self` is always different to `value`, False otherwise. MEOS Functions: - tpoint_ever_eq + always_ne_tpoint_point, always_ne_temporal_temporal """ - gs = geography_to_gserialized(value) - return not tpoint_ever_eq(self._inner, gs) + if isinstance(value, shpb.BaseGeometry): + gs = geography_to_gserialized(value) + return always_ne_tpoint_point(self._inner, gs) > 0 + elif isinstance(value, TGeogPoint): + return always_ne_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_equal(self, value: shpb.BaseGeometry) -> bool: + def ever_equal(self, value: Union[shpb.BaseGeometry, TGeogPoint]) -> bool: """ Returns whether `self` is ever equal to `value`. @@ -1827,12 +1853,17 @@ def ever_equal(self, value: shpb.BaseGeometry) -> bool: True if `self` is ever equal to `value`, False otherwise. MEOS Functions: - tpoint_ever_eq + ever_eq_tpoint_point, ever_eq_temporal_temporal """ - gs = geography_to_gserialized(value) - return tpoint_ever_eq(self._inner, gs) + if isinstance(value, shpb.BaseGeometry): + gs = geography_to_gserialized(value) + return ever_eq_tpoint_point(self._inner, gs) > 0 + elif isinstance(value, TGeogPoint): + return ever_eq_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_not_equal(self, value: shpb.BaseGeometry) -> bool: + def ever_not_equal(self, value: Union[shpb.BaseGeometry, TGeogPoint]) -> bool: """ Returns whether `self` is ever different to `value`. @@ -1843,12 +1874,17 @@ def ever_not_equal(self, value: shpb.BaseGeometry) -> bool: True if `self` is ever different to `value`, False otherwise. MEOS Functions: - tpoint_always_eq + ever_ne_tpoint_point, ever_ne_temporal_temporal """ - gs = geography_to_gserialized(value) - return not tpoint_always_eq(self._inner, gs) + if isinstance(value, shpb.BaseGeometry): + gs = geography_to_gserialized(value) + return ever_ne_tpoint_point(self._inner, gs) > 0 + elif isinstance(value, TGeogPoint): + return ever_ne_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def never_equal(self, value: shpb.BaseGeometry) -> bool: + def never_equal(self, value: Union[shpb.BaseGeometry, TGeogPoint]) -> bool: """ Returns whether `self` is never equal to `value`. @@ -1859,12 +1895,11 @@ def never_equal(self, value: shpb.BaseGeometry) -> bool: True if `self` is never equal to `value`, False otherwise. MEOS Functions: - tpoint_ever_eq + ever_eq_tpoint_point, ever_eq_temporal_temporal """ - gs = geography_to_gserialized(value) - return not tpoint_ever_eq(self._inner, gs) + return not self.ever_equal(value) - def never_not_equal(self, value: shpb.BaseGeometry) -> bool: + def never_not_equal(self, value: Union[shpb.BaseGeometry, TGeogPoint]) -> bool: """ Returns whether `self` is never different to `value`. @@ -1875,10 +1910,9 @@ def never_not_equal(self, value: shpb.BaseGeometry) -> bool: True if `self` is never different to `value`, False otherwise. MEOS Functions: - tpoint_always_eq + ever_ne_tpoint_point, ever_ne_temporal_temporal """ - gs = geography_to_gserialized(value) - return tpoint_always_eq(self._inner, gs) + return not self.ever_not_equal(value) # ------------------------- Temporal Comparisons -------------------------- def temporal_equal(self, other: Union[shp.Point, TGeogPoint]) -> TBool: diff --git a/pymeos/pymeos/main/ttext.py b/pymeos/pymeos/main/ttext.py index cbeec8ff..6f347e6d 100644 --- a/pymeos/pymeos/main/ttext.py +++ b/pymeos/pymeos/main/ttext.py @@ -224,268 +224,328 @@ def value_at_timestamp(self, timestamp: datetime) -> str: return text2cstring(result[0]) # ------------------------- Ever and Always Comparisons ------------------- - def always_equal(self, value: str) -> bool: + def always_less(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are always equal to `value`. + Returns whether the values of `self` are always less than `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are always equal to `value`, + `True` if the values of `self` are always less than `value`, `False` otherwise. MEOS Functions: - ttext_always_eq + always_lt_ttext_text, always_lt_temporal_temporal """ - return ttext_always_eq(self._inner, value) + if isinstance(value, str): + return always_lt_ttext_text(self._inner, value) > 0 + elif isinstance(value, TText): + return always_lt_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_not_equal(self, value: str) -> bool: + def always_less_or_equal(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are always not equal to `value`. + Returns whether the values of `self` are always less than or equal to + `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are always not equal to `value`, - `False` otherwise. + `True` if the values of `self` are always less than or equal to + `value`, `False` otherwise. MEOS Functions: - ttext_ever_eq + always_le_ttext_text, always_le_temporal_temporal """ - return not ttext_always_eq(self._inner, value) + if isinstance(value, str): + return always_le_ttext_text(self._inner, value) > 0 + elif isinstance(value, TText): + return always_le_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_less(self, value: str) -> bool: + def always_equal(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are always less than `value`. + Returns whether the values of `self` are always equal to `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are always less than `value`, + `True` if the values of `self` are always equal to `value`, `False` otherwise. MEOS Functions: - ttext_always_lt + always_eq_ttext_text, always_eq_temporal_temporal """ - return ttext_always_lt(self._inner, value) + if isinstance(value, str): + return always_eq_ttext_text(self._inner, value) > 0 + elif isinstance(value, TText): + return always_eq_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_less_or_equal(self, value: str) -> bool: + def always_not_equal(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are always less than or equal to - `value`. + Returns whether the values of `self` are always not equal to `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are always less than or equal to - `value`, `False` otherwise. + `True` if the values of `self` are always not equal to `value`, + `False` otherwise. MEOS Functions: - ttext_always_le + always_ne_ttext_text, always_ne_temporal_temporal """ - return ttext_always_le(self._inner, value) + if isinstance(value, str): + return always_ne_ttext_text(self._inner, value) > 0 + elif isinstance(value, TText): + return always_ne_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_greater(self, value: str) -> bool: + def always_greater_or_equal(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are always greater than `value`. + Returns whether the values of `self` are always greater than or equal + to `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are always greater than `value`, - `False` otherwise. + `True` if the values of `self` are always greater than or equal to + `value`, `False` otherwise. MEOS Functions: - ttext_ever_le + always_ge_ttext_text, always_ge_temporal_temporal """ - return not ttext_ever_le(self._inner, value) + if isinstance(value, str): + return always_ge_ttext_text(self._inner, value) > 0 + elif isinstance(value, TText): + return always_ge_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def always_greater_or_equal(self, value: str) -> bool: + def always_greater(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are always greater than or equal - to `value`. + Returns whether the values of `self` are always greater than `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are always greater than or equal to - `value`, `False` otherwise. + `True` if the values of `self` are always greater than `value`, + `False` otherwise. MEOS Functions: - ttext_ever_lt + always_gt_ttext_text, always_gt_temporal_temporal """ - return not ttext_ever_lt(self._inner, value) + if isinstance(value, str): + return always_gt_ttext_text(self._inner, value) > 0 + elif isinstance(value, TText): + return always_gt_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_equal(self, value: str) -> bool: + def ever_less(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are ever equal to `value`. + Returns whether the values of `self` are ever less than `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are ever equal to `value`, `False` + `True` if the values of `self` are ever less than `value`, `False` otherwise. MEOS Functions: - ttext_ever_eq + ever_lt_ttext_text, ever_lt_temporal_temporal """ - return ttext_ever_eq(self._inner, value) + if isinstance(value, str): + return ever_lt_ttext_text(self._inner, value) > 0 + elif isinstance(value, TText): + return ever_lt_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_not_equal(self, value: str) -> bool: + def ever_less_or_equal(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are ever not equal to `value`. + Returns whether the values of `self` are ever less than or equal to + `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are ever not equal to `value`, - `False` otherwise. + `True` if the values of `self` are ever less than or equal to + `value`, `False` otherwise. MEOS Functions: - ttext_always_eq + ever_le_ttext_text, ever_le_temporal_temporal """ - return not ttext_ever_eq(self._inner, value) + if isinstance(value, str): + return ever_le_ttext_text(self._inner, value) > 0 + elif isinstance(value, TText): + return ever_le_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_less(self, value: str) -> bool: + def ever_equal(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are ever less than `value`. + Returns whether the values of `self` are ever equal to `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are ever less than `value`, `False` + `True` if the values of `self` are ever equal to `value`, `False` otherwise. MEOS Functions: - ttext_ever_lt + ever_eq_ttext_text, ever_eq_temporal_temporal """ - return ttext_ever_lt(self._inner, value) + if isinstance(value, str): + return ever_eq_ttext_text(self._inner, value) > 0 + elif isinstance(value, TText): + return ever_eq_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_less_or_equal(self, value: str) -> bool: + def ever_not_equal(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are ever less than or equal to - `value`. + Returns whether the values of `self` are ever not equal to `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are ever less than or equal to - `value`, `False` otherwise. + `True` if the values of `self` are ever not equal to `value`, + `False` otherwise. MEOS Functions: - ttext_ever_le + ever_ne_ttext_text, ever_ne_temporal_temporal """ - return ttext_ever_le(self._inner, value) + if isinstance(value, str): + return ever_ne_ttext_text(self._inner, value) > 0 + elif isinstance(value, TText): + return ever_ne_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_greater(self, value: str) -> bool: + def ever_greater_or_equal(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are ever greater than `value`. + Returns whether the values of `self` are ever greater than or equal to + `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are ever greater than `value`, - `False` otherwise. + `True` if the values of `self` are ever greater than or equal to + `value`, `False` otherwise. MEOS Functions: - ttext_always_le + ever_ge_ttext_text, ever_ge_temporal_temporal """ - return not ttext_always_le(self._inner, value) + if isinstance(value, str): + return ever_ge_ttext_text(self._inner, value) > 0 + elif isinstance(value, TText): + return ever_ge_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def ever_greater_or_equal(self, value: str) -> bool: + def ever_greater(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are ever greater than or equal to - `value`. + Returns whether the values of `self` are ever greater than `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are ever greater than or equal to - `value`, `False` otherwise. + `True` if the values of `self` are ever greater than `value`, + `False` otherwise. MEOS Functions: - ttext_always_lt + ever_gt_ttext_text, ever_gt_temporal_temporal """ - return not ttext_always_lt(self._inner, value) + if isinstance(value, str): + return ever_gt_ttext_text(self._inner, value) > 0 + elif isinstance(value, TText): + return ever_gt_temporal_temporal(self._inner, value._inner) > 0 + else: + raise TypeError(f"Operation not supported with type {value.__class__}") - def never_equal(self, value: str) -> bool: + def never_less(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are never equal to `value`. + Returns whether the values of `self` are never less than `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are never equal to `value`, `False` + `True` if the values of `self` are never less than `value`, `False` otherwise. MEOS Functions: - ttext_ever_eq + ever_lt_ttext_text, ever_lt_temporal_temporal """ - return not ttext_ever_eq(self._inner, value) + return not self.ever_less(value) - def never_not_equal(self, value: str) -> bool: + def never_less_or_equal(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are never not equal to `value`. + Returns whether the values of `self` are never less than or equal to + `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are never not equal to `value`, - `False` otherwise. + `True` if the values of `self` are never less than or equal to + `value`, `False` otherwise. MEOS Functions: - ttext_always_eq + ever_le_ttext_text, ever_le_temporal_temporal """ - return ttext_always_eq(self._inner, value) + return not self.ever_less_or_equal(value) - def never_less(self, value: str) -> bool: + def never_equal(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are never less than `value`. + Returns whether the values of `self` are never equal to `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are never less than `value`, `False` + `True` if the values of `self` are never equal to `value`, `False` otherwise. MEOS Functions: - ttext_ever_lt + ever_eq_ttext_text, ever_eq_temporal_temporal """ - return not ttext_ever_lt(self._inner, value) + return not self.ever_equal(value) - def never_less_or_equal(self, value: str) -> bool: + def never_not_equal(self, value: Union[str, TText]) -> bool: """ - Returns whether the values of `self` are never less than or equal to - `value`. + Returns whether the values of `self` are never not equal to `value`. Args: value: String value to compare. Returns: - `True` if the values of `self` are never less than or equal to - `value`, `False` otherwise. + `True` if the values of `self` are never not equal to `value`, + `False` otherwise. MEOS Functions: - ttext_ever_le + ever_ne_ttext_text, ever_ne_temporal_temporal """ - return not ttext_ever_le(self._inner, value) + return not self.ever_not_equal(value) - def never_greater_or_equal(self, value: str) -> bool: + def never_greater_or_equal(self, value: Union[str, TText]) -> bool: """ Returns whether the values of `self` are never greater than or equal to `value`. @@ -498,11 +558,11 @@ def never_greater_or_equal(self, value: str) -> bool: `value`, `False` otherwise. MEOS Functions: - ttext_always_lt + ever_ge_ttext_text, ever_ge_temporal_temporal """ - return ttext_always_lt(self._inner, value) + return not self.ever_greater_or_equal(value) - def never_greater(self, value: str) -> bool: + def never_greater(self, value: Union[str, TText]) -> bool: """ Returns whether the values of `self` are never greater than `value`. @@ -514,9 +574,9 @@ def never_greater(self, value: str) -> bool: `False` otherwise. MEOS Functions: - ttext_always_le + ever_gt_ttext_text, ever_gt_temporal_temporal """ - return ttext_always_le(self._inner, value) + return not self.ever_greater(value) # ------------------------- Temporal Comparisons -------------------------- def temporal_equal(self, other: Union[str, TText]) -> TBool: From cac30919db3ab4779da0073b841737cadf797fdf Mon Sep 17 00:00:00 2001 From: Diviloper Date: Fri, 12 Jan 2024 23:42:38 +0100 Subject: [PATCH 22/37] Add string conversions to interpolation. --- pymeos/pymeos/temporal/interpolation.py | 14 ++++++++++++++ pymeos/pymeos/temporal/temporal.py | 4 ++-- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/pymeos/pymeos/temporal/interpolation.py b/pymeos/pymeos/temporal/interpolation.py index c1a75f8c..c3f18a50 100644 --- a/pymeos/pymeos/temporal/interpolation.py +++ b/pymeos/pymeos/temporal/interpolation.py @@ -14,6 +14,20 @@ class TInterpolation(IntEnum): STEPWISE = InterpolationType.STEP LINEAR = InterpolationType.LINEAR + def to_string(self) -> str: + """ + Returns a string representation of the interpolation type. + """ + + if self == InterpolationType.NONE: + return "None" + elif self == InterpolationType.DISCRETE: + return "Discrete" + elif self == InterpolationType.STEP: + return "Step" + elif self == InterpolationType.LINEAR: + return "Linear" + @staticmethod def from_string(source: str, none: bool = True) -> TInterpolation: """ diff --git a/pymeos/pymeos/temporal/temporal.py b/pymeos/pymeos/temporal/temporal.py index c526d061..ec60dd04 100644 --- a/pymeos/pymeos/temporal/temporal.py +++ b/pymeos/pymeos/temporal/temporal.py @@ -650,7 +650,7 @@ def to_sequence(self, interpolation: TInterpolation) -> TS: MEOS Functions: temporal_to_sequence """ - seq = temporal_to_tsequence(self._inner, interpolation) + seq = temporal_to_tsequence(self._inner, interpolation.to_string()) return Temporal._factory(seq) def to_sequenceset(self, interpolation: TInterpolation) -> TSS: @@ -660,7 +660,7 @@ def to_sequenceset(self, interpolation: TInterpolation) -> TSS: MEOS Functions: temporal_to_tsequenceset """ - ss = temporal_to_tsequenceset(self._inner, interpolation) + ss = temporal_to_tsequenceset(self._inner, interpolation.to_string()) return Temporal._factory(ss) def to_dataframe(self) -> pd.DataFrame: From dac9a680e86e7c94aaf59127df86bdf642e68a62 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Fri, 12 Jan 2024 23:45:33 +0100 Subject: [PATCH 23/37] Remove width function from base Span and update numspan width functions to use new specific ones --- pymeos/pymeos/collections/base/span.py | 12 ------------ pymeos/pymeos/collections/number/floatspan.py | 6 +++--- pymeos/pymeos/collections/number/floatspanset.py | 6 +++--- pymeos/pymeos/collections/number/intspan.py | 6 +++--- pymeos/pymeos/collections/number/intspanset.py | 6 +++--- pymeos/pymeos/collections/time/tstzspan.py | 12 ------------ pymeos/tests/collections/time/tstzspan_test.py | 4 ---- 7 files changed, 12 insertions(+), 40 deletions(-) diff --git a/pymeos/pymeos/collections/base/span.py b/pymeos/pymeos/collections/base/span.py index 5295e8de..2da9b64f 100644 --- a/pymeos/pymeos/collections/base/span.py +++ b/pymeos/pymeos/collections/base/span.py @@ -198,18 +198,6 @@ def upper_inc(self) -> bool: """ return span_upper_inc(self._inner) - def width(self) -> float: - """ - Returns the duration of the tstzspan. - - Returns: - Returns a `float` representing the duration of the tstzspan in seconds - - MEOS Functions: - span_width - """ - return span_width(self._inner) - def __hash__(self) -> int: """ Return the hash representation of ``self``. diff --git a/pymeos/pymeos/collections/number/floatspan.py b/pymeos/pymeos/collections/number/floatspan.py index 7c342b3b..f48186bb 100644 --- a/pymeos/pymeos/collections/number/floatspan.py +++ b/pymeos/pymeos/collections/number/floatspan.py @@ -27,7 +27,7 @@ union_spanset_span, floatspan_out, floatspan_make, - span_width, + floatspan_width, floatspan_to_intspan, ) @@ -143,9 +143,9 @@ def width(self) -> float: Returns a `float` representing the width of the span MEOS Functions: - span_width + floatspan_width """ - return span_width(self._inner) + return floatspan_width(self._inner) # ------------------------- Transformations ------------------------------- def shift(self, delta: float) -> FloatSpan: diff --git a/pymeos/pymeos/collections/number/floatspanset.py b/pymeos/pymeos/collections/number/floatspanset.py index 364990e6..b3cd54e0 100644 --- a/pymeos/pymeos/collections/number/floatspanset.py +++ b/pymeos/pymeos/collections/number/floatspanset.py @@ -5,7 +5,7 @@ from pymeos_cffi import ( floatspanset_in, floatspanset_out, - spanset_width, + floatspanset_width, floatspanset_shift_scale, adjacent_spanset_float, contains_spanset_float, @@ -120,9 +120,9 @@ def width(self, ignore_gaps: Optional[bool] = False) -> float: A `float` representing the duration of the spanset MEOS Functions: - spanset_width + floatspanset_width """ - return spanset_width(self._inner, ignore_gaps) + return floatspanset_width(self._inner, ignore_gaps) def start_span(self) -> FloatSpan: """ diff --git a/pymeos/pymeos/collections/number/intspan.py b/pymeos/pymeos/collections/number/intspan.py index 520f7a01..9dbea40d 100644 --- a/pymeos/pymeos/collections/number/intspan.py +++ b/pymeos/pymeos/collections/number/intspan.py @@ -9,7 +9,7 @@ intspan_shift_scale, contains_span_int, adjacent_span_int, - span_width, + intspan_width, int_to_span, span_eq, left_span_int, @@ -142,9 +142,9 @@ def width(self) -> float: Returns a `float` representing the width of the span MEOS Functions: - span_width + intspan_width """ - return span_width(self._inner) + return intspan_width(self._inner) # ------------------------- Transformations ------------------------------- def shift(self, delta: int) -> IntSpan: diff --git a/pymeos/pymeos/collections/number/intspanset.py b/pymeos/pymeos/collections/number/intspanset.py index ffa6769b..f938d942 100644 --- a/pymeos/pymeos/collections/number/intspanset.py +++ b/pymeos/pymeos/collections/number/intspanset.py @@ -5,7 +5,7 @@ from pymeos_cffi import ( intspanset_in, intspanset_out, - spanset_width, + intspanset_width, intspanset_shift_scale, adjacent_spanset_int, contains_spanset_int, @@ -118,9 +118,9 @@ def width(self, ignore_gaps: Optional[bool] = False) -> float: A `float` representing the duration of the spanset MEOS Functions: - spanset_width + intspanset_width """ - return spanset_width(self._inner, ignore_gaps) + return intspanset_width(self._inner, ignore_gaps) def start_span(self) -> IntSpan: """ diff --git a/pymeos/pymeos/collections/time/tstzspan.py b/pymeos/pymeos/collections/time/tstzspan.py index 8544c94b..428a17c1 100644 --- a/pymeos/pymeos/collections/time/tstzspan.py +++ b/pymeos/pymeos/collections/time/tstzspan.py @@ -119,18 +119,6 @@ def duration(self) -> timedelta: """ return interval_to_timedelta(tstzspan_duration(self._inner)) - def duration_in_seconds(self) -> float: - """ - Returns the duration of the tstzspan. - - Returns: - Returns a `float` representing the duration of the tstzspan in seconds - - MEOS Functions: - span_width - """ - return self.width() - # ------------------------- Transformations ------------------------------- def shift(self, delta: timedelta) -> TsTzSpan: """ diff --git a/pymeos/tests/collections/time/tstzspan_test.py b/pymeos/tests/collections/time/tstzspan_test.py index 54721ed9..c3fec24f 100644 --- a/pymeos/tests/collections/time/tstzspan_test.py +++ b/pymeos/tests/collections/time/tstzspan_test.py @@ -176,10 +176,6 @@ def test_duration(self): assert self.tstzspan.duration() == timedelta(days=2) assert self.tstzspan2.duration() == timedelta(days=2) - def test_duration_in_seconds(self): - assert self.tstzspan.duration_in_seconds() == 172800 - assert self.tstzspan2.duration_in_seconds() == 172800 - def test_hash(self): assert hash(self.tstzspan) From ee481c79a7675c5c9a76d086f08e23d979af0121 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Fri, 12 Jan 2024 23:46:00 +0100 Subject: [PATCH 24/37] Update distance functions to use updated API. --- pymeos/pymeos/collections/base/set.py | 19 ++------- pymeos/pymeos/collections/base/span.py | 16 ++------ pymeos/pymeos/collections/base/spanset.py | 18 ++------- pymeos/pymeos/collections/number/floatset.py | 31 ++++++++++++++- pymeos/pymeos/collections/number/floatspan.py | 25 ++++++++++-- .../pymeos/collections/number/floatspanset.py | 27 ++++++++++--- pymeos/pymeos/collections/number/intset.py | 25 +++++++++++- pymeos/pymeos/collections/number/intspan.py | 20 ++++++++-- .../pymeos/collections/number/intspanset.py | 20 ++++++++-- pymeos/pymeos/collections/time/dateset.py | 39 ++++++++++++++----- pymeos/pymeos/collections/time/datespan.py | 19 +++++++-- pymeos/pymeos/collections/time/datespanset.py | 25 ++++++++++-- pymeos/pymeos/collections/time/tstzset.py | 16 ++++++-- pymeos/pymeos/collections/time/tstzspan.py | 17 +++++++- pymeos/pymeos/collections/time/tstzspanset.py | 14 ++++++- pymeos/tests/collections/time/dateset_test.py | 8 ++-- pymeos/tests/main/tgeogpoint_test.py | 9 ++--- 17 files changed, 252 insertions(+), 96 deletions(-) diff --git a/pymeos/pymeos/collections/base/set.py b/pymeos/pymeos/collections/base/set.py index fceb8694..d482d224 100644 --- a/pymeos/pymeos/collections/base/set.py +++ b/pymeos/pymeos/collections/base/set.py @@ -428,7 +428,7 @@ def is_right(self, other) -> bool: raise TypeError(f"Operation not supported with type {other.__class__}") # ------------------------- Distance Operations --------------------------- - def distance(self, other) -> float: + def distance(self, other): """ Returns the distance between ``self`` and ``other``. @@ -436,22 +436,9 @@ def distance(self, other) -> float: other: object to compare with Returns: - A :class:`float` instance - - MEOS Functions: - distance_set_set, distance_span_span, distance_spanset_span + The distance metric in the appropriate format depending on the subclass. """ - from .span import Span - from .spanset import SpanSet - - if isinstance(other, Set): - return distance_set_set(self._inner, other._inner) - elif isinstance(other, Span): - return distance_span_span(set_span(self._inner), other._inner) - elif isinstance(other, SpanSet): - return distance_spanset_span(other._inner, set_span(self._inner)) - else: - raise TypeError(f"Operation not supported with type {other.__class__}") + raise TypeError(f"Operation not supported with type {other.__class__}") # ------------------------- Set Operations -------------------------------- @abstractmethod diff --git a/pymeos/pymeos/collections/base/span.py b/pymeos/pymeos/collections/base/span.py index 2da9b64f..42b6cc7f 100644 --- a/pymeos/pymeos/collections/base/span.py +++ b/pymeos/pymeos/collections/base/span.py @@ -437,7 +437,7 @@ def is_right(self, other) -> bool: raise TypeError(f"Operation not supported with type {other.__class__}") # ------------------------- Distance Operations --------------------------- - def distance(self, other) -> float: + def distance(self, other): """ Returns the distance between ``self`` and ``other``. @@ -445,19 +445,9 @@ def distance(self, other) -> float: other: object to compare with Returns: - A :class:`flat` instance - - MEOS Functions: - distance_span_span, distance_spanset_span + The distance metric in the appropriate format depending on the subclass. """ - from .spanset import SpanSet - - if isinstance(other, Span): - return distance_span_span(self._inner, other._inner) - elif isinstance(other, SpanSet): - return distance_spanset_span(other._inner, self._inner) - else: - raise TypeError(f"Operation not supported with type {other.__class__}") + raise TypeError(f"Operation not supported with type {other.__class__}") # ------------------------- Set Operations -------------------------------- @abstractmethod diff --git a/pymeos/pymeos/collections/base/spanset.py b/pymeos/pymeos/collections/base/spanset.py index 81da72f6..81d592ce 100644 --- a/pymeos/pymeos/collections/base/spanset.py +++ b/pymeos/pymeos/collections/base/spanset.py @@ -44,7 +44,7 @@ def __init__( self._inner = self.__class__._parse_function(string) else: spans = [self.__class__._parse_value_function(p) for p in span_list] - self._inner = spanset_make(spans, normalize) + self._inner = spanset_make(spans, normalize, True) def __copy__(self: Self) -> Self: """ @@ -439,7 +439,7 @@ def is_right(self, other) -> bool: raise TypeError(f"Operation not supported with type {other.__class__}") # ------------------------- Distance Operations --------------------------- - def distance(self, other) -> float: + def distance(self, other): """ Returns the distance between ``self`` and ``other``. @@ -447,19 +447,9 @@ def distance(self, other) -> float: other: object to compare with Returns: - A :class:`float` instance - - MEOS Functions: - distance_spanset_span, distance_spanset_spanset + The distance metric in the appropriate format depending on the subclass. """ - from .span import Span - - if isinstance(other, Span): - return distance_spanset_span(self._inner, other._inner) - elif isinstance(other, SpanSet): - return distance_spanset_spanset(self._inner, other._inner) - else: - raise TypeError(f"Operation not supported with type {other.__class__}") + raise TypeError(f"Operation not supported with type {other.__class__}") # ------------------------- Set Operations -------------------------------- @abstractmethod diff --git a/pymeos/pymeos/collections/number/floatset.py b/pymeos/pymeos/collections/number/floatset.py index 0aac60ab..e1f4de02 100644 --- a/pymeos/pymeos/collections/number/floatset.py +++ b/pymeos/pymeos/collections/number/floatset.py @@ -24,6 +24,7 @@ floatset_shift_scale, minus_float_set, distance_set_float, + distance_floatset_floatset, ) from .floatspan import FloatSpan @@ -392,8 +393,34 @@ def union(self, other: Union[FloatSet, float]) -> FloatSet: # ------------------------- Distance Operations --------------------------- - def distance(self, other: Union[float, FloatSet, FloatSpan, FloatSpanSet]) -> float: - if isinstance(other, float): + def distance( + self, other: Union[int, float, FloatSet, FloatSpan, FloatSpanSet] + ) -> float: + """ + Returns the distance between ``self`` and ``other``. + + Args: + other: object to compare with + + Returns: + A :class:`float` instance + + MEOS Functions: + distance_set_float, distance_floatset_floatset, + distance_floatspanset_floatspan, distance_floatspanset_floatspanset + """ + from .floatspan import FloatSpan + from .floatspanset import FloatSpanSet + + if isinstance(other, int): + return distance_set_float(self._inner, float(other)) + elif isinstance(other, float): return distance_set_float(self._inner, other) + elif isinstance(other, FloatSet): + return distance_floatset_floatset(self._inner, other._inner) + elif isinstance(other, FloatSpan): + return self.to_spanset().distance(other) + elif isinstance(other, FloatSpanSet): + return self.to_spanset().distance(other) else: return super().distance(other) diff --git a/pymeos/pymeos/collections/number/floatspan.py b/pymeos/pymeos/collections/number/floatspan.py index f48186bb..df7a4b1f 100644 --- a/pymeos/pymeos/collections/number/floatspan.py +++ b/pymeos/pymeos/collections/number/floatspan.py @@ -29,11 +29,14 @@ floatspan_make, floatspan_width, floatspan_to_intspan, + distance_floatspan_floatspan, + distance_floatspanset_floatspan, ) -from .. import Span +from ..base import Span if TYPE_CHECKING: + from .floatset import FloatSet from .floatspanset import FloatSpanSet from .intspan import IntSpan @@ -340,7 +343,9 @@ def is_over_or_right(self, other: Union[float, FloatSpan, FloatSpanSet]) -> bool return super().is_over_or_right(other) # ------------------------- Distance Operations --------------------------- - def distance(self, other: Union[int, float, FloatSpan, FloatSpanSet]) -> float: + def distance( + self, other: Union[int, float, FloatSet, FloatSpan, FloatSpanSet] + ) -> float: """ Returns the distance between ``self`` and ``other``. @@ -351,10 +356,22 @@ def distance(self, other: Union[int, float, FloatSpan, FloatSpanSet]) -> float: A float value MEOS Functions: - distance_span_span, distance_span_spanset, distance_span_float, + distance_span_float, distance_floatspan_floatspan, + distance_floatspanset_floatspan, """ - if isinstance(other, int) or isinstance(other, float): + from .floatset import FloatSet + from .floatspanset import FloatSpanSet + + if isinstance(other, int): return distance_span_float(self._inner, float(other)) + elif isinstance(other, float): + return distance_span_float(self._inner, other) + elif isinstance(other, FloatSet): + return self.distance(other.to_spanset()) + elif isinstance(other, FloatSpan): + return distance_floatspan_floatspan(self._inner, other._inner) + elif isinstance(other, FloatSpanSet): + return distance_floatspanset_floatspan(other._inner, self._inner) else: return super().distance(other) diff --git a/pymeos/pymeos/collections/number/floatspanset.py b/pymeos/pymeos/collections/number/floatspanset.py index b3cd54e0..ec67089a 100644 --- a/pymeos/pymeos/collections/number/floatspanset.py +++ b/pymeos/pymeos/collections/number/floatspanset.py @@ -20,11 +20,14 @@ union_spanset_float, minus_spanset_float, floatspanset_to_intspanset, + distance_floatspanset_floatspan, + distance_floatspanset_floatspanset, ) -from pymeos.collections import SpanSet +from ..base import SpanSet if TYPE_CHECKING: + from .floatset import FloatSet from .floatspan import FloatSpan from .intspanset import IntSpanSet @@ -372,7 +375,9 @@ def is_over_or_right(self, other: Union[int, FloatSpan, FloatSpanSet]) -> bool: return super().is_over_or_right(other) # ------------------------- Distance Operations --------------------------- - def distance(self, other: Union[int, FloatSpan, FloatSpanSet]) -> float: + def distance( + self, other: Union[int, float, FloatSet, FloatSpan, FloatSpanSet] + ) -> float: """ Returns the distance between ``self`` and ``other``. @@ -380,14 +385,26 @@ def distance(self, other: Union[int, FloatSpan, FloatSpanSet]) -> float: other: object to compare with Returns: - A float value + A :class:`float` value MEOS Functions: - distance_spanset_span, distance_spanset_spanset, - distance_spanset_float + distance_spanset_float, distance_floatspanset_floatspan, + distance_floatspanset_floatspanset + """ + from .floatset import FloatSet + from .floatspan import FloatSpan + if isinstance(other, int): + return distance_spanset_float(self._inner, float(other)) + elif isinstance(other, float): return distance_spanset_float(self._inner, other) + elif isinstance(other, FloatSet): + return self.distance(other.to_spanset()) + elif isinstance(other, FloatSpan): + return distance_floatspanset_floatspan(self._inner, other._inner) + elif isinstance(other, FloatSpanSet): + return distance_floatspanset_floatspanset(other._inner, self._inner) else: return super().distance(other) diff --git a/pymeos/pymeos/collections/number/intset.py b/pymeos/pymeos/collections/number/intset.py index 2317a1ba..47b6016b 100644 --- a/pymeos/pymeos/collections/number/intset.py +++ b/pymeos/pymeos/collections/number/intset.py @@ -24,6 +24,7 @@ intset_shift_scale, minus_int_set, distance_set_int, + distance_intset_intset, ) from .intspan import IntSpan @@ -391,8 +392,30 @@ def union(self, other: Union[IntSet, int]) -> IntSet: # ------------------------- Distance Operations --------------------------- - def distance(self, other: Union[int, IntSet, IntSpan, IntSpanSet]) -> float: + def distance(self, other: Union[int, IntSet, IntSpan, IntSpanSet]) -> int: + """ + Returns the distance between ``self`` and ``other``. + + Args: + other: object to compare with + + Returns: + A :class:`int` instance + + MEOS Functions: + distance_set_int, distance_intset_intset, distance_intspanset_intspan, + distance_intspanset_intspanset + """ + from .intspan import IntSpan + from .intspanset import IntSpanSet + if isinstance(other, int): return distance_set_int(self._inner, other) + elif isinstance(other, IntSet): + return distance_intset_intset(self._inner, other._inner) + elif isinstance(other, IntSpan): + return self.to_spanset().distance(other) + elif isinstance(other, IntSpanSet): + return self.to_spanset().distance(other) else: return super().distance(other) diff --git a/pymeos/pymeos/collections/number/intspan.py b/pymeos/pymeos/collections/number/intspan.py index 9dbea40d..49a7d34d 100644 --- a/pymeos/pymeos/collections/number/intspan.py +++ b/pymeos/pymeos/collections/number/intspan.py @@ -29,11 +29,14 @@ intspan_make, distance_span_int, intspan_to_floatspan, + distance_intspan_intspan, + distance_intspanset_intspan, ) -from .. import Span +from ..base import Span if TYPE_CHECKING: + from .intset import IntSet from .intspanset import IntSpanSet from .floatspan import FloatSpan @@ -336,7 +339,7 @@ def is_over_or_right(self, other: Union[int, IntSpan, IntSpanSet]) -> bool: return super().is_over_or_right(other) # ------------------------- Distance Operations --------------------------- - def distance(self, other: Union[int, IntSpan, IntSpanSet]) -> float: + def distance(self, other: Union[int, IntSet, IntSpan, IntSpanSet]) -> int: """ Returns the distance between ``self`` and ``other``. @@ -344,13 +347,22 @@ def distance(self, other: Union[int, IntSpan, IntSpanSet]) -> float: other: object to compare with Returns: - A float value + A :class:`int` value MEOS Functions: - distance_span_span, distance_span_spanset, distance_span_int, + distance_span_int, distance_intspanset_intspan, distance_intspanset_intspan, """ + from .intset import IntSet + from .intspanset import IntSpanSet + if isinstance(other, int): return distance_span_int(self._inner, other) + elif isinstance(other, IntSet): + return self.distance(other.to_spanset()) + elif isinstance(other, IntSpan): + return distance_intspan_intspan(self._inner, other._inner) + elif isinstance(other, IntSpanSet): + return distance_intspanset_intspan(other._inner, self._inner) else: return super().distance(other) diff --git a/pymeos/pymeos/collections/number/intspanset.py b/pymeos/pymeos/collections/number/intspanset.py index f938d942..36248423 100644 --- a/pymeos/pymeos/collections/number/intspanset.py +++ b/pymeos/pymeos/collections/number/intspanset.py @@ -20,11 +20,14 @@ union_spanset_int, minus_spanset_int, intspanset_to_floatspanset, + distance_intspanset_intspan, + distance_intspanset_intspanset, ) -from pymeos.collections import SpanSet +from ..base import SpanSet if TYPE_CHECKING: + from .intset import IntSet from .intspan import IntSpan from .floatspanset import FloatSpanSet @@ -370,7 +373,7 @@ def is_over_or_right(self, other: Union[int, IntSpan, IntSpanSet]) -> bool: return super().is_over_or_right(other) # ------------------------- Distance Operations --------------------------- - def distance(self, other: Union[int, IntSpan, IntSpanSet]) -> float: + def distance(self, other: Union[int, IntSet, IntSpan, IntSpanSet]) -> int: """ Returns the distance between ``self`` and ``other``. @@ -381,11 +384,20 @@ def distance(self, other: Union[int, IntSpan, IntSpanSet]) -> float: A float value MEOS Functions: - distance_spanset_span, distance_spanset_spanset, - distance_spanset_int + distance_spanset_int, distance_intspanset_intspan, + distance_intspanset_intspanset """ + from .intset import IntSet + from .intspan import IntSpan + if isinstance(other, int): return distance_spanset_int(self._inner, other) + elif isinstance(other, IntSet): + return self.distance(other.to_spanset()) + elif isinstance(other, IntSpan): + return distance_intspanset_intspan(self._inner, other._inner) + elif isinstance(other, IntSpanSet): + return distance_intspanset_intspanset(other._inner, self._inner) else: return super().distance(other) diff --git a/pymeos/pymeos/collections/time/dateset.py b/pymeos/pymeos/collections/time/dateset.py index 0b04aaa3..b97ae0f0 100644 --- a/pymeos/pymeos/collections/time/dateset.py +++ b/pymeos/pymeos/collections/time/dateset.py @@ -29,6 +29,7 @@ minus_date_set, union_set_date, union_set_set, + distance_dateset_dateset, ) from .timecollection import TimeCollection @@ -334,6 +335,8 @@ def overlaps(self, other: Union[date, DateSet, DateSpan, DateSpanSet]) -> bool: MEOS Functions: overlaps_set_set, overlaps_span_span, overlaps_spanset_spanset """ + from .datespan import DateSpan + from .datespanset import DateSpanSet if isinstance(other, date): return contains_set_date(self._inner, date_to_date_adt(other)) @@ -367,6 +370,8 @@ def is_left(self, other: TimeDate) -> bool: MEOS Functions: before_set_date, left_span_span """ + from .datespan import DateSpan + from .datespanset import DateSpanSet if isinstance(other, date): return before_set_date(self._inner, date_to_date_adt(other)) @@ -399,6 +404,9 @@ def is_over_or_left(self, other: TimeDate) -> bool: MEOS Functions: overbefore_set_date, overleft_span_span, overleft_span_spanset """ + from .datespan import DateSpan + from .datespanset import DateSpanSet + if isinstance(other, date): return overbefore_set_date(self._inner, date_to_date_adt(other)) elif isinstance(other, DateSpan): @@ -430,6 +438,9 @@ def is_over_or_right(self, other: TimeDate) -> bool: MEOS Functions: overafter_set_date, overright_span_span, overright_span_spanset """ + from .datespan import DateSpan + from .datespanset import DateSpanSet + if isinstance(other, date): return overafter_set_date(self._inner, date_to_date_adt(other)) elif isinstance(other, DateSpan): @@ -461,6 +472,9 @@ def is_right(self, other: TimeDate) -> bool: MEOS Functions: after_set_date, right_span_span, right_span_spanset """ + from .datespan import DateSpan + from .datespanset import DateSpanSet + if isinstance(other, date): return after_set_date(self._inner, date_to_date_adt(other)) elif isinstance(other, DateSpan): @@ -482,24 +496,31 @@ def distance(self, other: TimeDate) -> timedelta: A :class:`datetime.timedelta` instance MEOS Functions: - distance_set_timestamptz, distance_set_set, - distance_span_span, distance_spanset_span + distance_set_date, distance_dateset_dateset, + distance_datespanset_datespan, distance_datespanset_datespanset """ + from .datespan import DateSpan + from .datespanset import DateSpanSet if isinstance(other, date): return timedelta( - seconds=distance_set_date(self._inner, date_to_date_adt(other)) + days=distance_set_date(self._inner, date_to_date_adt(other)) + ) + elif isinstance(other, DateSet): + return timedelta( + days=distance_dateset_dateset(self._inner, other._inner) ) + elif isinstance(other, DateSpan): + return self.to_spanset().distance(other) + elif isinstance(other, DateSpanSet): + return self.to_spanset().distance(other) else: - return timedelta(seconds=super().distance(other)) + return super().distance(other) # ------------------------- Set Operations -------------------------------- - @overload - def intersection(self, other: date) -> Optional[date]: - ... @overload - def intersection(self, other: DateSet) -> Optional[DateSet]: + def intersection(self, other: Union[date, DateSet]) -> Optional[DateSet]: ... @overload @@ -527,7 +548,7 @@ def intersection(self, other: TimeDate) -> Optional[TimeDate]: if isinstance(other, date): result = intersection_set_date(self._inner, date_to_date_adt(other)) - return date_adt_to_date(result) if result is not None else None + return DateSet(_inner=result) if result is not None else None elif isinstance(other, DateSet): result = intersection_set_set(self._inner, other._inner) return DateSet(_inner=result) if result is not None else None diff --git a/pymeos/pymeos/collections/time/datespan.py b/pymeos/pymeos/collections/time/datespan.py index 5e189647..85c57b4b 100644 --- a/pymeos/pymeos/collections/time/datespan.py +++ b/pymeos/pymeos/collections/time/datespan.py @@ -3,6 +3,7 @@ from datetime import date, timedelta from typing import TYPE_CHECKING, Union, Optional, overload +from _meos_cffi.lib import distance_datespanset_datespan from dateutil.parser import parse from pymeos_cffi import ( adjacent_span_date, @@ -460,18 +461,28 @@ def distance(self, other: TimeDate) -> timedelta: A :class:`datetime.timedelta` instance MEOS Functions: - distance_span_span, distance_spanset_span, distance_span_date + distance_span_date, distance_datespanset_datespan, + distance_datespanset_datespan """ from .dateset import DateSet + from .datespanset import DateSpanSet if isinstance(other, date): return timedelta( - seconds=distance_span_date(self._inner, date_to_date_adt(other)) + days=distance_span_date(self._inner, date_to_date_adt(other)) ) elif isinstance(other, DateSet): - return self.distance(other.to_span()) + return self.distance(other.to_spanset()) + elif isinstance(other, DateSpan): + return timedelta( + days=distance_datespanset_datespan(self._inner, other._inner) + ) + elif isinstance(other, DateSpanSet): + return timedelta( + days=distance_datespanset_datespan(self._inner, other._inner) + ) else: - return timedelta(seconds=super().distance(other)) + return super().distance(other) # ------------------------- Set Operations -------------------------------- @overload diff --git a/pymeos/pymeos/collections/time/datespanset.py b/pymeos/pymeos/collections/time/datespanset.py index bbdcb6bb..f4118ad9 100644 --- a/pymeos/pymeos/collections/time/datespanset.py +++ b/pymeos/pymeos/collections/time/datespanset.py @@ -4,6 +4,10 @@ from typing import Optional, Union, List, overload from typing import TYPE_CHECKING +from _meos_cffi.lib import ( + distance_datespanset_datespan, + distance_datespanset_datespanset, +) from pymeos_cffi import ( datespanset_in, datespan_in, @@ -506,7 +510,7 @@ def is_right(self, other: Union[TimeDate]) -> bool: return super().is_right(other) # ------------------------- Distance Operations --------------------------- - def distance(self, other: Union[TimeDate]) -> timedelta: + def distance(self, other: TimeDate) -> timedelta: """ Returns the temporal distance between ``self`` and ``other``. @@ -517,15 +521,28 @@ def distance(self, other: Union[TimeDate]) -> timedelta: A :class:`datetime.timedelta` instance MEOS Functions: - distance_spanset_span, distance_spanset_spanset, distance_spanset_date + distance_spanset_date, distance_datespanset_datespan, + distance_datespanset_datespanset """ + from .dateset import DateSet + from .datespan import DateSpan if isinstance(other, date): return timedelta( - seconds=distance_spanset_date(self._inner, date_to_date_adt(other)) + days=distance_spanset_date(self._inner, date_to_date_adt(other)) + ) + elif isinstance(other, DateSet): + return self.distance(other.to_spanset()) + elif isinstance(other, DateSpan): + return timedelta( + days=distance_datespanset_datespan(self._inner, other._inner) + ) + elif isinstance(other, DateSpanSet): + return timedelta( + days=distance_datespanset_datespanset(self._inner, other._inner) ) else: - return timedelta(seconds=super().distance(other)) + return super().distance(other) # ------------------------- Set Operations -------------------------------- diff --git a/pymeos/pymeos/collections/time/tstzset.py b/pymeos/pymeos/collections/time/tstzset.py index 105ebd1f..06f009d6 100644 --- a/pymeos/pymeos/collections/time/tstzset.py +++ b/pymeos/pymeos/collections/time/tstzset.py @@ -528,9 +528,11 @@ def distance(self, other: Union[Time, Temporal, Box]) -> timedelta: A :class:`datetime.timedelta` instance MEOS Functions: - distance_set_timestamptz, distance_set_set, - distance_span_span, distance_spanset_span + distance_set_timestamptz, distance_tstzset_tstzset, + distance_tstzspanset_tstzspan, distance_tstzspanset_tstzspanset """ + from .tstzspan import TsTzSpan + from .tstzspanset import TsTzSpanSet from ...temporal import Temporal from ...boxes import Box @@ -540,12 +542,20 @@ def distance(self, other: Union[Time, Temporal, Box]) -> timedelta: self._inner, datetime_to_timestamptz(other) ) ) + elif isinstance(other, TsTzSet): + return timedelta( + seconds=distance_tstzset_tstzset(self._inner, other._inner) + ) + elif isinstance(other, TsTzSpan): + return self.to_spanset().distance(other) + elif isinstance(other, TsTzSpanSet): + return self.to_spanset().distance(other) elif isinstance(other, Temporal): return self.to_span().distance(other) elif isinstance(other, get_args(Box)): return self.to_span().distance(other) else: - return timedelta(seconds=super().distance(other)) + return super().distance(other) # ------------------------- Set Operations -------------------------------- @overload diff --git a/pymeos/pymeos/collections/time/tstzspan.py b/pymeos/pymeos/collections/time/tstzspan.py index 428a17c1..9e553ca1 100644 --- a/pymeos/pymeos/collections/time/tstzspan.py +++ b/pymeos/pymeos/collections/time/tstzspan.py @@ -523,8 +523,11 @@ def distance(self, other: Union[Time, Box, Temporal]) -> timedelta: A :class:`datetime.timedelta` instance MEOS Functions: - distance_span_span, distance_spanset_span, distance_span_timestamptz + distance_span_timestamptz, distance_tstzspan_tstzspan, + distance_tstzspanset_tstzspan """ + from .tstzset import TsTzSet + from .tstzspanset import TsTzSpanSet from ...temporal import Temporal from ...boxes import Box @@ -534,12 +537,22 @@ def distance(self, other: Union[Time, Box, Temporal]) -> timedelta: self._inner, datetime_to_timestamptz(other) ) ) + elif isinstance(other, TsTzSet): + return self.distance(other.to_spanset()) + elif isinstance(other, TsTzSpan): + return timedelta( + seconds=distance_tstzspan_tstzspan(self._inner, other._inner) + ) + elif isinstance(other, TsTzSpanSet): + return timedelta( + seconds=distance_tstzspanset_tstzspan(other._inner, self._inner) + ) elif isinstance(other, Temporal): return self.distance(other.tstzspan()) elif isinstance(other, get_args(Box)): return self.distance(other.to_tstzspan()) else: - return timedelta(seconds=super().distance(other)) + return super().distance(other) # ------------------------- Set Operations -------------------------------- @overload diff --git a/pymeos/pymeos/collections/time/tstzspanset.py b/pymeos/pymeos/collections/time/tstzspanset.py index ecf98c7a..9e938d7c 100644 --- a/pymeos/pymeos/collections/time/tstzspanset.py +++ b/pymeos/pymeos/collections/time/tstzspanset.py @@ -647,6 +647,8 @@ def distance(self, other: Union[Time, Box, Temporal]) -> timedelta: distance_tstzspanset_tstzspan, distance_tstzspanset_tstzspanset, distance_spanset_timestamptz, distance_tstzspanset_tstzset """ + from .tstzset import TsTzSet + from .tstzspan import TsTzSpan from ...temporal import Temporal from ...boxes import Box @@ -656,12 +658,22 @@ def distance(self, other: Union[Time, Box, Temporal]) -> timedelta: self._inner, datetime_to_timestamptz(other) ) ) + elif isinstance(other, TsTzSet): + return self.distance(other.to_spanset()) + elif isinstance(other, TsTzSpan): + return timedelta( + seconds=distance_tstzspanset_tstzspan(self._inner, other._inner) + ) + elif isinstance(other, TsTzSpanSet): + return timedelta( + seconds=distance_tstzspanset_tstzspanset(self._inner, other._inner) + ) if isinstance(other, Temporal): return self.distance(other.tstzspan()) elif isinstance(other, get_args(Box)): return self.distance(other.to_tstzspan()) else: - return timedelta(seconds=super().distance(other)) + return super().distance(other) # ------------------------- Set Operations -------------------------------- @overload diff --git a/pymeos/tests/collections/time/dateset_test.py b/pymeos/tests/collections/time/dateset_test.py index fd37723c..fa5ce36b 100644 --- a/pymeos/tests/collections/time/dateset_test.py +++ b/pymeos/tests/collections/time/dateset_test.py @@ -74,7 +74,7 @@ def test_to_spanset(self): class TestDateSetAccessors(TestDateSet): def test_duration(self): - assert self.date_set.duration() == timedelta(days=2) + assert self.date_set.duration() == timedelta(days=3) def test_num_elements(self): assert self.date_set.num_elements() == 3 @@ -102,7 +102,7 @@ def test_elements(self): class TestDateSetPositionFunctions(TestDateSet): - date_value = date(year=2020, month=1, day=25) + date_value = date(year=2019, month=9, day=25) other_date_set = DateSet("{2020-01-01, 2020-01-31}") @pytest.mark.parametrize( @@ -120,7 +120,7 @@ def test_is_contained_in(self, other, expected): ) def test_contains(self, other, expected): assert self.date_set.contains(other) == expected - assert other in self.date_set == expected + assert (other in self.date_set) == expected @pytest.mark.parametrize( "other", @@ -258,7 +258,7 @@ def test_shift(self, delta, expected): ids=["timedelta", "int"], ) def test_scale(self, delta): - expected = DateSet("{2020-1-1, 2020-1-3, 2020-1-7}") + expected = DateSet("{2020-1-1, 2020-1-3, 2020-1-8}") scaled = self.dateset.scale(delta) diff --git a/pymeos/tests/main/tgeogpoint_test.py b/pymeos/tests/main/tgeogpoint_test.py index a8d1fcf5..2cdbc568 100644 --- a/pymeos/tests/main/tgeogpoint_test.py +++ b/pymeos/tests/main/tgeogpoint_test.py @@ -1,22 +1,19 @@ from copy import copy -from operator import not_ from datetime import datetime, timezone, timedelta +from operator import not_ -import pytest import numpy as np -from shapely import Point, LineString +import pytest import shapely.geometry +from shapely import Point, LineString from pymeos import ( - TBool, TBoolInst, TBoolSeq, TBoolSeqSet, - TFloat, TFloatInst, TFloatSeq, TFloatSeqSet, - TGeomPoint, TGeomPointInst, TGeomPointSeq, TGeomPointSeqSet, From ed74c116e13c14ef1387ec4f94a5278c9db4894d Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 28 Jan 2024 12:26:14 +0100 Subject: [PATCH 25/37] Sync with MEOS: - NAD TBox - Dateset value n - Temporal from MFJSON --- pymeos/pymeos/boxes/tbox.py | 13 +- pymeos/pymeos/collections/time/dateset.py | 2 +- pymeos/pymeos/main/tbool.py | 22 +- pymeos/pymeos/main/tfloat.py | 23 +- pymeos/pymeos/main/tint.py | 23 +- pymeos/pymeos/main/tpoint.py | 36 ++ pymeos/pymeos/main/ttext.py | 23 +- pymeos/pymeos/temporal/temporal.py | 31 +- pymeos_cffi/pymeos_cffi/__init__.py | 91 +++- pymeos_cffi/pymeos_cffi/builder/meos.h | 105 +++- pymeos_cffi/pymeos_cffi/functions.py | 622 +++++++++++++++++----- 11 files changed, 790 insertions(+), 201 deletions(-) diff --git a/pymeos/pymeos/boxes/tbox.py b/pymeos/pymeos/boxes/tbox.py index 53efc6b6..204841f9 100644 --- a/pymeos/pymeos/boxes/tbox.py +++ b/pymeos/pymeos/boxes/tbox.py @@ -4,8 +4,8 @@ from pymeos_cffi import * -from ..main import TNumber from ..collections import * +from ..main import TNumber, TInt, TFloat class TBox: @@ -1081,9 +1081,14 @@ def nearest_approach_distance(self, other: Union[TBox, TNumber]) -> float: nad_tbox_tbox """ if isinstance(other, TBox): - return nad_tbox_tbox(self._inner, other._inner) - elif isinstance(other, TNumber): - return nad_tnumber_tbox(other._inner, self._inner) + if self._is_float(): + return nad_tboxfloat_tboxfloat(self._inner, other._inner) + else: + return nad_tboxint_tboxint(self._inner, other._inner) + elif isinstance(other, TInt): + return nad_tint_tbox(other._inner, self._inner) + elif isinstance(other, TFloat): + return nad_tfloat_tbox(other._inner, self._inner) else: raise TypeError(f"Operation not supported with type {other.__class__}") diff --git a/pymeos/pymeos/collections/time/dateset.py b/pymeos/pymeos/collections/time/dateset.py index b97ae0f0..1e98954f 100644 --- a/pymeos/pymeos/collections/time/dateset.py +++ b/pymeos/pymeos/collections/time/dateset.py @@ -157,7 +157,7 @@ def element_n(self, n: int) -> date: dateset_value_n """ super().element_n(n) - return date_adt_to_date(dateset_value_n(self._inner, n + 1)) + return date_adt_to_date(dateset_value_n(self._inner, n + 1)[0]) def elements(self) -> List[date]: """ diff --git a/pymeos/pymeos/main/tbool.py b/pymeos/pymeos/main/tbool.py index 6d70798d..0a8feefa 100644 --- a/pymeos/pymeos/main/tbool.py +++ b/pymeos/pymeos/main/tbool.py @@ -1,13 +1,15 @@ from __future__ import annotations from abc import ABC -from typing import Optional, Union, List, Set, overload +from typing import Optional, Union, List, Set, overload, Type, TypeVar from pymeos_cffi import * from ..collections import * from ..temporal import TInterpolation, Temporal, TInstant, TSequence, TSequenceSet +Self = TypeVar("Self", bound="TBool") + class TBool(Temporal[bool, "TBool", "TBoolInst", "TBoolSeq", "TBoolSeqSet"], ABC): """ @@ -87,6 +89,24 @@ def from_base_time(value: bool, base: Time) -> TBool: ) raise TypeError(f"Operation not supported with type {base.__class__}") + @classmethod + def from_mfjson(cls: Type[Self], mfjson: str) -> Self: + """ + Returns a temporal object from a MF-JSON string. + + Args: + mfjson: The MF-JSON string. + + Returns: + A temporal object from a MF-JSON string. + + MEOS Functions: + tbool_from_mfjson + """ + + result = tbool_from_mfjson(mfjson) + return Temporal._factory(result) + # ------------------------- Output ---------------------------------------- def __str__(self): """ diff --git a/pymeos/pymeos/main/tfloat.py b/pymeos/pymeos/main/tfloat.py index a2394c95..e55b962e 100644 --- a/pymeos/pymeos/main/tfloat.py +++ b/pymeos/pymeos/main/tfloat.py @@ -1,7 +1,7 @@ from __future__ import annotations from abc import ABC -from typing import Optional, List, Union, TYPE_CHECKING, Set, overload +from typing import Optional, List, Union, TYPE_CHECKING, Set, overload, Type, TypeVar from pymeos_cffi import * @@ -16,6 +16,9 @@ from .tbool import TBool +Self = TypeVar("Self", bound="TFloat") + + class TFloat( TNumber[float, "TFloat", "TFloatInst", "TFloatSeq", "TFloatSeqSet"], TSimplifiable, @@ -118,6 +121,24 @@ def from_base_time( ) raise TypeError(f"Operation not supported with type {base.__class__}") + @classmethod + def from_mfjson(cls: Type[Self], mfjson: str) -> Self: + """ + Returns a temporal object from a MF-JSON string. + + Args: + mfjson: The MF-JSON string. + + Returns: + A temporal object from a MF-JSON string. + + MEOS Functions: + tfloat_from_mfjson + """ + + result = tfloat_from_mfjson(mfjson) + return Temporal._factory(result) + # ------------------------- Output ---------------------------------------- def __str__(self, max_decimals: int = 15): """ diff --git a/pymeos/pymeos/main/tint.py b/pymeos/pymeos/main/tint.py index 030cc73a..a409818c 100644 --- a/pymeos/pymeos/main/tint.py +++ b/pymeos/pymeos/main/tint.py @@ -1,7 +1,7 @@ from __future__ import annotations from abc import ABC -from typing import Optional, Union, List, TYPE_CHECKING, Set, overload +from typing import Optional, Union, List, TYPE_CHECKING, Set, overload, TypeVar, Type from pymeos_cffi import * @@ -16,6 +16,9 @@ from .tbool import TBool +Self = TypeVar("Self", bound="TInt") + + class TInt( TNumber[int, "TInt", "TIntInst", "TIntSeq", "TIntSeqSet"], TTemporallyComparable, @@ -90,6 +93,24 @@ def from_base_time(value: int, base: Time) -> TInt: ) raise TypeError(f"Operation not supported with type {base.__class__}") + @classmethod + def from_mfjson(cls: Type[Self], mfjson: str) -> Self: + """ + Returns a temporal object from a MF-JSON string. + + Args: + mfjson: The MF-JSON string. + + Returns: + A temporal object from a MF-JSON string. + + MEOS Functions: + tint_from_mfjson + """ + + result = tint_from_mfjson(mfjson) + return Temporal._factory(result) + # ------------------------- Output ---------------------------------------- def __str__(self): """ diff --git a/pymeos/pymeos/main/tpoint.py b/pymeos/pymeos/main/tpoint.py index 456cf9ca..2d4d19dd 100644 --- a/pymeos/pymeos/main/tpoint.py +++ b/pymeos/pymeos/main/tpoint.py @@ -1472,6 +1472,24 @@ def from_base_time( ) raise TypeError(f"Operation not supported with type {base.__class__}") + @classmethod + def from_mfjson(cls: Type[Self], mfjson: str) -> Self: + """ + Returns a temporal object from a MF-JSON string. + + Args: + mfjson: The MF-JSON string. + + Returns: + A temporal object from a MF-JSON string. + + MEOS Functions: + tgeompoint_from_mfjson + """ + + result = tgeompoint_from_mfjson(mfjson) + return Temporal._factory(result) + # ------------------------- Conversions ---------------------------------- def to_geographic(self) -> TGeogPoint: """ @@ -1785,6 +1803,24 @@ def from_base_time( ) raise TypeError(f"Operation not supported with type {base.__class__}") + @classmethod + def from_mfjson(cls: Type[Self], mfjson: str) -> Self: + """ + Returns a temporal object from a MF-JSON string. + + Args: + mfjson: The MF-JSON string. + + Returns: + A temporal object from a MF-JSON string. + + MEOS Functions: + tgeogpoint_from_mfjson + """ + + result = tgeogpoint_from_mfjson(mfjson) + return Temporal._factory(result) + # ------------------------- Conversions ---------------------------------- def to_geometric(self) -> TGeomPoint: """ diff --git a/pymeos/pymeos/main/ttext.py b/pymeos/pymeos/main/ttext.py index 6f347e6d..ef373c73 100644 --- a/pymeos/pymeos/main/ttext.py +++ b/pymeos/pymeos/main/ttext.py @@ -1,7 +1,7 @@ from __future__ import annotations from abc import ABC -from typing import Optional, Union, List, Set, overload, TYPE_CHECKING +from typing import Optional, Union, List, Set, overload, TYPE_CHECKING, TypeVar, Type from pymeos_cffi import * @@ -13,6 +13,9 @@ from .tbool import TBool +Self = TypeVar("Self", bound="TText") + + class TText( Temporal[str, "TText", "TTextInst", "TTextSeq", "TTextSeqSet"], TTemporallyComparable, @@ -92,6 +95,24 @@ def from_base_time(value: str, base: Time) -> TText: ) raise TypeError(f"Operation not supported with type {base.__class__}") + @classmethod + def from_mfjson(cls: Type[Self], mfjson: str) -> Self: + """ + Returns a temporal object from a MF-JSON string. + + Args: + mfjson: The MF-JSON string. + + Returns: + A temporal object from a MF-JSON string. + + MEOS Functions: + ttext_from_mfjson + """ + + result = ttext_from_mfjson(mfjson) + return Temporal._factory(result) + # ------------------------- Output ---------------------------------------- def __str__(self) -> str: """ diff --git a/pymeos/pymeos/temporal/temporal.py b/pymeos/pymeos/temporal/temporal.py index ec60dd04..6ee3b3ec 100644 --- a/pymeos/pymeos/temporal/temporal.py +++ b/pymeos/pymeos/temporal/temporal.py @@ -96,6 +96,20 @@ def from_base_time(value: TBase, base: Time) -> TG: """ pass + @classmethod + @abstractmethod + def from_mfjson(cls: Type[Self], mfjson: str) -> Self: + """ + Returns a temporal object from a MF-JSON string. + + Args: + mfjson: The MF-JSON string. + + Returns: + A temporal object from a MF-JSON string. + """ + pass + @classmethod def from_wkb(cls: Type[Self], wkb: bytes) -> Self: """ @@ -130,23 +144,6 @@ def from_hexwkb(cls: Type[Self], hexwkb: str) -> Self: result = temporal_from_hexwkb(hexwkb) return Temporal._factory(result) - @classmethod - def from_mfjson(cls: Type[Self], mfjson: str) -> Self: - """ - Returns a temporal object from a MF-JSON string. - - Args: - mfjson: The MF-JSON string. - - Returns: - A temporal object from a MF-JSON string. - - MEOS Functions: - temporal_from_mfjson - """ - result = temporal_from_mfjson(mfjson) - return Temporal._factory(result) - @classmethod def from_merge(cls: Type[Self], *temporals: TG) -> Self: """ diff --git a/pymeos_cffi/pymeos_cffi/__init__.py b/pymeos_cffi/pymeos_cffi/__init__.py index 70cecf68..4950d4a0 100644 --- a/pymeos_cffi/pymeos_cffi/__init__.py +++ b/pymeos_cffi/pymeos_cffi/__init__.py @@ -98,7 +98,11 @@ "text2cstring", "text_cmp", "text_copy", + "text_initcap", + "text_lower", "text_out", + "text_upper", + "textcat_text_text", "timestamptz_to_date", "geo_as_ewkb", "geo_as_ewkt", @@ -302,6 +306,8 @@ "dateset_shift_scale", "datespan_shift_scale", "datespanset_shift_scale", + "floatset_degrees", + "floatset_radians", "floatset_round", "floatset_shift_scale", "floatspan_round", @@ -310,11 +316,18 @@ "floatspanset_shift_scale", "geoset_round", "geoset_set_srid", + "geoset_transform", + "geoset_transform_pipeline", + "point_transform", + "point_transform_pipeline", "intset_shift_scale", "intspan_shift_scale", "intspanset_shift_scale", + "textset_initcap", "textset_lower", "textset_upper", + "textcat_textset_text", + "textcat_text_textset", "timestamptz_tprecision", "tstzset_shift_scale", "tstzset_tprecision", @@ -750,7 +763,6 @@ "stbox_to_box3d", "stbox_to_geo", "stbox_to_tstzspan", - "tstzspanset_to_tbox", "tbox_to_intspan", "tbox_to_floatspan", "tbox_to_tstzspan", @@ -797,6 +809,8 @@ "stbox_round", "stbox_set_srid", "stbox_shift_scale_time", + "stbox_transform", + "stbox_transform_pipeline", "tbox_expand_time", "tbox_expand_float", "tbox_expand_int", @@ -857,24 +871,29 @@ "stbox_ge", "stbox_gt", "tbool_in", - "tbool_out", - "temporal_as_hexwkb", - "temporal_as_mfjson", - "temporal_as_wkb", - "temporal_from_hexwkb", - "temporal_from_mfjson", - "temporal_from_wkb", + "tint_in", "tfloat_in", - "tfloat_out", - "tgeogpoint_in", + "ttext_in", "tgeompoint_in", - "tint_in", + "tgeogpoint_in", + "tbool_from_mfjson", + "tint_from_mfjson", + "tfloat_from_mfjson", + "ttext_from_mfjson", + "tgeompoint_from_mfjson", + "tgeogpoint_from_mfjson", + "temporal_from_wkb", + "temporal_from_hexwkb", + "tbool_out", "tint_out", - "tpoint_as_ewkt", - "tpoint_as_text", - "tpoint_out", - "ttext_in", + "tfloat_out", "ttext_out", + "tpoint_out", + "tpoint_as_text", + "tpoint_as_ewkt", + "temporal_as_mfjson", + "temporal_as_wkb", + "temporal_as_hexwkb", "tbool_from_base_temp", "tboolinst_make", "tboolseq_from_base_tstzset", @@ -982,6 +1001,8 @@ "tint_shift_scale_value", "tint_shift_value", "tpoint_round", + "tpoint_transform", + "tpoint_transform_pipeline", "tpointarr_round", "temporal_append_tinstant", "temporal_append_tsequence", @@ -1374,6 +1395,7 @@ "textcat_ttext_ttext", "ttext_upper", "ttext_lower", + "ttext_initcap", "distance_tfloat_float", "distance_tint_int", "distance_tnumber_tnumber", @@ -1381,12 +1403,14 @@ "distance_tpoint_tpoint", "nad_stbox_geo", "nad_stbox_stbox", - "nad_tbox_tbox", - "nad_tfloat_float", - "nad_tfloat_tfloat", "nad_tint_int", + "nad_tint_tbox", "nad_tint_tint", - "nad_tnumber_tbox", + "nad_tboxint_tboxint", + "nad_tfloat_float", + "nad_tfloat_tfloat", + "nad_tfloat_tbox", + "nad_tboxfloat_tboxfloat", "nad_tpoint_geo", "nad_tpoint_stbox", "nad_tpoint_tpoint", @@ -1573,6 +1597,8 @@ "tgeo_type", "ensure_tgeo_type", "ensure_tnumber_tgeo_type", + "datum_degrees", + "datum_radians", "datum_hash", "datum_hash_extended", "set_in", @@ -1591,15 +1617,19 @@ "spanset_cp", "spanset_make_exp", "spanset_make_free", + "dateset_tstzset", "datespan_tstzspan", "datespanset_tstzspanset", - "intspan_floatspan", - "intspanset_floatspanset", + "floatset_intset", "floatspan_intspan", "floatspanset_intspanset", + "intset_floatset", + "intspan_floatspan", + "intspanset_floatspanset", "set_span", "set_spanset", "span_spanset", + "tstzset_dateset", "tstzspan_datespan", "tstzspanset_datespanset", "value_set_span", @@ -1621,7 +1651,11 @@ "spanset_sps", "spanset_upper", "datespan_set_tstzspan", + "floatset_deg", + "floatset_rad", + "floatset_rnd", "floatspan_rnd", + "floatspanset_rnd", "floatspan_set_intspan", "intspan_set_floatspan", "numset_shift_scale", @@ -1630,7 +1664,14 @@ "set_compact", "span_expand", "spanset_compact", + "textcat_textset_text_int", "tstzspan_set_datespan", + "set_cmp_int", + "set_eq_int", + "span_cmp_int", + "span_eq_int", + "spanset_cmp_int", + "spanset_eq_int", "adj_span_span", "adjacent_span_value", "adjacent_spanset_value", @@ -1809,10 +1850,12 @@ "ttextseqset_as_mfjson", "ttextseqset_from_mfjson", "ttextseqset_in", + "temporal_from_mfjson", "temporal_cp", "temporal_from_base_temp", "tinstant_copy", "tinstant_make", + "tinstant_make_free", "tpointseq_make_coords", "tsequence_copy", "tsequence_from_base_tstzset", @@ -1843,7 +1886,6 @@ "tinstant_hash", "tinstant_insts", "tinstant_set_bbox", - "tinstant_set_tstzspan", "tinstant_time", "tinstant_timestamps", "tinstant_val", @@ -1898,6 +1940,7 @@ "temporal_tsequenceset", "tinstant_shift_time", "tinstant_to_tsequence", + "tinstant_to_tsequence_free", "tinstant_to_tsequenceset", "tnumber_shift_scale_value", "tnumberinst_shift_value", @@ -1910,6 +1953,7 @@ "tsequence_subseq", "tsequence_to_tinstant", "tsequence_to_tsequenceset", + "tsequence_to_tsequenceset_free", "tsequence_to_tsequenceset_interp", "tsequenceset_compact", "tsequenceset_restart", @@ -2070,7 +2114,10 @@ "tnumberseqset_angular_difference", "tnumberseqset_delta_value", "distance_tnumber_number", + "nad_tbox_tbox", "nad_tnumber_number", + "nad_tnumber_tbox", + "nad_tnumber_tnumber", "tpointinst_srid", "tpointseq_trajectory", "tpointseq_azimuth", diff --git a/pymeos_cffi/pymeos_cffi/builder/meos.h b/pymeos_cffi/pymeos_cffi/builder/meos.h index a28ef2d4..ff2bafcc 100644 --- a/pymeos_cffi/pymeos_cffi/builder/meos.h +++ b/pymeos_cffi/pymeos_cffi/builder/meos.h @@ -394,10 +394,10 @@ typedef struct { Span period; double xmin; - double xmax; double ymin; - double ymax; double zmin; + double xmax; + double ymax; double zmax; int32 srid; int16 flags; @@ -579,7 +579,11 @@ extern char *pg_timestamptz_out(TimestampTz t); extern char *text2cstring(const text *txt); extern int text_cmp(const text *txt1, const text *txt2); extern text *text_copy(const text *txt); +/* extern text *text_initcap(const text *txt); (undefined) */ +/* extern text *text_lower(const text *txt); (undefined) */ extern char *text_out(const text *txt); +/* extern text *text_upper(const text *txt); (undefined) */ +extern text *textcat_text_text(const text *txt1, const text *txt2); extern DateADT timestamptz_to_date(TimestampTz t); extern bytea *geo_as_ewkb(const GSERIALIZED *gs, char *endian); @@ -789,6 +793,8 @@ extern SpanSet *bigintspanset_shift_scale(const SpanSet *ss, int64 shift, int64 extern Set *dateset_shift_scale(const Set *s, int shift, int width, bool hasshift, bool haswidth); extern Span *datespan_shift_scale(const Span *s, int shift, int width, bool hasshift, bool haswidth); extern SpanSet *datespanset_shift_scale(const SpanSet *ss, int shift, int width, bool hasshift, bool haswidth); +extern Set *floatset_degrees(const Set *s, bool normalize); +extern Set *floatset_radians(const Set *s); extern Set *floatset_round(const Set *s, int maxdd); extern Set *floatset_shift_scale(const Set *s, double shift, double width, bool hasshift, bool haswidth); extern Span *floatspan_round(const Span *s, int maxdd); @@ -797,11 +803,18 @@ extern SpanSet *floatspanset_round(const SpanSet *ss, int maxdd); extern SpanSet *floatspanset_shift_scale(const SpanSet *ss, double shift, double width, bool hasshift, bool haswidth); extern Set *geoset_round(const Set *s, int maxdd); extern Set *geoset_set_srid(const Set *s, int32 srid); +extern Set *geoset_transform(const Set *s, int32 srid); +extern Set *geoset_transform_pipeline(const Set *s, char *pipelinestr, int32 srid, bool is_forward); +extern GSERIALIZED *point_transform(const GSERIALIZED *gs, int32 srid); +extern GSERIALIZED *point_transform_pipeline(const GSERIALIZED *gs, char *pipelinestr, int32 srid, bool is_forward); extern Set *intset_shift_scale(const Set *s, int shift, int width, bool hasshift, bool haswidth); extern Span *intspan_shift_scale(const Span *s, int shift, int width, bool hasshift, bool haswidth); extern SpanSet *intspanset_shift_scale(const SpanSet *ss, int shift, int width, bool hasshift, bool haswidth); +extern Set *textset_initcap(const Set *s); extern Set *textset_lower(const Set *s); extern Set *textset_upper(const Set *s); +extern Set *textcat_textset_text(const Set *s, const text *txt); +extern Set *textcat_text_textset(const text *txt, const Set *s); extern TimestampTz timestamptz_tprecision(TimestampTz t, const Interval *duration, TimestampTz torigin); extern Set *tstzset_shift_scale(const Set *s, const Interval *shift, const Interval *duration); extern Set *tstzset_tprecision(const Set *s, const Interval *duration, TimestampTz torigin); @@ -1246,7 +1259,6 @@ extern GBOX *stbox_to_gbox(const STBox *box); extern BOX3D *stbox_to_box3d(const STBox *box); extern GSERIALIZED *stbox_to_geo(const STBox *box); extern Span *stbox_to_tstzspan(const STBox *box); -/* extern TBox *tstzspanset_to_tbox(const SpanSet *ss); (undefined) */ extern Span *tbox_to_intspan(const TBox *box); extern Span *tbox_to_floatspan(const TBox *box); extern Span *tbox_to_tstzspan(const TBox *box); @@ -1295,6 +1307,8 @@ extern STBox *stbox_quad_split(const STBox *box, int *count); extern STBox *stbox_round(const STBox *box, int maxdd); extern STBox *stbox_set_srid(const STBox *box, int32 srid); extern STBox *stbox_shift_scale_time(const STBox *box, const Interval *shift, const Interval *duration); +extern STBox *stbox_transform(const STBox *box, int32 srid); +extern STBox *stbox_transform_pipeline(const STBox *box, char *pipelinestr, int32 srid, bool is_forward); extern TBox *tbox_expand_time(const TBox *box, const Interval *interv); extern TBox *tbox_expand_float(const TBox *box, const double d); extern TBox *tbox_expand_int(const TBox *box, const int i); @@ -1360,24 +1374,30 @@ extern bool stbox_ge(const STBox *box1, const STBox *box2); extern bool stbox_gt(const STBox *box1, const STBox *box2); extern Temporal *tbool_in(const char *str); -extern char *tbool_out(const Temporal *temp); -extern char *temporal_as_hexwkb(const Temporal *temp, uint8_t variant, size_t *size_out); -extern char *temporal_as_mfjson(const Temporal *temp, bool with_bbox, int flags, int precision, char *srs); -extern uint8_t *temporal_as_wkb(const Temporal *temp, uint8_t variant, size_t *size_out); -extern Temporal *temporal_from_hexwkb(const char *hexwkb); -extern Temporal *temporal_from_mfjson(const char *mfjson); -extern Temporal *temporal_from_wkb(const uint8_t *wkb, size_t size); +extern Temporal *tint_in(const char *str); extern Temporal *tfloat_in(const char *str); -extern char *tfloat_out(const Temporal *temp, int maxdd); -extern Temporal *tgeogpoint_in(const char *str); +extern Temporal *ttext_in(const char *str); extern Temporal *tgeompoint_in(const char *str); -extern Temporal *tint_in(const char *str); +extern Temporal *tgeogpoint_in(const char *str); +extern Temporal *tbool_from_mfjson(const char *str); +extern Temporal *tint_from_mfjson(const char *str); +extern Temporal *tfloat_from_mfjson(const char *str); +extern Temporal *ttext_from_mfjson(const char *str); +extern Temporal *tgeompoint_from_mfjson(const char *str); +extern Temporal *tgeogpoint_from_mfjson(const char *str); +extern Temporal *temporal_from_wkb(const uint8_t *wkb, size_t size); +extern Temporal *temporal_from_hexwkb(const char *hexwkb); + +extern char *tbool_out(const Temporal *temp); extern char *tint_out(const Temporal *temp); -extern char *tpoint_as_ewkt(const Temporal *temp, int maxdd); -extern char *tpoint_as_text(const Temporal *temp, int maxdd); -extern char *tpoint_out(const Temporal *temp, int maxdd); -extern Temporal *ttext_in(const char *str); +extern char *tfloat_out(const Temporal *temp, int maxdd); extern char *ttext_out(const Temporal *temp); +extern char *tpoint_out(const Temporal *temp, int maxdd); +extern char *tpoint_as_text(const Temporal *temp, int maxdd); +extern char *tpoint_as_ewkt(const Temporal *temp, int maxdd); +extern char *temporal_as_mfjson(const Temporal *temp, bool with_bbox, int flags, int precision, char *srs); +extern uint8_t *temporal_as_wkb(const Temporal *temp, uint8_t variant, size_t *size_out); +extern char *temporal_as_hexwkb(const Temporal *temp, uint8_t variant, size_t *size_out); extern Temporal *tbool_from_base_temp(bool b, const Temporal *temp); extern TInstant *tboolinst_make(bool b, TimestampTz t); @@ -1489,6 +1509,8 @@ extern Temporal *tint_scale_value(const Temporal *temp, int width); extern Temporal *tint_shift_scale_value(const Temporal *temp, int shift, int width); extern Temporal *tint_shift_value(const Temporal *temp, int shift); extern Temporal *tpoint_round(const Temporal *temp, int maxdd); +extern Temporal *tpoint_transform(const Temporal *temp, int32 srid); +extern Temporal *tpoint_transform_pipeline(const Temporal *temp, char *pipelinestr, int32 srid, bool is_forward); extern Temporal **tpointarr_round(const Temporal **temp, int count, int maxdd); extern Temporal *temporal_append_tinstant(Temporal *temp, const TInstant *inst, double maxdist, Interval *maxt, bool expand); @@ -1891,6 +1913,7 @@ extern Temporal *textcat_ttext_text(const Temporal *temp, const text *txt); extern Temporal *textcat_ttext_ttext(const Temporal *temp1, const Temporal *temp2); extern Temporal *ttext_upper(const Temporal *temp); extern Temporal *ttext_lower(const Temporal *temp); +extern Temporal *ttext_initcap(const Temporal *temp); extern Temporal *distance_tfloat_float(const Temporal *temp, double d); extern Temporal *distance_tint_int(const Temporal *temp, int i); @@ -1899,12 +1922,14 @@ extern Temporal *distance_tpoint_point(const Temporal *temp, const GSERIALIZED * extern Temporal *distance_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); extern double nad_stbox_geo(const STBox *box, const GSERIALIZED *gs); extern double nad_stbox_stbox(const STBox *box1, const STBox *box2); -extern double nad_tbox_tbox(const TBox *box1, const TBox *box2); -extern double nad_tfloat_float(const Temporal *temp, double d); -extern double nad_tfloat_tfloat(const Temporal *temp1, const Temporal *temp2); extern int nad_tint_int(const Temporal *temp, int i); +extern int nad_tint_tbox(const Temporal *temp, const TBox *box); extern int nad_tint_tint(const Temporal *temp1, const Temporal *temp2); -extern double nad_tnumber_tbox(const Temporal *temp, const TBox *box); +extern int nad_tboxint_tboxint(const TBox *box1, const TBox *box2); +extern double nad_tfloat_float(const Temporal *temp, double d); +extern double nad_tfloat_tfloat(const Temporal *temp1, const Temporal *temp2); +extern double nad_tfloat_tbox(const Temporal *temp, const TBox *box); +extern double nad_tboxfloat_tboxfloat(const TBox *box1, const TBox *box2); extern double nad_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs); extern double nad_tpoint_stbox(const Temporal *temp, const STBox *box); extern double nad_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); @@ -2262,6 +2287,8 @@ extern bool ensure_tnumber_tgeo_type(meosType type); +extern Datum datum_degrees(Datum d, Datum normalize); +extern Datum datum_radians(Datum d); extern uint32 datum_hash(Datum d, meosType basetype); extern uint64 datum_hash_extended(Datum d, meosType basetype, uint64 seed); @@ -2285,15 +2312,19 @@ extern SpanSet *spanset_cp(const SpanSet *ss); extern SpanSet *spanset_make_exp(Span *spans, int count, int maxcount, bool normalize, bool ordered); extern SpanSet *spanset_make_free(Span *spans, int count, bool normalize, bool ordered); +extern Set *dateset_tstzset(const Set *s); extern Span *datespan_tstzspan(const Span *s); extern SpanSet *datespanset_tstzspanset(const SpanSet *ss); -extern Span *intspan_floatspan(const Span *s); -extern SpanSet *intspanset_floatspanset(const SpanSet *ss); +extern Set *floatset_intset(const Set *s); extern Span *floatspan_intspan(const Span *s); extern SpanSet *floatspanset_intspanset(const SpanSet *ss); +extern Set *intset_floatset(const Set *s); +extern Span *intspan_floatspan(const Span *s); +extern SpanSet *intspanset_floatspanset(const SpanSet *ss); extern Span *set_span(const Set *s); extern SpanSet *set_spanset(const Set *s); extern SpanSet *span_spanset(const Span *s); +extern Set *tstzset_dateset(const Set *s); extern Span *tstzspan_datespan(const Span *s); extern SpanSet *tstzspanset_datespanset(const SpanSet *ss); extern void value_set_span(Datum value, meosType basetype, Span *s); @@ -2317,7 +2348,11 @@ extern const Span **spanset_sps(const SpanSet *ss); extern Datum spanset_upper(const SpanSet *ss); extern void datespan_set_tstzspan(const Span *s1, Span *s2); -extern void floatspan_rnd(const Span *span, Datum size, Span *result); +extern Set * floatset_deg(const Set *s, bool normalize); +extern Set * floatset_rad(const Set *s); +extern Set * floatset_rnd(const Set *s, int size); +extern Span *floatspan_rnd(const Span *s, int size); +extern SpanSet *floatspanset_rnd(const SpanSet *ss, int size); extern void floatspan_set_intspan(const Span *s1, Span *s2); extern void intspan_set_floatspan(const Span *s1, Span *s2); extern Set *numset_shift_scale(const Set *s, Datum shift, Datum width, bool hasshift, bool haswidth); @@ -2325,9 +2360,17 @@ extern Span *numspan_shift_scale(const Span *s, Datum shift, Datum width, bool h extern SpanSet *numspanset_shift_scale(const SpanSet *ss, Datum shift, Datum width, bool hasshift, bool haswidth); extern Set *set_compact(const Set *s); extern void span_expand(const Span *s1, Span *s2); -extern SpanSet *spanset_compact(SpanSet *ss); +extern SpanSet *spanset_compact(const SpanSet *ss); +extern Set *textcat_textset_text_int(const Set *s, const text *txt, bool invert); extern void tstzspan_set_datespan(const Span *s1, Span *s2); +extern int set_cmp_int(const Set *s1, const Set *s2); +/* extern bool set_eq_int(const Set *s1, const Set *s2); (undefined) */ +extern int span_cmp_int(const Span *s1, const Span *s2); +extern bool span_eq_int(const Span *s1, const Span *s2); +extern int spanset_cmp_int(const SpanSet *ss1, const SpanSet *ss2); +extern bool spanset_eq_int(const SpanSet *ss1, const SpanSet *ss2); + extern bool adj_span_span(const Span *s1, const Span *s2); extern bool adjacent_span_value(const Span *s, Datum value); extern bool adjacent_spanset_value(const SpanSet *ss, Datum value); @@ -2515,11 +2558,13 @@ extern TSequence *ttextseq_in(const char *str, interpType interp); extern char *ttextseqset_as_mfjson(const TSequenceSet *ss, bool with_bbox); /* extern TSequenceSet *ttextseqset_from_mfjson(json_object *mfjson); (undefined type json_object) */ extern TSequenceSet *ttextseqset_in(const char *str); +extern Temporal *temporal_from_mfjson(const char *mfjson, meosType temptype); extern Temporal *temporal_cp(const Temporal *temp); extern Temporal *temporal_from_base_temp(Datum value, meosType temptype, const Temporal *temp); extern TInstant *tinstant_copy(const TInstant *inst); extern TInstant *tinstant_make(Datum value, meosType temptype, TimestampTz t); +extern TInstant *tinstant_make_free(Datum value, meosType temptype, TimestampTz t); extern TSequence *tpointseq_make_coords(const double *xcoords, const double *ycoords, const double *zcoords, const TimestampTz *times, int count, int32 srid, bool geodetic, bool lower_inc, bool upper_inc, interpType interp, bool normalize); extern TSequence *tsequence_copy(const TSequence *seq); extern TSequence *tsequence_from_base_tstzset(Datum value, meosType temptype, const Set *ss); @@ -2553,7 +2598,6 @@ extern Datum *temporal_values(const Temporal *temp, int *count); extern uint32 tinstant_hash(const TInstant *inst); extern const TInstant **tinstant_insts(const TInstant *inst, int *count); extern void tinstant_set_bbox(const TInstant *inst, void *box); -/* extern void tinstant_set_tstzspan(const TInstant *inst, Span *s); (repeated) */ extern SpanSet *tinstant_time(const TInstant *inst); extern TimestampTz *tinstant_timestamps(const TInstant *inst, int *count); extern Datum tinstant_val(const TInstant *inst); @@ -2609,6 +2653,7 @@ extern TSequence *temporal_tsequence(const Temporal *temp, interpType interp); extern TSequenceSet *temporal_tsequenceset(const Temporal *temp, interpType interp); extern TInstant *tinstant_shift_time(const TInstant *inst, const Interval *interv); extern TSequence *tinstant_to_tsequence(const TInstant *inst, interpType interp); +extern TSequence *tinstant_to_tsequence_free(TInstant *inst, interpType interp); extern TSequenceSet *tinstant_to_tsequenceset(const TInstant *inst, interpType interp); extern Temporal *tnumber_shift_scale_value(const Temporal *temp, Datum shift, Datum width, bool hasshift, bool haswidth); extern TInstant *tnumberinst_shift_value(const TInstant *inst, Datum shift); @@ -2621,6 +2666,7 @@ extern TSequence *tsequence_shift_scale_time(const TSequence *seq, const Interva extern TSequence *tsequence_subseq(const TSequence *seq, int from, int to, bool lower_inc, bool upper_inc); extern TInstant *tsequence_to_tinstant(const TSequence *seq); extern TSequenceSet *tsequence_to_tsequenceset(const TSequence *seq); +extern TSequenceSet *tsequence_to_tsequenceset_free(TSequence *seq); extern TSequenceSet *tsequence_to_tsequenceset_interp(const TSequence *seq, interpType interp); extern TSequenceSet *tsequenceset_compact(const TSequenceSet *ss); extern void tsequenceset_restart(TSequenceSet *ss, int count); @@ -2787,8 +2833,11 @@ extern TSequenceSet *tnumberseqset_abs(const TSequenceSet *ss); extern TSequence *tnumberseqset_angular_difference(const TSequenceSet *ss); extern TSequenceSet *tnumberseqset_delta_value(const TSequenceSet *ss); -extern Temporal *distance_tnumber_number(const Temporal *temp, Datum value, meosType valuetype, meosType restype); -extern double nad_tnumber_number(const Temporal *temp, Datum value, meosType basetype); +extern Temporal *distance_tnumber_number(const Temporal *temp, Datum value); +extern Datum nad_tbox_tbox(const TBox *box1, const TBox *box2); +extern Datum nad_tnumber_number(const Temporal *temp, Datum value); +extern Datum nad_tnumber_tbox(const Temporal *temp, const TBox *box); +extern Datum nad_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); extern int tpointinst_srid(const TInstant *inst); extern GSERIALIZED *tpointseq_trajectory(const TSequence *seq); diff --git a/pymeos_cffi/pymeos_cffi/functions.py b/pymeos_cffi/pymeos_cffi/functions.py index 4434204f..d9482710 100644 --- a/pymeos_cffi/pymeos_cffi/functions.py +++ b/pymeos_cffi/pymeos_cffi/functions.py @@ -503,6 +503,22 @@ def text_copy(txt: str) -> str: return result if result != _ffi.NULL else None +def text_initcap(txt: str) -> str: + txt_converted = cstring2text(txt) + result = _lib.text_initcap(txt_converted) + _check_error() + result = text2cstring(result) + return result if result != _ffi.NULL else None + + +def text_lower(txt: str) -> str: + txt_converted = cstring2text(txt) + result = _lib.text_lower(txt_converted) + _check_error() + result = text2cstring(result) + return result if result != _ffi.NULL else None + + def text_out(txt: str) -> str: txt_converted = cstring2text(txt) result = _lib.text_out(txt_converted) @@ -511,6 +527,23 @@ def text_out(txt: str) -> str: return result if result != _ffi.NULL else None +def text_upper(txt: str) -> str: + txt_converted = cstring2text(txt) + result = _lib.text_upper(txt_converted) + _check_error() + result = text2cstring(result) + return result if result != _ffi.NULL else None + + +def textcat_text_text(txt1: str, txt2: str) -> str: + txt1_converted = cstring2text(txt1) + txt2_converted = cstring2text(txt2) + result = _lib.textcat_text_text(txt1_converted, txt2_converted) + _check_error() + result = text2cstring(result) + return result if result != _ffi.NULL else None + + def timestamptz_to_date(t: int) -> "DateADT": t_converted = _ffi.cast("TimestampTz", t) result = _lib.timestamptz_to_date(t_converted) @@ -2047,6 +2080,20 @@ def datespanset_shift_scale( return result if result != _ffi.NULL else None +def floatset_degrees(s: "const Set *", normalize: bool) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.floatset_degrees(s_converted, normalize) + _check_error() + return result if result != _ffi.NULL else None + + +def floatset_radians(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.floatset_radians(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + def floatset_round(s: "const Set *", maxdd: int) -> "Set *": s_converted = _ffi.cast("const Set *", s) result = _lib.floatset_round(s_converted, maxdd) @@ -2112,6 +2159,48 @@ def geoset_set_srid(s: "const Set *", srid: int) -> "Set *": return result if result != _ffi.NULL else None +def geoset_transform(s: "const Set *", srid: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + srid_converted = _ffi.cast("int32", srid) + result = _lib.geoset_transform(s_converted, srid_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def geoset_transform_pipeline( + s: "const Set *", pipelinestr: str, srid: int, is_forward: bool +) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + pipelinestr_converted = pipelinestr.encode("utf-8") + srid_converted = _ffi.cast("int32", srid) + result = _lib.geoset_transform_pipeline( + s_converted, pipelinestr_converted, srid_converted, is_forward + ) + _check_error() + return result if result != _ffi.NULL else None + + +def point_transform(gs: "const GSERIALIZED *", srid: int) -> "GSERIALIZED *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + srid_converted = _ffi.cast("int32", srid) + result = _lib.point_transform(gs_converted, srid_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def point_transform_pipeline( + gs: "const GSERIALIZED *", pipelinestr: str, srid: int, is_forward: bool +) -> "GSERIALIZED *": + gs_converted = _ffi.cast("const GSERIALIZED *", gs) + pipelinestr_converted = pipelinestr.encode("utf-8") + srid_converted = _ffi.cast("int32", srid) + result = _lib.point_transform_pipeline( + gs_converted, pipelinestr_converted, srid_converted, is_forward + ) + _check_error() + return result if result != _ffi.NULL else None + + def intset_shift_scale( s: "const Set *", shift: int, width: int, hasshift: bool, haswidth: bool ) -> "Set *": @@ -2139,6 +2228,13 @@ def intspanset_shift_scale( return result if result != _ffi.NULL else None +def textset_initcap(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.textset_initcap(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + def textset_lower(s: "const Set *") -> "Set *": s_converted = _ffi.cast("const Set *", s) result = _lib.textset_lower(s_converted) @@ -2153,6 +2249,22 @@ def textset_upper(s: "const Set *") -> "Set *": return result if result != _ffi.NULL else None +def textcat_textset_text(s: "const Set *", txt: str) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + txt_converted = cstring2text(txt) + result = _lib.textcat_textset_text(s_converted, txt_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def textcat_text_textset(txt: str, s: "const Set *") -> "Set *": + txt_converted = cstring2text(txt) + s_converted = _ffi.cast("const Set *", s) + result = _lib.textcat_text_textset(txt_converted, s_converted) + _check_error() + return result if result != _ffi.NULL else None + + def timestamptz_tprecision( t: int, duration: "const Interval *", torigin: int ) -> "TimestampTz": @@ -5602,13 +5714,6 @@ def stbox_to_tstzspan(box: "const STBox *") -> "Span *": return result if result != _ffi.NULL else None -def tstzspanset_to_tbox(ss: "const SpanSet *") -> "TBox *": - ss_converted = _ffi.cast("const SpanSet *", ss) - result = _lib.tstzspanset_to_tbox(ss_converted) - _check_error() - return result if result != _ffi.NULL else None - - def tbox_to_intspan(box: "const TBox *") -> "Span *": box_converted = _ffi.cast("const TBox *", box) result = _lib.tbox_to_intspan(box_converted) @@ -6012,6 +6117,27 @@ def stbox_shift_scale_time( return result if result != _ffi.NULL else None +def stbox_transform(box: "const STBox *", srid: int) -> "STBox *": + box_converted = _ffi.cast("const STBox *", box) + srid_converted = _ffi.cast("int32", srid) + result = _lib.stbox_transform(box_converted, srid_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def stbox_transform_pipeline( + box: "const STBox *", pipelinestr: str, srid: int, is_forward: bool +) -> "STBox *": + box_converted = _ffi.cast("const STBox *", box) + pipelinestr_converted = pipelinestr.encode("utf-8") + srid_converted = _ffi.cast("int32", srid) + result = _lib.stbox_transform_pipeline( + box_converted, pipelinestr_converted, srid_converted, is_forward + ) + _check_error() + return result if result != _ffi.NULL else None + + def tbox_expand_time(box: "const TBox *", interv: "const Interval *") -> "TBox *": box_converted = _ffi.cast("const TBox *", box) interv_converted = _ffi.cast("const Interval *", interv) @@ -6509,111 +6635,104 @@ def tbool_in(string: str) -> "Temporal *": return result if result != _ffi.NULL else None -def tbool_out(temp: "const Temporal *") -> str: - temp_converted = _ffi.cast("const Temporal *", temp) - result = _lib.tbool_out(temp_converted) +def tint_in(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") + result = _lib.tint_in(string_converted) _check_error() - result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def temporal_as_hexwkb( - temp: "const Temporal *", variant: int -) -> "Tuple[str, 'size_t *']": - temp_converted = _ffi.cast("const Temporal *", temp) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") - result = _lib.temporal_as_hexwkb(temp_converted, variant_converted, size_out) +def tfloat_in(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") + result = _lib.tfloat_in(string_converted) _check_error() - result = _ffi.string(result).decode("utf-8") - return result if result != _ffi.NULL else None, size_out[0] + return result if result != _ffi.NULL else None -def temporal_as_mfjson( - temp: "const Temporal *", - with_bbox: bool, - flags: int, - precision: int, - srs: "Optional[str]", -) -> str: - temp_converted = _ffi.cast("const Temporal *", temp) - srs_converted = srs.encode("utf-8") if srs is not None else _ffi.NULL - result = _lib.temporal_as_mfjson( - temp_converted, with_bbox, flags, precision, srs_converted - ) +def ttext_in(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") + result = _lib.ttext_in(string_converted) _check_error() - result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def temporal_as_wkb(temp: "const Temporal *", variant: int) -> bytes: - temp_converted = _ffi.cast("const Temporal *", temp) - variant_converted = _ffi.cast("uint8_t", variant) - size_out = _ffi.new("size_t *") - result = _lib.temporal_as_wkb(temp_converted, variant_converted, size_out) +def tgeompoint_in(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") + result = _lib.tgeompoint_in(string_converted) _check_error() - result_converted = ( - bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None - ) - return result_converted + return result if result != _ffi.NULL else None -def temporal_from_hexwkb(hexwkb: str) -> "Temporal *": - hexwkb_converted = hexwkb.encode("utf-8") - result = _lib.temporal_from_hexwkb(hexwkb_converted) +def tgeogpoint_in(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") + result = _lib.tgeogpoint_in(string_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_from_mfjson(mfjson: str) -> "Temporal *": - mfjson_converted = mfjson.encode("utf-8") - result = _lib.temporal_from_mfjson(mfjson_converted) +def tbool_from_mfjson(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") + result = _lib.tbool_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def temporal_from_wkb(wkb: bytes) -> "Temporal *": - wkb_converted = _ffi.new("uint8_t []", wkb) - result = _lib.temporal_from_wkb(wkb_converted, len(wkb)) +def tint_from_mfjson(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") + result = _lib.tint_from_mfjson(string_converted) + _check_error() return result if result != _ffi.NULL else None -def tfloat_in(string: str) -> "Temporal *": +def tfloat_from_mfjson(string: str) -> "Temporal *": string_converted = string.encode("utf-8") - result = _lib.tfloat_in(string_converted) + result = _lib.tfloat_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def tfloat_out(temp: "const Temporal *", maxdd: int) -> str: - temp_converted = _ffi.cast("const Temporal *", temp) - result = _lib.tfloat_out(temp_converted, maxdd) +def ttext_from_mfjson(string: str) -> "Temporal *": + string_converted = string.encode("utf-8") + result = _lib.ttext_from_mfjson(string_converted) _check_error() - result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tgeogpoint_in(string: str) -> "Temporal *": +def tgeompoint_from_mfjson(string: str) -> "Temporal *": string_converted = string.encode("utf-8") - result = _lib.tgeogpoint_in(string_converted) + result = _lib.tgeompoint_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def tgeompoint_in(string: str) -> "Temporal *": +def tgeogpoint_from_mfjson(string: str) -> "Temporal *": string_converted = string.encode("utf-8") - result = _lib.tgeompoint_in(string_converted) + result = _lib.tgeogpoint_from_mfjson(string_converted) _check_error() return result if result != _ffi.NULL else None -def tint_in(string: str) -> "Temporal *": - string_converted = string.encode("utf-8") - result = _lib.tint_in(string_converted) +def temporal_from_wkb(wkb: bytes) -> "Temporal *": + wkb_converted = _ffi.new("uint8_t []", wkb) + result = _lib.temporal_from_wkb(wkb_converted, len(wkb)) + return result if result != _ffi.NULL else None + + +def temporal_from_hexwkb(hexwkb: str) -> "Temporal *": + hexwkb_converted = hexwkb.encode("utf-8") + result = _lib.temporal_from_hexwkb(hexwkb_converted) _check_error() return result if result != _ffi.NULL else None +def tbool_out(temp: "const Temporal *") -> str: + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tbool_out(temp_converted) + _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None + + def tint_out(temp: "const Temporal *") -> str: temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tint_out(temp_converted) @@ -6622,17 +6741,17 @@ def tint_out(temp: "const Temporal *") -> str: return result if result != _ffi.NULL else None -def tpoint_as_ewkt(temp: "const Temporal *", maxdd: int) -> str: +def tfloat_out(temp: "const Temporal *", maxdd: int) -> str: temp_converted = _ffi.cast("const Temporal *", temp) - result = _lib.tpoint_as_ewkt(temp_converted, maxdd) + result = _lib.tfloat_out(temp_converted, maxdd) _check_error() result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def tpoint_as_text(temp: "const Temporal *", maxdd: int) -> str: +def ttext_out(temp: "const Temporal *") -> str: temp_converted = _ffi.cast("const Temporal *", temp) - result = _lib.tpoint_as_text(temp_converted, maxdd) + result = _lib.ttext_out(temp_converted) _check_error() result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None @@ -6646,21 +6765,63 @@ def tpoint_out(temp: "const Temporal *", maxdd: int) -> str: return result if result != _ffi.NULL else None -def ttext_in(string: str) -> "Temporal *": - string_converted = string.encode("utf-8") - result = _lib.ttext_in(string_converted) +def tpoint_as_text(temp: "const Temporal *", maxdd: int) -> str: + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.tpoint_as_text(temp_converted, maxdd) _check_error() + result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None -def ttext_out(temp: "const Temporal *") -> str: +def tpoint_as_ewkt(temp: "const Temporal *", maxdd: int) -> str: temp_converted = _ffi.cast("const Temporal *", temp) - result = _lib.ttext_out(temp_converted) + result = _lib.tpoint_as_ewkt(temp_converted, maxdd) _check_error() result = _ffi.string(result).decode("utf-8") return result if result != _ffi.NULL else None +def temporal_as_mfjson( + temp: "const Temporal *", + with_bbox: bool, + flags: int, + precision: int, + srs: "Optional[str]", +) -> str: + temp_converted = _ffi.cast("const Temporal *", temp) + srs_converted = srs.encode("utf-8") if srs is not None else _ffi.NULL + result = _lib.temporal_as_mfjson( + temp_converted, with_bbox, flags, precision, srs_converted + ) + _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None + + +def temporal_as_wkb(temp: "const Temporal *", variant: int) -> bytes: + temp_converted = _ffi.cast("const Temporal *", temp) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") + result = _lib.temporal_as_wkb(temp_converted, variant_converted, size_out) + _check_error() + result_converted = ( + bytes(result[i] for i in range(size_out[0])) if result != _ffi.NULL else None + ) + return result_converted + + +def temporal_as_hexwkb( + temp: "const Temporal *", variant: int +) -> "Tuple[str, 'size_t *']": + temp_converted = _ffi.cast("const Temporal *", temp) + variant_converted = _ffi.cast("uint8_t", variant) + size_out = _ffi.new("size_t *") + result = _lib.temporal_as_hexwkb(temp_converted, variant_converted, size_out) + _check_error() + result = _ffi.string(result).decode("utf-8") + return result if result != _ffi.NULL else None, size_out[0] + + def tbool_from_base_temp(b: bool, temp: "const Temporal *") -> "Temporal *": temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tbool_from_base_temp(b, temp_converted) @@ -7551,6 +7712,27 @@ def tpoint_round(temp: "const Temporal *", maxdd: int) -> "Temporal *": return result if result != _ffi.NULL else None +def tpoint_transform(temp: "const Temporal *", srid: int) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + srid_converted = _ffi.cast("int32", srid) + result = _lib.tpoint_transform(temp_converted, srid_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def tpoint_transform_pipeline( + temp: "const Temporal *", pipelinestr: str, srid: int, is_forward: bool +) -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + pipelinestr_converted = pipelinestr.encode("utf-8") + srid_converted = _ffi.cast("int32", srid) + result = _lib.tpoint_transform_pipeline( + temp_converted, pipelinestr_converted, srid_converted, is_forward + ) + _check_error() + return result if result != _ffi.NULL else None + + def tpointarr_round(temp: "const Temporal **", count: int, maxdd: int) -> "Temporal **": temp_converted = [_ffi.cast("const Temporal *", x) for x in temp] result = _lib.tpointarr_round(temp_converted, count, maxdd) @@ -10770,6 +10952,13 @@ def ttext_lower(temp: "const Temporal *") -> "Temporal *": return result if result != _ffi.NULL else None +def ttext_initcap(temp: "const Temporal *") -> "Temporal *": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.ttext_initcap(temp_converted) + _check_error() + return result if result != _ffi.NULL else None + + def distance_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.distance_tfloat_float(temp_converted, d) @@ -10830,48 +11019,64 @@ def nad_stbox_stbox(box1: "const STBox *", box2: "const STBox *") -> "double": return result if result != _ffi.NULL else None -def nad_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "double": - box1_converted = _ffi.cast("const TBox *", box1) - box2_converted = _ffi.cast("const TBox *", box2) - result = _lib.nad_tbox_tbox(box1_converted, box2_converted) +def nad_tint_int(temp: "const Temporal *", i: int) -> "int": + temp_converted = _ffi.cast("const Temporal *", temp) + result = _lib.nad_tint_int(temp_converted, i) _check_error() return result if result != _ffi.NULL else None -def nad_tfloat_float(temp: "const Temporal *", d: float) -> "double": +def nad_tint_tbox(temp: "const Temporal *", box: "const TBox *") -> "int": temp_converted = _ffi.cast("const Temporal *", temp) - result = _lib.nad_tfloat_float(temp_converted, d) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.nad_tint_tbox(temp_converted, box_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tfloat_tfloat(temp1: "const Temporal *", temp2: "const Temporal *") -> "double": +def nad_tint_tint(temp1: "const Temporal *", temp2: "const Temporal *") -> "int": temp1_converted = _ffi.cast("const Temporal *", temp1) temp2_converted = _ffi.cast("const Temporal *", temp2) - result = _lib.nad_tfloat_tfloat(temp1_converted, temp2_converted) + result = _lib.nad_tint_tint(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tint_int(temp: "const Temporal *", i: int) -> "int": +def nad_tboxint_tboxint(box1: "const TBox *", box2: "const TBox *") -> "int": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) + result = _lib.nad_tboxint_tboxint(box1_converted, box2_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def nad_tfloat_float(temp: "const Temporal *", d: float) -> "double": temp_converted = _ffi.cast("const Temporal *", temp) - result = _lib.nad_tint_int(temp_converted, i) + result = _lib.nad_tfloat_float(temp_converted, d) _check_error() return result if result != _ffi.NULL else None -def nad_tint_tint(temp1: "const Temporal *", temp2: "const Temporal *") -> "int": +def nad_tfloat_tfloat(temp1: "const Temporal *", temp2: "const Temporal *") -> "double": temp1_converted = _ffi.cast("const Temporal *", temp1) temp2_converted = _ffi.cast("const Temporal *", temp2) - result = _lib.nad_tint_tint(temp1_converted, temp2_converted) + result = _lib.nad_tfloat_tfloat(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "double": +def nad_tfloat_tbox(temp: "const Temporal *", box: "const TBox *") -> "double": temp_converted = _ffi.cast("const Temporal *", temp) box_converted = _ffi.cast("const TBox *", box) - result = _lib.nad_tnumber_tbox(temp_converted, box_converted) + result = _lib.nad_tfloat_tbox(temp_converted, box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def nad_tboxfloat_tboxfloat(box1: "const TBox *", box2: "const TBox *") -> "double": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) + result = _lib.nad_tboxfloat_tboxfloat(box1_converted, box2_converted) _check_error() return result if result != _ffi.NULL else None @@ -12645,6 +12850,21 @@ def ensure_tnumber_tgeo_type(type: "meosType") -> "bool": return result if result != _ffi.NULL else None +def datum_degrees(d: "Datum", normalize: "Datum") -> "Datum": + d_converted = _ffi.cast("Datum", d) + normalize_converted = _ffi.cast("Datum", normalize) + result = _lib.datum_degrees(d_converted, normalize_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def datum_radians(d: "Datum") -> "Datum": + d_converted = _ffi.cast("Datum", d) + result = _lib.datum_radians(d_converted) + _check_error() + return result if result != _ffi.NULL else None + + def datum_hash(d: "Datum", basetype: "meosType") -> "uint32": d_converted = _ffi.cast("Datum", d) basetype_converted = _ffi.cast("meosType", basetype) @@ -12828,6 +13048,13 @@ def spanset_make_free( return result if result != _ffi.NULL else None +def dateset_tstzset(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.dateset_tstzset(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + def datespan_tstzspan(s: "const Span *") -> "Span *": s_converted = _ffi.cast("const Span *", s) result = _lib.datespan_tstzspan(s_converted) @@ -12842,30 +13069,44 @@ def datespanset_tstzspanset(ss: "const SpanSet *") -> "SpanSet *": return result if result != _ffi.NULL else None -def intspan_floatspan(s: "const Span *") -> "Span *": +def floatset_intset(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.floatset_intset(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def floatspan_intspan(s: "const Span *") -> "Span *": s_converted = _ffi.cast("const Span *", s) - result = _lib.intspan_floatspan(s_converted) + result = _lib.floatspan_intspan(s_converted) _check_error() return result if result != _ffi.NULL else None -def intspanset_floatspanset(ss: "const SpanSet *") -> "SpanSet *": +def floatspanset_intspanset(ss: "const SpanSet *") -> "SpanSet *": ss_converted = _ffi.cast("const SpanSet *", ss) - result = _lib.intspanset_floatspanset(ss_converted) + result = _lib.floatspanset_intspanset(ss_converted) _check_error() return result if result != _ffi.NULL else None -def floatspan_intspan(s: "const Span *") -> "Span *": +def intset_floatset(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.intset_floatset(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def intspan_floatspan(s: "const Span *") -> "Span *": s_converted = _ffi.cast("const Span *", s) - result = _lib.floatspan_intspan(s_converted) + result = _lib.intspan_floatspan(s_converted) _check_error() return result if result != _ffi.NULL else None -def floatspanset_intspanset(ss: "const SpanSet *") -> "SpanSet *": +def intspanset_floatspanset(ss: "const SpanSet *") -> "SpanSet *": ss_converted = _ffi.cast("const SpanSet *", ss) - result = _lib.floatspanset_intspanset(ss_converted) + result = _lib.intspanset_floatspanset(ss_converted) _check_error() return result if result != _ffi.NULL else None @@ -12891,6 +13132,13 @@ def span_spanset(s: "const Span *") -> "SpanSet *": return result if result != _ffi.NULL else None +def tstzset_dateset(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.tstzset_dateset(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + def tstzspan_datespan(s: "const Span *") -> "Span *": s_converted = _ffi.cast("const Span *", s) result = _lib.tstzspan_datespan(s_converted) @@ -13045,13 +13293,39 @@ def datespan_set_tstzspan(s1: "const Span *", s2: "Span *") -> None: _check_error() -def floatspan_rnd(span: "const Span *", size: "Datum") -> "Span *": - span_converted = _ffi.cast("const Span *", span) - size_converted = _ffi.cast("Datum", size) - out_result = _ffi.new("Span *") - _lib.floatspan_rnd(span_converted, size_converted, out_result) +def floatset_deg(s: "const Set *", normalize: bool) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.floatset_deg(s_converted, normalize) _check_error() - return out_result if out_result != _ffi.NULL else None + return result if result != _ffi.NULL else None + + +def floatset_rad(s: "const Set *") -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.floatset_rad(s_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def floatset_rnd(s: "const Set *", size: int) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + result = _lib.floatset_rnd(s_converted, size) + _check_error() + return result if result != _ffi.NULL else None + + +def floatspan_rnd(s: "const Span *", size: int) -> "Span *": + s_converted = _ffi.cast("const Span *", s) + result = _lib.floatspan_rnd(s_converted, size) + _check_error() + return result if result != _ffi.NULL else None + + +def floatspanset_rnd(ss: "const SpanSet *", size: int) -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) + result = _lib.floatspanset_rnd(ss_converted, size) + _check_error() + return result if result != _ffi.NULL else None def floatspan_set_intspan(s1: "const Span *", s2: "Span *") -> None: @@ -13125,13 +13399,21 @@ def span_expand(s1: "const Span *", s2: "Span *") -> None: _check_error() -def spanset_compact(ss: "SpanSet *") -> "SpanSet *": - ss_converted = _ffi.cast("SpanSet *", ss) +def spanset_compact(ss: "const SpanSet *") -> "SpanSet *": + ss_converted = _ffi.cast("const SpanSet *", ss) result = _lib.spanset_compact(ss_converted) _check_error() return result if result != _ffi.NULL else None +def textcat_textset_text_int(s: "const Set *", txt: str, invert: bool) -> "Set *": + s_converted = _ffi.cast("const Set *", s) + txt_converted = cstring2text(txt) + result = _lib.textcat_textset_text_int(s_converted, txt_converted, invert) + _check_error() + return result if result != _ffi.NULL else None + + def tstzspan_set_datespan(s1: "const Span *", s2: "Span *") -> None: s1_converted = _ffi.cast("const Span *", s1) s2_converted = _ffi.cast("Span *", s2) @@ -13139,6 +13421,54 @@ def tstzspan_set_datespan(s1: "const Span *", s2: "Span *") -> None: _check_error() +def set_cmp_int(s1: "const Set *", s2: "const Set *") -> "int": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.set_cmp_int(s1_converted, s2_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def set_eq_int(s1: "const Set *", s2: "const Set *") -> "bool": + s1_converted = _ffi.cast("const Set *", s1) + s2_converted = _ffi.cast("const Set *", s2) + result = _lib.set_eq_int(s1_converted, s2_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def span_cmp_int(s1: "const Span *", s2: "const Span *") -> "int": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.span_cmp_int(s1_converted, s2_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def span_eq_int(s1: "const Span *", s2: "const Span *") -> "bool": + s1_converted = _ffi.cast("const Span *", s1) + s2_converted = _ffi.cast("const Span *", s2) + result = _lib.span_eq_int(s1_converted, s2_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def spanset_cmp_int(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "int": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.spanset_cmp_int(ss1_converted, ss2_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def spanset_eq_int(ss1: "const SpanSet *", ss2: "const SpanSet *") -> "bool": + ss1_converted = _ffi.cast("const SpanSet *", ss1) + ss2_converted = _ffi.cast("const SpanSet *", ss2) + result = _lib.spanset_eq_int(ss1_converted, ss2_converted) + _check_error() + return result if result != _ffi.NULL else None + + def adj_span_span(s1: "const Span *", s2: "const Span *") -> "bool": s1_converted = _ffi.cast("const Span *", s1) s2_converted = _ffi.cast("const Span *", s2) @@ -14662,6 +14992,14 @@ def ttextseqset_in(string: str) -> "TSequenceSet *": return result if result != _ffi.NULL else None +def temporal_from_mfjson(mfjson: str, temptype: "meosType") -> "Temporal *": + mfjson_converted = mfjson.encode("utf-8") + temptype_converted = _ffi.cast("meosType", temptype) + result = _lib.temporal_from_mfjson(mfjson_converted, temptype_converted) + _check_error() + return result if result != _ffi.NULL else None + + def temporal_cp(temp: "const Temporal *") -> "Temporal *": temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.temporal_cp(temp_converted) @@ -14698,6 +15036,15 @@ def tinstant_make(value: "Datum", temptype: "meosType", t: int) -> "TInstant *": return result if result != _ffi.NULL else None +def tinstant_make_free(value: "Datum", temptype: "meosType", t: int) -> "TInstant *": + value_converted = _ffi.cast("Datum", value) + temptype_converted = _ffi.cast("meosType", temptype) + t_converted = _ffi.cast("TimestampTz", t) + result = _lib.tinstant_make_free(value_converted, temptype_converted, t_converted) + _check_error() + return result if result != _ffi.NULL else None + + def tpointseq_make_coords( xcoords: "const double *", ycoords: "const double *", @@ -14996,13 +15343,6 @@ def tinstant_set_bbox(inst: "const TInstant *", box: "void *") -> None: _check_error() -def tinstant_set_tstzspan(inst: "const TInstant *", s: "Span *") -> None: - inst_converted = _ffi.cast("const TInstant *", inst) - s_converted = _ffi.cast("Span *", s) - _lib.tinstant_set_tstzspan(inst_converted, s_converted) - _check_error() - - def tinstant_time(inst: "const TInstant *") -> "SpanSet *": inst_converted = _ffi.cast("const TInstant *", inst) result = _lib.tinstant_time(inst_converted) @@ -15424,6 +15764,16 @@ def tinstant_to_tsequence( return result if result != _ffi.NULL else None +def tinstant_to_tsequence_free( + inst: "TInstant *", interp: "interpType" +) -> "TSequence *": + inst_converted = _ffi.cast("TInstant *", inst) + interp_converted = _ffi.cast("interpType", interp) + result = _lib.tinstant_to_tsequence_free(inst_converted, interp_converted) + _check_error() + return result if result != _ffi.NULL else None + + def tinstant_to_tsequenceset( inst: "const TInstant *", interp: "interpType" ) -> "TSequenceSet *": @@ -15552,6 +15902,13 @@ def tsequence_to_tsequenceset(seq: "const TSequence *") -> "TSequenceSet *": return result if result != _ffi.NULL else None +def tsequence_to_tsequenceset_free(seq: "TSequence *") -> "TSequenceSet *": + seq_converted = _ffi.cast("TSequence *", seq) + result = _lib.tsequence_to_tsequenceset_free(seq_converted) + _check_error() + return result if result != _ffi.NULL else None + + def tsequence_to_tsequenceset_interp( seq: "const TSequence *", interp: "interpType" ) -> "TSequenceSet *": @@ -16980,29 +17337,44 @@ def tnumberseqset_delta_value(ss: "const TSequenceSet *") -> "TSequenceSet *": return result if result != _ffi.NULL else None -def distance_tnumber_number( - temp: "const Temporal *", value: "Datum", valuetype: "meosType", restype: "meosType" -) -> "Temporal *": +def distance_tnumber_number(temp: "const Temporal *", value: "Datum") -> "Temporal *": temp_converted = _ffi.cast("const Temporal *", temp) value_converted = _ffi.cast("Datum", value) - valuetype_converted = _ffi.cast("meosType", valuetype) - restype_converted = _ffi.cast("meosType", restype) - result = _lib.distance_tnumber_number( - temp_converted, value_converted, valuetype_converted, restype_converted - ) + result = _lib.distance_tnumber_number(temp_converted, value_converted) _check_error() return result if result != _ffi.NULL else None -def nad_tnumber_number( - temp: "const Temporal *", value: "Datum", basetype: "meosType" -) -> "double": +def nad_tbox_tbox(box1: "const TBox *", box2: "const TBox *") -> "Datum": + box1_converted = _ffi.cast("const TBox *", box1) + box2_converted = _ffi.cast("const TBox *", box2) + result = _lib.nad_tbox_tbox(box1_converted, box2_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def nad_tnumber_number(temp: "const Temporal *", value: "Datum") -> "Datum": temp_converted = _ffi.cast("const Temporal *", temp) value_converted = _ffi.cast("Datum", value) - basetype_converted = _ffi.cast("meosType", basetype) - result = _lib.nad_tnumber_number( - temp_converted, value_converted, basetype_converted - ) + result = _lib.nad_tnumber_number(temp_converted, value_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def nad_tnumber_tbox(temp: "const Temporal *", box: "const TBox *") -> "Datum": + temp_converted = _ffi.cast("const Temporal *", temp) + box_converted = _ffi.cast("const TBox *", box) + result = _lib.nad_tnumber_tbox(temp_converted, box_converted) + _check_error() + return result if result != _ffi.NULL else None + + +def nad_tnumber_tnumber( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Datum": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.nad_tnumber_tnumber(temp1_converted, temp2_converted) _check_error() return result if result != _ffi.NULL else None From 34d98d15cd542897fadf4dade30082b0fc00dfa7 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 28 Jan 2024 12:37:35 +0100 Subject: [PATCH 26/37] Fix TPoint to MFJSON tests --- pymeos/tests/main/tgeogpoint_test.py | 8 ++++---- pymeos/tests/main/tgeompoint_test.py | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/pymeos/tests/main/tgeogpoint_test.py b/pymeos/tests/main/tgeogpoint_test.py index 2cdbc568..be40482f 100644 --- a/pymeos/tests/main/tgeogpoint_test.py +++ b/pymeos/tests/main/tgeogpoint_test.py @@ -445,7 +445,7 @@ def test_as_hexwkb(self, temporal, expected): ( tpi, "{\n" - ' "type": "MovingGeogPoint",\n' + ' "type": "MovingPoint",\n' ' "bbox": [\n' " [\n" " 1,\n" @@ -477,7 +477,7 @@ def test_as_hexwkb(self, temporal, expected): ( tpds, "{\n" - ' "type": "MovingGeogPoint",\n' + ' "type": "MovingPoint",\n' ' "bbox": [\n' " [\n" " 1,\n" @@ -516,7 +516,7 @@ def test_as_hexwkb(self, temporal, expected): ( tps, "{\n" - ' "type": "MovingGeogPoint",\n' + ' "type": "MovingPoint",\n' ' "bbox": [\n' " [\n" " 1,\n" @@ -555,7 +555,7 @@ def test_as_hexwkb(self, temporal, expected): ( tpss, "{\n" - ' "type": "MovingGeogPoint",\n' + ' "type": "MovingPoint",\n' ' "bbox": [\n' " [\n" " 1,\n" diff --git a/pymeos/tests/main/tgeompoint_test.py b/pymeos/tests/main/tgeompoint_test.py index 6ee9440e..2155b113 100644 --- a/pymeos/tests/main/tgeompoint_test.py +++ b/pymeos/tests/main/tgeompoint_test.py @@ -462,7 +462,7 @@ def test_as_geojson(self, temporal, expected): ( tpi, "{\n" - ' "type": "MovingGeomPoint",\n' + ' "type": "MovingPoint",\n' ' "bbox": [\n' " [\n" " 1,\n" @@ -494,7 +494,7 @@ def test_as_geojson(self, temporal, expected): ( tpds, "{\n" - ' "type": "MovingGeomPoint",\n' + ' "type": "MovingPoint",\n' ' "bbox": [\n' " [\n" " 1,\n" @@ -533,7 +533,7 @@ def test_as_geojson(self, temporal, expected): ( tps, "{\n" - ' "type": "MovingGeomPoint",\n' + ' "type": "MovingPoint",\n' ' "bbox": [\n' " [\n" " 1,\n" @@ -572,7 +572,7 @@ def test_as_geojson(self, temporal, expected): ( tpss, "{\n" - ' "type": "MovingGeomPoint",\n' + ' "type": "MovingPoint",\n' ' "bbox": [\n' " [\n" " 1,\n" From 8fbd147d4e4e09a1e2adf0d48d06da2daf7c6a7a Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 28 Jan 2024 12:37:54 +0100 Subject: [PATCH 27/37] Update speed and derivative tests that now raise an exception on error --- pymeos/tests/main/tfloat_test.py | 22 +++++++++++++++------- pymeos/tests/main/tgeogpoint_test.py | 14 +++++++++++--- pymeos/tests/main/tgeompoint_test.py | 17 ++++++++++++++--- 3 files changed, 40 insertions(+), 13 deletions(-) diff --git a/pymeos/tests/main/tfloat_test.py b/pymeos/tests/main/tfloat_test.py index d46b4aa0..8f611a29 100644 --- a/pymeos/tests/main/tfloat_test.py +++ b/pymeos/tests/main/tfloat_test.py @@ -3,6 +3,7 @@ from operator import not_ import pytest +from pymeos_cffi import MeosInvalidArgValueError from pymeos import ( TBoolInst, @@ -2036,8 +2037,6 @@ def test_to_radians_to_degrees(self, temporal): @pytest.mark.parametrize( "temporal, expected", [ - (tfi, None), - (tfds, None), (tfs, TFloatSeq("Interp=Step;[-1@2019-09-01, -1@2019-09-02]")), ( tfss, @@ -2046,13 +2045,22 @@ def test_to_radians_to_degrees(self, temporal): ), ), ], - ids=["Instant", "Discrete Sequence", "Sequence", "SequenceSet"], + ids=["Sequence", "SequenceSet"], ) def test_derivative(self, temporal, expected): - if expected is None: - assert temporal.derivative() is None - else: - assert temporal.derivative() * 3600 * 24 == expected + assert temporal.derivative() * 3600 * 24 == expected + + @pytest.mark.parametrize( + "temporal", + [ + tfi, + tfds + ], + ids=["Instant", "Discrete Sequence"], + ) + def test_derivative_without_linear_interpolation_raises(self, temporal): + with pytest.raises(MeosInvalidArgValueError): + temporal.derivative() class TestTFloatRestrictors(TestTFloat): diff --git a/pymeos/tests/main/tgeogpoint_test.py b/pymeos/tests/main/tgeogpoint_test.py index be40482f..913be6bd 100644 --- a/pymeos/tests/main/tgeogpoint_test.py +++ b/pymeos/tests/main/tgeogpoint_test.py @@ -5,6 +5,7 @@ import numpy as np import pytest import shapely.geometry +from pymeos_cffi import MeosInvalidArgValueError from shapely import Point, LineString from pymeos import ( @@ -1088,8 +1089,6 @@ def test_cumulative_length(self, temporal, expected): @pytest.mark.parametrize( "temporal, expected", [ - (tpi, None), - (tpds, None), (tps, TFloatSeq("Interp=Step;[1.8157@2019-09-01, 1.8157@2019-09-02]")), ( tpss, @@ -1099,7 +1098,7 @@ def test_cumulative_length(self, temporal, expected): ), ), ], - ids=["Instant", "Discrete Sequence", "Sequence", "SequenceSet"], + ids=["Sequence", "SequenceSet"], ) def test_speed(self, temporal, expected): if expected is None: @@ -1107,6 +1106,15 @@ def test_speed(self, temporal, expected): else: assert temporal.speed().round(4) == expected + @pytest.mark.parametrize( + "temporal", + [tpi, tpds], + ids=["Instant", "Discrete Sequence"], + ) + def test_speed_without_linear_interpolation_throws(self, temporal): + with pytest.raises(MeosInvalidArgValueError): + temporal.speed() + @pytest.mark.parametrize( "temporal, expected", [ diff --git a/pymeos/tests/main/tgeompoint_test.py b/pymeos/tests/main/tgeompoint_test.py index 2155b113..14b52037 100644 --- a/pymeos/tests/main/tgeompoint_test.py +++ b/pymeos/tests/main/tgeompoint_test.py @@ -5,6 +5,7 @@ import pytest import math import numpy as np +from pymeos_cffi import MeosInvalidArgValueError from shapely import Point, LineString, Polygon, MultiPoint, GeometryCollection from pymeos import ( @@ -1117,8 +1118,6 @@ def test_cumulative_length(self, temporal, expected): @pytest.mark.parametrize( "temporal, expected", [ - (tpi, None), - (tpds, None), ( tps, TFloatSeq( @@ -1137,11 +1136,23 @@ def test_cumulative_length(self, temporal, expected): / 24, ), ], - ids=["Instant", "Discrete Sequence", "Sequence", "SequenceSet"], + ids=["Sequence", "SequenceSet"], ) def test_speed(self, temporal, expected): assert temporal.speed() == expected + @pytest.mark.parametrize( + "temporal, expected", + [ + tpi, + tpds + ], + ids=["Instant", "Discrete Sequence"], + ) + def test_speed(self, temporal, expected): + with pytest.raises(MeosInvalidArgValueError): + temporal.speed() + @pytest.mark.parametrize( "temporal, expected", [ From 13936e51c9860ee740df748e6e9850aee116d441 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 28 Jan 2024 12:46:04 +0100 Subject: [PATCH 28/37] Fix issue in tgeompoint speed test --- pymeos/tests/main/tgeompoint_test.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pymeos/tests/main/tgeompoint_test.py b/pymeos/tests/main/tgeompoint_test.py index 14b52037..5f0c4a44 100644 --- a/pymeos/tests/main/tgeompoint_test.py +++ b/pymeos/tests/main/tgeompoint_test.py @@ -1142,14 +1142,14 @@ def test_speed(self, temporal, expected): assert temporal.speed() == expected @pytest.mark.parametrize( - "temporal, expected", + "temporal", [ tpi, tpds ], ids=["Instant", "Discrete Sequence"], ) - def test_speed(self, temporal, expected): + def test_speed(self, temporal): with pytest.raises(MeosInvalidArgValueError): temporal.speed() From 3c35eca5f06c961650b7121a7b575e63ce52646c Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 28 Jan 2024 12:57:59 +0100 Subject: [PATCH 29/37] Fix shortest_line method --- pymeos/pymeos/main/tpoint.py | 2 +- pymeos/tests/main/tgeompoint_test.py | 5 +---- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/pymeos/pymeos/main/tpoint.py b/pymeos/pymeos/main/tpoint.py index 2d4d19dd..30c196d3 100644 --- a/pymeos/pymeos/main/tpoint.py +++ b/pymeos/pymeos/main/tpoint.py @@ -1101,7 +1101,7 @@ def shortest_line( result = shortestline_tpoint_tpoint(self._inner, other._inner) else: raise TypeError(f"Operation not supported with type {other.__class__}") - return gserialized_to_shapely_geometry(result[0], 10) + return gserialized_to_shapely_geometry(result, 10) # ------------------------- Tiling Operations ----------------------------- def tile( diff --git a/pymeos/tests/main/tgeompoint_test.py b/pymeos/tests/main/tgeompoint_test.py index 5f0c4a44..0ae0cc5a 100644 --- a/pymeos/tests/main/tgeompoint_test.py +++ b/pymeos/tests/main/tgeompoint_test.py @@ -1143,10 +1143,7 @@ def test_speed(self, temporal, expected): @pytest.mark.parametrize( "temporal", - [ - tpi, - tpds - ], + [tpi, tpds], ids=["Instant", "Discrete Sequence"], ) def test_speed(self, temporal): From e8776b89cde39eeaf2da7b83c8d2043630b53049 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 28 Jan 2024 13:16:20 +0100 Subject: [PATCH 30/37] Update temporal equality to new API --- pymeos/pymeos/main/tbool.py | 12 ++-- pymeos/pymeos/main/tfloat.py | 12 ++-- pymeos/pymeos/main/tint.py | 12 ++-- pymeos/pymeos/main/tpoint.py | 24 ++++--- pymeos/pymeos/main/ttext.py | 12 ++-- pymeos/pymeos/mixins/temporal_comparison.py | 11 +-- pymeos_cffi/pymeos_cffi/__init__.py | 8 +++ pymeos_cffi/pymeos_cffi/builder/meos.h | 8 +++ pymeos_cffi/pymeos_cffi/functions.py | 76 +++++++++++++++++++++ 9 files changed, 146 insertions(+), 29 deletions(-) diff --git a/pymeos/pymeos/main/tbool.py b/pymeos/pymeos/main/tbool.py index 0a8feefa..c59d9272 100644 --- a/pymeos/pymeos/main/tbool.py +++ b/pymeos/pymeos/main/tbool.py @@ -240,12 +240,14 @@ def temporal_equal(self, other: Union[bool, TBool]) -> TBool: A :class:`TBool` with the result of the temporal equality relation. MEOS Functions: - teq_tbool_tbool, teq_temporal_temporal + teq_tbool_tbool, teq_tbool_bool """ if isinstance(other, bool): result = teq_tbool_bool(self._inner, other) + elif isinstance(other, TBool): + result = teq_tbool_tbool(self._inner, other._inner) else: - return super().temporal_equal(other) + raise TypeError(f"Operation not supported with type {other.__class__}") return Temporal._factory(result) def temporal_not_equal(self, other: Union[bool, TBool]) -> TBool: @@ -259,12 +261,14 @@ def temporal_not_equal(self, other: Union[bool, TBool]) -> TBool: A :class:`TBool` with the result of the temporal inequality relation. MEOS Functions: - tne_tbool_tbool, tne_temporal_temporal + tne_tbool_tbool, tne_tbool_bool """ if isinstance(other, bool): result = tne_tbool_bool(self._inner, other) + elif isinstance(other, TBool): + result = tne_tbool_tbool(self._inner, other._inner) else: - return super().temporal_not_equal(other) + raise TypeError(f"Operation not supported with type {other.__class__}") return Temporal._factory(result) # ------------------------- Restrictions ---------------------------------- diff --git a/pymeos/pymeos/main/tfloat.py b/pymeos/pymeos/main/tfloat.py index e55b962e..fc45ae63 100644 --- a/pymeos/pymeos/main/tfloat.py +++ b/pymeos/pymeos/main/tfloat.py @@ -660,12 +660,14 @@ def temporal_equal(self, other: Union[int, float, TFloat]) -> TBool: A :class:`TBool` with the result of the temporal equality relation. MEOS Functions: - teq_tfloat_float, teq_temporal_temporal + teq_tfloat_float, teq_tfloat_tfloat """ if isinstance(other, int) or isinstance(other, float): result = teq_tfloat_float(self._inner, float(other)) + elif isinstance(other, TFloat): + result = teq_tfloat_tfloat(self._inner, other._inner) else: - return super().temporal_equal(other) + raise TypeError(f"Operation not supported with type {other.__class__}") return Temporal._factory(result) def temporal_not_equal(self, other: Union[int, float, TFloat]) -> TBool: @@ -680,12 +682,14 @@ def temporal_not_equal(self, other: Union[int, float, TFloat]) -> TBool: A :class:`TBool` with the result of the temporal not equal relation. MEOS Functions: - tne_tfloat_float, tne_temporal_temporal + tne_tfloat_float, tne_tfloat_tfloat """ if isinstance(other, int) or isinstance(other, float): result = tne_tfloat_float(self._inner, float(other)) + elif isinstance(other, TFloat): + result = tne_tfloat_tfloat(self._inner, other._inner) else: - return super().temporal_not_equal(other) + raise TypeError(f"Operation not supported with type {other.__class__}") return Temporal._factory(result) def temporal_less(self, other: Union[int, float, TFloat]) -> TBool: diff --git a/pymeos/pymeos/main/tint.py b/pymeos/pymeos/main/tint.py index a409818c..abf39bc7 100644 --- a/pymeos/pymeos/main/tint.py +++ b/pymeos/pymeos/main/tint.py @@ -633,12 +633,14 @@ def temporal_equal(self, other: Union[int, TInt]) -> TBool: A :class:`TBool` with the result of the temporal equality relation. MEOS Functions: - teq_tint_int, teq_temporal_temporal + teq_tint_int, teq_tint_tint """ if isinstance(other, int): result = teq_tint_int(self._inner, other) + elif isinstance(other, TInt): + result = teq_tint_tint(self._inner, other._inner) else: - return super().temporal_equal(other) + raise TypeError(f"Operation not supported with type {other.__class__}") return Temporal._factory(result) def temporal_not_equal(self, other: Union[int, TInt]) -> TBool: @@ -652,12 +654,14 @@ def temporal_not_equal(self, other: Union[int, TInt]) -> TBool: A :class:`TBool` with the result of the temporal not equal relation. MEOS Functions: - tne_tint_int, tne_temporal_temporal + tne_tint_int, tne_tint_tint """ if isinstance(other, int): result = tne_tint_int(self._inner, other) + elif isinstance(other, TInt): + result = tne_tint_tint(self._inner, other._inner) else: - return super().temporal_not_equal(other) + raise TypeError(f"Operation not supported with type {other.__class__}") return Temporal._factory(result) def temporal_less(self, other: Union[int, TInt]) -> TBool: diff --git a/pymeos/pymeos/main/tpoint.py b/pymeos/pymeos/main/tpoint.py index 30c196d3..2e42a9e0 100644 --- a/pymeos/pymeos/main/tpoint.py +++ b/pymeos/pymeos/main/tpoint.py @@ -1645,13 +1645,15 @@ def temporal_equal(self, other: Union[shp.Point, TGeomPoint]) -> TBool: A :class:`TBool` with the result of the temporal equality relation. MEOS Functions: - teq_tpoint_point, teq_temporal_temporal + teq_tpoint_point, teq_tpoint_tpoint """ if isinstance(other, shp.Point): gs = geometry_to_gserialized(other) result = teq_tpoint_point(self._inner, gs) + elif isinstance(other, TGeomPoint): + result = teq_tpoint_tpoint(self._inner, other._inner) else: - return super().temporal_equal(other) + raise TypeError(f"Operation not supported with type {other.__class__}") return Temporal._factory(result) def temporal_not_equal(self, other: Union[shp.Point, TGeomPoint]) -> TBool: @@ -1665,13 +1667,15 @@ def temporal_not_equal(self, other: Union[shp.Point, TGeomPoint]) -> TBool: A :class:`TBool` with the result of the temporal inequality relation. MEOS Functions: - tne_tpoint_point, tne_temporal_temporal + tne_tpoint_point, tne_tpoint_tpoint """ if isinstance(other, shp.Point): gs = geometry_to_gserialized(other) result = tne_tpoint_point(self._inner, gs) + elif isinstance(other, TGeomPoint): + result = tne_tpoint_tpoint(self._inner, other._inner) else: - return super().temporal_not_equal(other) + raise TypeError(f"Operation not supported with type {other.__class__}") return Temporal._factory(result) # ------------------------- Database Operations --------------------------- @@ -1962,13 +1966,15 @@ def temporal_equal(self, other: Union[shp.Point, TGeogPoint]) -> TBool: A :class:`TBool` with the result of the temporal equality relation. MEOS Functions: - teq_tpoint_point, teq_temporal_temporal + teq_tpoint_point, teq_tpoint_tpoint """ if isinstance(other, shp.Point): gs = geography_to_gserialized(other) result = teq_tpoint_point(self._inner, gs) + elif isinstance(other, TGeogPoint): + result = teq_tpoint_tpoint(self._inner, other._inner) else: - return super().temporal_equal(other) + raise TypeError(f"Operation not supported with type {other.__class__}") return Temporal._factory(result) def temporal_not_equal(self, other: Union[shp.Point, TGeogPoint]) -> TBool: @@ -1982,13 +1988,15 @@ def temporal_not_equal(self, other: Union[shp.Point, TGeogPoint]) -> TBool: A :class:`TBool` with the result of the temporal inequality relation. MEOS Functions: - tne_tpoint_point, tne_temporal_temporal + tne_tpoint_point, tne_tpoint_tpoint """ if isinstance(other, shp.Point): gs = geography_to_gserialized(other) result = tne_tpoint_point(self._inner, gs) + elif isinstance(other, TGeogPoint): + result = tne_tpoint_tpoint(self._inner, other._inner) else: - return super().temporal_not_equal(other) + raise TypeError(f"Operation not supported with type {other.__class__}") return Temporal._factory(result) # ------------------------- Database Operations --------------------------- diff --git a/pymeos/pymeos/main/ttext.py b/pymeos/pymeos/main/ttext.py index ef373c73..1709670a 100644 --- a/pymeos/pymeos/main/ttext.py +++ b/pymeos/pymeos/main/ttext.py @@ -611,12 +611,14 @@ def temporal_equal(self, other: Union[str, TText]) -> TBool: A :class:`TBool` with the result of the temporal equality relation. MEOS Functions: - teq_ttext_text, teq_temporal_temporal + teq_ttext_text, teq_ttext_ttext """ if isinstance(other, str): result = teq_ttext_text(self._inner, other) + elif isinstance(other, TText): + result = teq_ttext_ttext(self._inner, other._inner) else: - return super().temporal_equal(other) + raise TypeError(f"Operation not supported with type {other.__class__}") return Temporal._factory(result) def temporal_not_equal(self, other: Union[str, TText]) -> TBool: @@ -630,12 +632,14 @@ def temporal_not_equal(self, other: Union[str, TText]) -> TBool: A :class:`TBool` with the result of the temporal not equal relation. MEOS Functions: - tne_ttext_text, tne_temporal_temporal + tne_ttext_text, tne_ttext_ttext """ if isinstance(other, str): result = tne_ttext_text(self._inner, other) + elif isinstance(other, TText): + result = tne_ttext_ttext(self._inner, other._inner) else: - return super().temporal_not_equal(other) + raise TypeError(f"Operation not supported with type {other.__class__}") return Temporal._factory(result) def temporal_less(self, other: Union[str, TText]) -> TBool: diff --git a/pymeos/pymeos/mixins/temporal_comparison.py b/pymeos/pymeos/mixins/temporal_comparison.py index 2c8c8397..c4e484ad 100644 --- a/pymeos/pymeos/mixins/temporal_comparison.py +++ b/pymeos/pymeos/mixins/temporal_comparison.py @@ -1,5 +1,6 @@ from __future__ import annotations +from abc import ABC, abstractmethod from typing import TypeVar, TYPE_CHECKING from pymeos_cffi import ( @@ -18,7 +19,8 @@ from ..temporal import Temporal -class TTemporallyEquatable: +class TTemporallyEquatable(ABC): + @abstractmethod def temporal_equal(self: Self, other: Temporal) -> TBool: """ Returns the temporal equality relation between `self` and `other`. @@ -32,9 +34,9 @@ def temporal_equal(self: Self, other: Temporal) -> TBool: MEOS Functions: teq_temporal_temporal """ - result = teq_temporal_temporal(self._inner, other._inner) - return self._factory(result) + pass + @abstractmethod def temporal_not_equal(self: Self, other: Temporal) -> TBool: """ Returns the temporal not equal relation between `self` and `other`. @@ -48,8 +50,7 @@ def temporal_not_equal(self: Self, other: Temporal) -> TBool: MEOS Functions: tne_temporal_temporal """ - result = tne_temporal_temporal(self._inner, other._inner) - return self._factory(result) + pass class TTemporallyComparable: diff --git a/pymeos_cffi/pymeos_cffi/__init__.py b/pymeos_cffi/pymeos_cffi/__init__.py index 4950d4a0..60a3b6b5 100644 --- a/pymeos_cffi/pymeos_cffi/__init__.py +++ b/pymeos_cffi/pymeos_cffi/__init__.py @@ -1164,13 +1164,17 @@ "teq_int_tint", "teq_point_tpoint", "teq_tbool_bool", + "teq_tbool_tbool", "teq_temporal_temporal", "teq_text_ttext", "teq_tfloat_float", + "teq_tfloat_tfloat", "teq_tpoint_point", "teq_tpoint_tpoint", "teq_tint_int", + "teq_tint_tint", "teq_ttext_text", + "teq_ttext_ttext", "tge_float_tfloat", "tge_int_tint", "tge_temporal_temporal", @@ -1204,13 +1208,17 @@ "tne_int_tint", "tne_point_tpoint", "tne_tbool_bool", + "tne_tbool_tbool", "tne_temporal_temporal", "tne_text_ttext", "tne_tfloat_float", + "tne_tfloat_tfloat", "tne_tpoint_point", "tne_tpoint_tpoint", "tne_tint_int", + "tne_tint_tint", "tne_ttext_text", + "tne_ttext_ttext", "adjacent_numspan_tnumber", "adjacent_stbox_tpoint", "adjacent_tbox_tnumber", diff --git a/pymeos_cffi/pymeos_cffi/builder/meos.h b/pymeos_cffi/pymeos_cffi/builder/meos.h index ff2bafcc..4c52d380 100644 --- a/pymeos_cffi/pymeos_cffi/builder/meos.h +++ b/pymeos_cffi/pymeos_cffi/builder/meos.h @@ -1677,13 +1677,17 @@ extern Temporal *teq_float_tfloat(double d, const Temporal *temp); extern Temporal *teq_int_tint(int i, const Temporal *temp); extern Temporal *teq_point_tpoint(const GSERIALIZED *gs, const Temporal *temp); extern Temporal *teq_tbool_bool(const Temporal *temp, bool b); +extern Temporal *teq_tbool_tbool(const Temporal *temp1, const Temporal *temp2); /* extern Temporal *teq_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ extern Temporal *teq_text_ttext(const text *txt, const Temporal *temp); extern Temporal *teq_tfloat_float(const Temporal *temp, double d); +extern Temporal *teq_tfloat_tfloat(const Temporal *temp1, const Temporal *temp2); extern Temporal *teq_tpoint_point(const Temporal *temp, const GSERIALIZED *gs); extern Temporal *teq_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); extern Temporal *teq_tint_int(const Temporal *temp, int i); +extern Temporal *teq_tint_tint(const Temporal *temp1, const Temporal *temp2); extern Temporal *teq_ttext_text(const Temporal *temp, const text *txt); +extern Temporal *teq_ttext_ttext(const Temporal *temp1, const Temporal *temp2); extern Temporal *tge_float_tfloat(double d, const Temporal *temp); extern Temporal *tge_int_tint(int i, const Temporal *temp); /* extern Temporal *tge_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ @@ -1717,13 +1721,17 @@ extern Temporal *tne_float_tfloat(double d, const Temporal *temp); extern Temporal *tne_int_tint(int i, const Temporal *temp); extern Temporal *tne_point_tpoint(const GSERIALIZED *gs, const Temporal *temp); extern Temporal *tne_tbool_bool(const Temporal *temp, bool b); +extern Temporal *tne_tbool_tbool(const Temporal *temp1, const Temporal *temp2); /* extern Temporal *tne_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ extern Temporal *tne_text_ttext(const text *txt, const Temporal *temp); extern Temporal *tne_tfloat_float(const Temporal *temp, double d); +extern Temporal *tne_tfloat_tfloat(const Temporal *temp1, const Temporal *temp2); extern Temporal *tne_tpoint_point(const Temporal *temp, const GSERIALIZED *gs); extern Temporal *tne_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); extern Temporal *tne_tint_int(const Temporal *temp, int i); +extern Temporal *tne_tint_tint(const Temporal *temp1, const Temporal *temp2); extern Temporal *tne_ttext_text(const Temporal *temp, const text *txt); +extern Temporal *tne_ttext_ttext(const Temporal *temp1, const Temporal *temp2); extern bool adjacent_numspan_tnumber(const Span *s, const Temporal *temp); extern bool adjacent_stbox_tpoint(const STBox *box, const Temporal *temp); diff --git a/pymeos_cffi/pymeos_cffi/functions.py b/pymeos_cffi/pymeos_cffi/functions.py index d9482710..45549018 100644 --- a/pymeos_cffi/pymeos_cffi/functions.py +++ b/pymeos_cffi/pymeos_cffi/functions.py @@ -9050,6 +9050,16 @@ def teq_tbool_bool(temp: "const Temporal *", b: bool) -> "Temporal *": return result if result != _ffi.NULL else None +def teq_tbool_tbool( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.teq_tbool_tbool(temp1_converted, temp2_converted) + _check_error() + return result if result != _ffi.NULL else None + + def teq_temporal_temporal( temp1: "const Temporal *", temp2: "const Temporal *" ) -> "Temporal *": @@ -9075,6 +9085,16 @@ def teq_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": return result if result != _ffi.NULL else None +def teq_tfloat_tfloat( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.teq_tfloat_tfloat(temp1_converted, temp2_converted) + _check_error() + return result if result != _ffi.NULL else None + + def teq_tpoint_point( temp: "const Temporal *", gs: "const GSERIALIZED *" ) -> "Temporal *": @@ -9102,6 +9122,14 @@ def teq_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": return result if result != _ffi.NULL else None +def teq_tint_tint(temp1: "const Temporal *", temp2: "const Temporal *") -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.teq_tint_tint(temp1_converted, temp2_converted) + _check_error() + return result if result != _ffi.NULL else None + + def teq_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) @@ -9110,6 +9138,16 @@ def teq_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": return result if result != _ffi.NULL else None +def teq_ttext_ttext( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.teq_ttext_ttext(temp1_converted, temp2_converted) + _check_error() + return result if result != _ffi.NULL else None + + def tge_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tge_float_tfloat(d, temp_converted) @@ -9364,6 +9402,16 @@ def tne_tbool_bool(temp: "const Temporal *", b: bool) -> "Temporal *": return result if result != _ffi.NULL else None +def tne_tbool_tbool( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.tne_tbool_tbool(temp1_converted, temp2_converted) + _check_error() + return result if result != _ffi.NULL else None + + def tne_temporal_temporal( temp1: "const Temporal *", temp2: "const Temporal *" ) -> "Temporal *": @@ -9389,6 +9437,16 @@ def tne_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": return result if result != _ffi.NULL else None +def tne_tfloat_tfloat( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.tne_tfloat_tfloat(temp1_converted, temp2_converted) + _check_error() + return result if result != _ffi.NULL else None + + def tne_tpoint_point( temp: "const Temporal *", gs: "const GSERIALIZED *" ) -> "Temporal *": @@ -9416,6 +9474,14 @@ def tne_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": return result if result != _ffi.NULL else None +def tne_tint_tint(temp1: "const Temporal *", temp2: "const Temporal *") -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.tne_tint_tint(temp1_converted, temp2_converted) + _check_error() + return result if result != _ffi.NULL else None + + def tne_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) @@ -9424,6 +9490,16 @@ def tne_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": return result if result != _ffi.NULL else None +def tne_ttext_ttext( + temp1: "const Temporal *", temp2: "const Temporal *" +) -> "Temporal *": + temp1_converted = _ffi.cast("const Temporal *", temp1) + temp2_converted = _ffi.cast("const Temporal *", temp2) + result = _lib.tne_ttext_ttext(temp1_converted, temp2_converted) + _check_error() + return result if result != _ffi.NULL else None + + def adjacent_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": s_converted = _ffi.cast("const Span *", s) temp_converted = _ffi.cast("const Temporal *", temp) From 351b94daf49cf6a8ed00415b42c22f48cb2c85ae Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 28 Jan 2024 17:14:52 +0100 Subject: [PATCH 31/37] Sync last MEOS update --- pymeos_cffi/pymeos_cffi/__init__.py | 1 + pymeos_cffi/pymeos_cffi/builder/meos.h | 1 + pymeos_cffi/pymeos_cffi/functions.py | 29 ++++++++++++++++++++++++++ 3 files changed, 31 insertions(+) diff --git a/pymeos_cffi/pymeos_cffi/__init__.py b/pymeos_cffi/pymeos_cffi/__init__.py index 60a3b6b5..8494eca1 100644 --- a/pymeos_cffi/pymeos_cffi/__init__.py +++ b/pymeos_cffi/pymeos_cffi/__init__.py @@ -1525,6 +1525,7 @@ "temporal_time_split", "tfloat_value_split", "tfloat_value_time_split", + "tpoint_space_split", "tfloatbox_tile", "tfloatbox_tile_list", "timestamptz_bucket", diff --git a/pymeos_cffi/pymeos_cffi/builder/meos.h b/pymeos_cffi/pymeos_cffi/builder/meos.h index 4c52d380..468b81ef 100644 --- a/pymeos_cffi/pymeos_cffi/builder/meos.h +++ b/pymeos_cffi/pymeos_cffi/builder/meos.h @@ -2055,6 +2055,7 @@ extern STBox *stbox_tile_list(const STBox *bounds, double xsize, double ysize, d extern Temporal **temporal_time_split(Temporal *temp, Interval *duration, TimestampTz torigin, TimestampTz **time_buckets, int *count); extern Temporal **tfloat_value_split(Temporal *temp, double size, double origin, double **value_buckets, int *count); extern Temporal **tfloat_value_time_split(Temporal *temp, double size, Interval *duration, double vorigin, TimestampTz torigin, double **value_buckets, TimestampTz **time_buckets, int *count); +extern Temporal **tpoint_space_split(Temporal *temp, float xsize, float ysize, float zsize, GSERIALIZED *sorigin, bool bitmatrix, GSERIALIZED ***space_buckets, int *count); extern TBox *tfloatbox_tile(double value, TimestampTz t, double vsize, Interval *duration, double vorigin, TimestampTz torigin); extern TBox *tfloatbox_tile_list(const TBox *box, double xsize, const Interval *duration, double xorigin, TimestampTz torigin, int *count); extern TimestampTz timestamptz_bucket(TimestampTz timestamp, const Interval *duration, TimestampTz origin); diff --git a/pymeos_cffi/pymeos_cffi/functions.py b/pymeos_cffi/pymeos_cffi/functions.py index 45549018..20e2daa6 100644 --- a/pymeos_cffi/pymeos_cffi/functions.py +++ b/pymeos_cffi/pymeos_cffi/functions.py @@ -12233,6 +12233,35 @@ def tfloat_value_time_split( ) +def tpoint_space_split( + temp: "Temporal *", + xsize: "float", + ysize: "float", + zsize: "float", + sorigin: "GSERIALIZED *", + bitmatrix: bool, +) -> "Tuple['Temporal **', 'GSERIALIZED ***', 'int']": + temp_converted = _ffi.cast("Temporal *", temp) + xsize_converted = _ffi.cast("float", xsize) + ysize_converted = _ffi.cast("float", ysize) + zsize_converted = _ffi.cast("float", zsize) + sorigin_converted = _ffi.cast("GSERIALIZED *", sorigin) + space_buckets = _ffi.new("GSERIALIZED ***") + count = _ffi.new("int *") + result = _lib.tpoint_space_split( + temp_converted, + xsize_converted, + ysize_converted, + zsize_converted, + sorigin_converted, + bitmatrix, + space_buckets, + count, + ) + _check_error() + return result if result != _ffi.NULL else None, space_buckets[0], count[0] + + def tfloatbox_tile( value: float, t: int, From 65b8a08caef3f88378b53dc2e04c22a6d1974509 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 28 Jan 2024 18:11:36 +0100 Subject: [PATCH 32/37] Update pymeos_cffi build dockers --- pymeos_cffi/docker/Dockerfile | 22 ++++++++++------------ pymeos_cffi/docker/MEOS.Dockerfile | 8 ++++---- 2 files changed, 14 insertions(+), 16 deletions(-) diff --git a/pymeos_cffi/docker/Dockerfile b/pymeos_cffi/docker/Dockerfile index c4c107c8..c8cf6dc3 100644 --- a/pymeos_cffi/docker/Dockerfile +++ b/pymeos_cffi/docker/Dockerfile @@ -1,24 +1,22 @@ FROM pymeos/meos:latest WORKDIR MobilityDB -RUN git fetch -RUN git checkout master -RUN git pull +RUN git fetch \ + && git checkout develop \ + && git pull WORKDIR build -RUN cmake .. -DMEOS=on -DGEOS_INCLUDE_DIR=/usr/geos39/include/ -DGEOS_LIBRARY=/usr/geos39/lib64/libgeos_c.so -DGEOS_CONFIG=/usr/geos39/bin/geos-config -RUN make -j -RUN make install +RUN cmake .. -DMEOS=on -DGEOS_INCLUDE_DIR=/usr/geos39/include/ -DGEOS_LIBRARY=/usr/geos39/lib64/libgeos_c.so -DGEOS_CONFIG=/usr/geos39/bin/geos-config -DPROJ_INCLUDE_DIRS=/usr/proj81/include/ -DPROJ_LIBRARIES=/usr/proj81/lib/libproj.so \ + && make -j \ + && make install COPY build_wheels.sh /build_wheels.sh -RUN sed -i -e 's/\r$//' /build_wheels.sh -RUN chmod +x /build_wheels.sh - -RUN rm -rf /opt/python/cp36-cp36m -RUN rm -rf /opt/python/cp312-cp312 -RUN mkdir /wheelhouse_int +RUN sed -i -e 's/\r$//' /build_wheels.sh \ + && chmod +x /build_wheels.sh \ + && rm -rf /opt/python/cp36-cp36m \ + && mkdir /wheelhouse_int ENV LD_LIBRARY_PATH=/usr/lib64;/lib64 diff --git a/pymeos_cffi/docker/MEOS.Dockerfile b/pymeos_cffi/docker/MEOS.Dockerfile index 4b58088e..3b980b7d 100644 --- a/pymeos_cffi/docker/MEOS.Dockerfile +++ b/pymeos_cffi/docker/MEOS.Dockerfile @@ -1,6 +1,6 @@ FROM quay.io/pypa/manylinux2014_x86_64 -RUN yum -y install https://download.postgresql.org/pub/repos/yum/reporpms/EL-7-x86_64/pgdg-redhat-repo-latest.noarch.rpm -RUN yum -y update -RUN yum -y install gcc gcc-c++ make cmake postgresql13-devel proj-devel json-c-devel geos39-devel gsl-devel -RUN git clone https://github.com/MobilityDB/MobilityDB +RUN yum -y install https://download.postgresql.org/pub/repos/yum/reporpms/EL-7-x86_64/pgdg-redhat-repo-latest.noarch.rpm \ + && yum -y update \ + && yum -y install gcc gcc-c++ make cmake postgresql13-devel proj81-devel json-c-devel geos39-devel gsl-devel \ + && git clone https://github.com/Diviloper/MobilityDB From 58b905efacff0827c736aaeaa356a3aa6858b7a8 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 28 Jan 2024 18:11:47 +0100 Subject: [PATCH 33/37] Minor update --- pymeos/pymeos/boxes/stbox.py | 2 +- pymeos/tests/main/tfloat_test.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/pymeos/pymeos/boxes/stbox.py b/pymeos/pymeos/boxes/stbox.py index d82d99dd..05d775aa 100644 --- a/pymeos/pymeos/boxes/stbox.py +++ b/pymeos/pymeos/boxes/stbox.py @@ -250,7 +250,7 @@ def from_geometry_time( else: raise TypeError( f"Operation not supported with types " - "{geometry.__class__} and {time.__class__}" + f"{geometry.__class__} and {time.__class__}" ) return STBox(_inner=result) diff --git a/pymeos/tests/main/tfloat_test.py b/pymeos/tests/main/tfloat_test.py index 8f611a29..2545632d 100644 --- a/pymeos/tests/main/tfloat_test.py +++ b/pymeos/tests/main/tfloat_test.py @@ -3182,8 +3182,8 @@ def test_always_less_ever_greater_or_equal(self, temporal, argument, expected): ) def test_ever_less_always_greater_or_equal(self, temporal, argument, expected): assert temporal.ever_less(argument) == expected - assert temporal.always_greater_or_equal(argument) == not_(expected) - assert temporal.never_less(argument) == not_(expected) + assert temporal.always_greater_or_equal(argument) == (not expected) + assert temporal.never_less(argument) == (not expected) @pytest.mark.parametrize( "temporal, argument, expected", From ba0f30961d5573206edacb2302a5cb5b37e90c94 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sun, 28 Jan 2024 18:12:04 +0100 Subject: [PATCH 34/37] Update pymeos version and sync with pymeos_cffi --- pymeos/pymeos/__init__.py | 2 +- pymeos/pyproject.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pymeos/pymeos/__init__.py b/pymeos/pymeos/__init__.py index e8c0ff1e..fd49e03a 100644 --- a/pymeos/pymeos/__init__.py +++ b/pymeos/pymeos/__init__.py @@ -29,7 +29,7 @@ MeosGeoJsonOutputError, ) -__version__ = "1.1.3b3" +__version__ = "1.1.3b5" __all__ = [ # initialization "pymeos_initialize", diff --git a/pymeos/pyproject.toml b/pymeos/pyproject.toml index 6a930848..5a5062ad 100644 --- a/pymeos/pyproject.toml +++ b/pymeos/pyproject.toml @@ -34,7 +34,7 @@ license = { file = 'LICENSE' } requires-python = '>=3.7' dependencies = [ - 'pymeos-cffi ==1.1.0b4', + 'pymeos-cffi ==1.1.0b5', 'python-dateutil', 'shapely', ] From 46b3f16d11d4ff557e32b856af5fc63da76a3e23 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Thu, 1 Feb 2024 21:23:23 +0100 Subject: [PATCH 35/37] Revert migration to specific temporal comparisons --- pymeos/pymeos/main/tbool.py | 12 +- pymeos/pymeos/main/tfloat.py | 12 +- pymeos/pymeos/main/tint.py | 12 +- pymeos/pymeos/main/tpoint.py | 24 ++-- pymeos/pymeos/main/ttext.py | 12 +- pymeos/pymeos/mixins/temporal_comparison.py | 11 +- pymeos_cffi/pymeos_cffi/__init__.py | 13 +- pymeos_cffi/pymeos_cffi/builder/meos.h | 23 +--- .../pymeos_cffi/builder/templates/init.py | 2 +- pymeos_cffi/pymeos_cffi/functions.py | 125 ++++-------------- 10 files changed, 68 insertions(+), 178 deletions(-) diff --git a/pymeos/pymeos/main/tbool.py b/pymeos/pymeos/main/tbool.py index c59d9272..0a8feefa 100644 --- a/pymeos/pymeos/main/tbool.py +++ b/pymeos/pymeos/main/tbool.py @@ -240,14 +240,12 @@ def temporal_equal(self, other: Union[bool, TBool]) -> TBool: A :class:`TBool` with the result of the temporal equality relation. MEOS Functions: - teq_tbool_tbool, teq_tbool_bool + teq_tbool_tbool, teq_temporal_temporal """ if isinstance(other, bool): result = teq_tbool_bool(self._inner, other) - elif isinstance(other, TBool): - result = teq_tbool_tbool(self._inner, other._inner) else: - raise TypeError(f"Operation not supported with type {other.__class__}") + return super().temporal_equal(other) return Temporal._factory(result) def temporal_not_equal(self, other: Union[bool, TBool]) -> TBool: @@ -261,14 +259,12 @@ def temporal_not_equal(self, other: Union[bool, TBool]) -> TBool: A :class:`TBool` with the result of the temporal inequality relation. MEOS Functions: - tne_tbool_tbool, tne_tbool_bool + tne_tbool_tbool, tne_temporal_temporal """ if isinstance(other, bool): result = tne_tbool_bool(self._inner, other) - elif isinstance(other, TBool): - result = tne_tbool_tbool(self._inner, other._inner) else: - raise TypeError(f"Operation not supported with type {other.__class__}") + return super().temporal_not_equal(other) return Temporal._factory(result) # ------------------------- Restrictions ---------------------------------- diff --git a/pymeos/pymeos/main/tfloat.py b/pymeos/pymeos/main/tfloat.py index fc45ae63..e55b962e 100644 --- a/pymeos/pymeos/main/tfloat.py +++ b/pymeos/pymeos/main/tfloat.py @@ -660,14 +660,12 @@ def temporal_equal(self, other: Union[int, float, TFloat]) -> TBool: A :class:`TBool` with the result of the temporal equality relation. MEOS Functions: - teq_tfloat_float, teq_tfloat_tfloat + teq_tfloat_float, teq_temporal_temporal """ if isinstance(other, int) or isinstance(other, float): result = teq_tfloat_float(self._inner, float(other)) - elif isinstance(other, TFloat): - result = teq_tfloat_tfloat(self._inner, other._inner) else: - raise TypeError(f"Operation not supported with type {other.__class__}") + return super().temporal_equal(other) return Temporal._factory(result) def temporal_not_equal(self, other: Union[int, float, TFloat]) -> TBool: @@ -682,14 +680,12 @@ def temporal_not_equal(self, other: Union[int, float, TFloat]) -> TBool: A :class:`TBool` with the result of the temporal not equal relation. MEOS Functions: - tne_tfloat_float, tne_tfloat_tfloat + tne_tfloat_float, tne_temporal_temporal """ if isinstance(other, int) or isinstance(other, float): result = tne_tfloat_float(self._inner, float(other)) - elif isinstance(other, TFloat): - result = tne_tfloat_tfloat(self._inner, other._inner) else: - raise TypeError(f"Operation not supported with type {other.__class__}") + return super().temporal_not_equal(other) return Temporal._factory(result) def temporal_less(self, other: Union[int, float, TFloat]) -> TBool: diff --git a/pymeos/pymeos/main/tint.py b/pymeos/pymeos/main/tint.py index abf39bc7..a409818c 100644 --- a/pymeos/pymeos/main/tint.py +++ b/pymeos/pymeos/main/tint.py @@ -633,14 +633,12 @@ def temporal_equal(self, other: Union[int, TInt]) -> TBool: A :class:`TBool` with the result of the temporal equality relation. MEOS Functions: - teq_tint_int, teq_tint_tint + teq_tint_int, teq_temporal_temporal """ if isinstance(other, int): result = teq_tint_int(self._inner, other) - elif isinstance(other, TInt): - result = teq_tint_tint(self._inner, other._inner) else: - raise TypeError(f"Operation not supported with type {other.__class__}") + return super().temporal_equal(other) return Temporal._factory(result) def temporal_not_equal(self, other: Union[int, TInt]) -> TBool: @@ -654,14 +652,12 @@ def temporal_not_equal(self, other: Union[int, TInt]) -> TBool: A :class:`TBool` with the result of the temporal not equal relation. MEOS Functions: - tne_tint_int, tne_tint_tint + tne_tint_int, tne_temporal_temporal """ if isinstance(other, int): result = tne_tint_int(self._inner, other) - elif isinstance(other, TInt): - result = tne_tint_tint(self._inner, other._inner) else: - raise TypeError(f"Operation not supported with type {other.__class__}") + return super().temporal_not_equal(other) return Temporal._factory(result) def temporal_less(self, other: Union[int, TInt]) -> TBool: diff --git a/pymeos/pymeos/main/tpoint.py b/pymeos/pymeos/main/tpoint.py index 2e42a9e0..30c196d3 100644 --- a/pymeos/pymeos/main/tpoint.py +++ b/pymeos/pymeos/main/tpoint.py @@ -1645,15 +1645,13 @@ def temporal_equal(self, other: Union[shp.Point, TGeomPoint]) -> TBool: A :class:`TBool` with the result of the temporal equality relation. MEOS Functions: - teq_tpoint_point, teq_tpoint_tpoint + teq_tpoint_point, teq_temporal_temporal """ if isinstance(other, shp.Point): gs = geometry_to_gserialized(other) result = teq_tpoint_point(self._inner, gs) - elif isinstance(other, TGeomPoint): - result = teq_tpoint_tpoint(self._inner, other._inner) else: - raise TypeError(f"Operation not supported with type {other.__class__}") + return super().temporal_equal(other) return Temporal._factory(result) def temporal_not_equal(self, other: Union[shp.Point, TGeomPoint]) -> TBool: @@ -1667,15 +1665,13 @@ def temporal_not_equal(self, other: Union[shp.Point, TGeomPoint]) -> TBool: A :class:`TBool` with the result of the temporal inequality relation. MEOS Functions: - tne_tpoint_point, tne_tpoint_tpoint + tne_tpoint_point, tne_temporal_temporal """ if isinstance(other, shp.Point): gs = geometry_to_gserialized(other) result = tne_tpoint_point(self._inner, gs) - elif isinstance(other, TGeomPoint): - result = tne_tpoint_tpoint(self._inner, other._inner) else: - raise TypeError(f"Operation not supported with type {other.__class__}") + return super().temporal_not_equal(other) return Temporal._factory(result) # ------------------------- Database Operations --------------------------- @@ -1966,15 +1962,13 @@ def temporal_equal(self, other: Union[shp.Point, TGeogPoint]) -> TBool: A :class:`TBool` with the result of the temporal equality relation. MEOS Functions: - teq_tpoint_point, teq_tpoint_tpoint + teq_tpoint_point, teq_temporal_temporal """ if isinstance(other, shp.Point): gs = geography_to_gserialized(other) result = teq_tpoint_point(self._inner, gs) - elif isinstance(other, TGeogPoint): - result = teq_tpoint_tpoint(self._inner, other._inner) else: - raise TypeError(f"Operation not supported with type {other.__class__}") + return super().temporal_equal(other) return Temporal._factory(result) def temporal_not_equal(self, other: Union[shp.Point, TGeogPoint]) -> TBool: @@ -1988,15 +1982,13 @@ def temporal_not_equal(self, other: Union[shp.Point, TGeogPoint]) -> TBool: A :class:`TBool` with the result of the temporal inequality relation. MEOS Functions: - tne_tpoint_point, tne_tpoint_tpoint + tne_tpoint_point, tne_temporal_temporal """ if isinstance(other, shp.Point): gs = geography_to_gserialized(other) result = tne_tpoint_point(self._inner, gs) - elif isinstance(other, TGeogPoint): - result = tne_tpoint_tpoint(self._inner, other._inner) else: - raise TypeError(f"Operation not supported with type {other.__class__}") + return super().temporal_not_equal(other) return Temporal._factory(result) # ------------------------- Database Operations --------------------------- diff --git a/pymeos/pymeos/main/ttext.py b/pymeos/pymeos/main/ttext.py index 1709670a..ef373c73 100644 --- a/pymeos/pymeos/main/ttext.py +++ b/pymeos/pymeos/main/ttext.py @@ -611,14 +611,12 @@ def temporal_equal(self, other: Union[str, TText]) -> TBool: A :class:`TBool` with the result of the temporal equality relation. MEOS Functions: - teq_ttext_text, teq_ttext_ttext + teq_ttext_text, teq_temporal_temporal """ if isinstance(other, str): result = teq_ttext_text(self._inner, other) - elif isinstance(other, TText): - result = teq_ttext_ttext(self._inner, other._inner) else: - raise TypeError(f"Operation not supported with type {other.__class__}") + return super().temporal_equal(other) return Temporal._factory(result) def temporal_not_equal(self, other: Union[str, TText]) -> TBool: @@ -632,14 +630,12 @@ def temporal_not_equal(self, other: Union[str, TText]) -> TBool: A :class:`TBool` with the result of the temporal not equal relation. MEOS Functions: - tne_ttext_text, tne_ttext_ttext + tne_ttext_text, tne_temporal_temporal """ if isinstance(other, str): result = tne_ttext_text(self._inner, other) - elif isinstance(other, TText): - result = tne_ttext_ttext(self._inner, other._inner) else: - raise TypeError(f"Operation not supported with type {other.__class__}") + return super().temporal_not_equal(other) return Temporal._factory(result) def temporal_less(self, other: Union[str, TText]) -> TBool: diff --git a/pymeos/pymeos/mixins/temporal_comparison.py b/pymeos/pymeos/mixins/temporal_comparison.py index c4e484ad..2c8c8397 100644 --- a/pymeos/pymeos/mixins/temporal_comparison.py +++ b/pymeos/pymeos/mixins/temporal_comparison.py @@ -1,6 +1,5 @@ from __future__ import annotations -from abc import ABC, abstractmethod from typing import TypeVar, TYPE_CHECKING from pymeos_cffi import ( @@ -19,8 +18,7 @@ from ..temporal import Temporal -class TTemporallyEquatable(ABC): - @abstractmethod +class TTemporallyEquatable: def temporal_equal(self: Self, other: Temporal) -> TBool: """ Returns the temporal equality relation between `self` and `other`. @@ -34,9 +32,9 @@ def temporal_equal(self: Self, other: Temporal) -> TBool: MEOS Functions: teq_temporal_temporal """ - pass + result = teq_temporal_temporal(self._inner, other._inner) + return self._factory(result) - @abstractmethod def temporal_not_equal(self: Self, other: Temporal) -> TBool: """ Returns the temporal not equal relation between `self` and `other`. @@ -50,7 +48,8 @@ def temporal_not_equal(self: Self, other: Temporal) -> TBool: MEOS Functions: tne_temporal_temporal """ - pass + result = tne_temporal_temporal(self._inner, other._inner) + return self._factory(result) class TTemporallyComparable: diff --git a/pymeos_cffi/pymeos_cffi/__init__.py b/pymeos_cffi/pymeos_cffi/__init__.py index 8494eca1..15ebe9c0 100644 --- a/pymeos_cffi/pymeos_cffi/__init__.py +++ b/pymeos_cffi/pymeos_cffi/__init__.py @@ -2,7 +2,7 @@ from .enums import * from .errors import * -__version__ = "1.1.0b5" +__version__ = "1.1.0b6" __all__ = [ # Exceptions "MeosException", @@ -1164,17 +1164,12 @@ "teq_int_tint", "teq_point_tpoint", "teq_tbool_bool", - "teq_tbool_tbool", "teq_temporal_temporal", "teq_text_ttext", "teq_tfloat_float", - "teq_tfloat_tfloat", "teq_tpoint_point", - "teq_tpoint_tpoint", "teq_tint_int", - "teq_tint_tint", "teq_ttext_text", - "teq_ttext_ttext", "tge_float_tfloat", "tge_int_tint", "tge_temporal_temporal", @@ -1208,17 +1203,12 @@ "tne_int_tint", "tne_point_tpoint", "tne_tbool_bool", - "tne_tbool_tbool", "tne_temporal_temporal", "tne_text_ttext", "tne_tfloat_float", - "tne_tfloat_tfloat", "tne_tpoint_point", - "tne_tpoint_tpoint", "tne_tint_int", - "tne_tint_tint", "tne_ttext_text", - "tne_ttext_ttext", "adjacent_numspan_tnumber", "adjacent_stbox_tpoint", "adjacent_tbox_tnumber", @@ -1533,6 +1523,7 @@ "tint_value_time_split", "tintbox_tile", "tintbox_tile_list", + "tpoint_space_split", "tpoint_space_time_split", "tstzspan_bucket_list", "temptype_subtype", diff --git a/pymeos_cffi/pymeos_cffi/builder/meos.h b/pymeos_cffi/pymeos_cffi/builder/meos.h index 468b81ef..b4006898 100644 --- a/pymeos_cffi/pymeos_cffi/builder/meos.h +++ b/pymeos_cffi/pymeos_cffi/builder/meos.h @@ -1677,41 +1677,36 @@ extern Temporal *teq_float_tfloat(double d, const Temporal *temp); extern Temporal *teq_int_tint(int i, const Temporal *temp); extern Temporal *teq_point_tpoint(const GSERIALIZED *gs, const Temporal *temp); extern Temporal *teq_tbool_bool(const Temporal *temp, bool b); -extern Temporal *teq_tbool_tbool(const Temporal *temp1, const Temporal *temp2); -/* extern Temporal *teq_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ +extern Temporal *teq_temporal_temporal(const Temporal *temp1, const Temporal *temp2); extern Temporal *teq_text_ttext(const text *txt, const Temporal *temp); extern Temporal *teq_tfloat_float(const Temporal *temp, double d); -extern Temporal *teq_tfloat_tfloat(const Temporal *temp1, const Temporal *temp2); extern Temporal *teq_tpoint_point(const Temporal *temp, const GSERIALIZED *gs); -extern Temporal *teq_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); extern Temporal *teq_tint_int(const Temporal *temp, int i); -extern Temporal *teq_tint_tint(const Temporal *temp1, const Temporal *temp2); extern Temporal *teq_ttext_text(const Temporal *temp, const text *txt); -extern Temporal *teq_ttext_ttext(const Temporal *temp1, const Temporal *temp2); extern Temporal *tge_float_tfloat(double d, const Temporal *temp); extern Temporal *tge_int_tint(int i, const Temporal *temp); -/* extern Temporal *tge_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ +extern Temporal *tge_temporal_temporal(const Temporal *temp1, const Temporal *temp2); extern Temporal *tge_text_ttext(const text *txt, const Temporal *temp); extern Temporal *tge_tfloat_float(const Temporal *temp, double d); extern Temporal *tge_tint_int(const Temporal *temp, int i); extern Temporal *tge_ttext_text(const Temporal *temp, const text *txt); extern Temporal *tgt_float_tfloat(double d, const Temporal *temp); extern Temporal *tgt_int_tint(int i, const Temporal *temp); -/* extern Temporal *tgt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ +extern Temporal *tgt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); extern Temporal *tgt_text_ttext(const text *txt, const Temporal *temp); extern Temporal *tgt_tfloat_float(const Temporal *temp, double d); extern Temporal *tgt_tint_int(const Temporal *temp, int i); extern Temporal *tgt_ttext_text(const Temporal *temp, const text *txt); extern Temporal *tle_float_tfloat(double d, const Temporal *temp); extern Temporal *tle_int_tint(int i, const Temporal *temp); -/* extern Temporal *tle_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ +extern Temporal *tle_temporal_temporal(const Temporal *temp1, const Temporal *temp2); extern Temporal *tle_text_ttext(const text *txt, const Temporal *temp); extern Temporal *tle_tfloat_float(const Temporal *temp, double d); extern Temporal *tle_tint_int(const Temporal *temp, int i); extern Temporal *tle_ttext_text(const Temporal *temp, const text *txt); extern Temporal *tlt_float_tfloat(double d, const Temporal *temp); extern Temporal *tlt_int_tint(int i, const Temporal *temp); -/* extern Temporal *tlt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ +extern Temporal *tlt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); extern Temporal *tlt_text_ttext(const text *txt, const Temporal *temp); extern Temporal *tlt_tfloat_float(const Temporal *temp, double d); extern Temporal *tlt_tint_int(const Temporal *temp, int i); @@ -1721,17 +1716,12 @@ extern Temporal *tne_float_tfloat(double d, const Temporal *temp); extern Temporal *tne_int_tint(int i, const Temporal *temp); extern Temporal *tne_point_tpoint(const GSERIALIZED *gs, const Temporal *temp); extern Temporal *tne_tbool_bool(const Temporal *temp, bool b); -extern Temporal *tne_tbool_tbool(const Temporal *temp1, const Temporal *temp2); -/* extern Temporal *tne_temporal_temporal(const Temporal *temp1, const Temporal *temp2); (undefined) */ +extern Temporal *tne_temporal_temporal(const Temporal *temp1, const Temporal *temp2); extern Temporal *tne_text_ttext(const text *txt, const Temporal *temp); extern Temporal *tne_tfloat_float(const Temporal *temp, double d); -extern Temporal *tne_tfloat_tfloat(const Temporal *temp1, const Temporal *temp2); extern Temporal *tne_tpoint_point(const Temporal *temp, const GSERIALIZED *gs); -extern Temporal *tne_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); extern Temporal *tne_tint_int(const Temporal *temp, int i); -extern Temporal *tne_tint_tint(const Temporal *temp1, const Temporal *temp2); extern Temporal *tne_ttext_text(const Temporal *temp, const text *txt); -extern Temporal *tne_ttext_ttext(const Temporal *temp1, const Temporal *temp2); extern bool adjacent_numspan_tnumber(const Span *s, const Temporal *temp); extern bool adjacent_stbox_tpoint(const STBox *box, const Temporal *temp); @@ -2063,6 +2053,7 @@ extern Temporal **tint_value_split(Temporal *temp, int size, int origin, int **v extern Temporal **tint_value_time_split(Temporal *temp, int size, Interval *duration, int vorigin, TimestampTz torigin, int **value_buckets, TimestampTz **time_buckets, int *count); extern TBox *tintbox_tile(int value, TimestampTz t, int vsize, Interval *duration, int vorigin, TimestampTz torigin); extern TBox *tintbox_tile_list(const TBox *box, int xsize, const Interval *duration, int xorigin, TimestampTz torigin, int *count); +/* extern Temporal **tpoint_space_split(Temporal *temp, float xsize, float ysize, float zsize, GSERIALIZED *sorigin, bool bitmatrix, GSERIALIZED ***space_buckets, int *count); (repeated) */ extern Temporal **tpoint_space_time_split(Temporal *temp, float xsize, float ysize, float zsize, Interval *duration, GSERIALIZED *sorigin, TimestampTz torigin, bool bitmatrix, GSERIALIZED ***space_buckets, TimestampTz **time_buckets, int *count); extern Span *tstzspan_bucket_list(const Span *bounds, const Interval *duration, TimestampTz origin, int *count); diff --git a/pymeos_cffi/pymeos_cffi/builder/templates/init.py b/pymeos_cffi/pymeos_cffi/builder/templates/init.py index 1704b694..33bc56e6 100644 --- a/pymeos_cffi/pymeos_cffi/builder/templates/init.py +++ b/pymeos_cffi/pymeos_cffi/builder/templates/init.py @@ -2,7 +2,7 @@ from .enums import * from .errors import * -__version__ = "1.1.0b5" +__version__ = "1.1.0b6" __all__ = [ # Exceptions "MeosException", diff --git a/pymeos_cffi/pymeos_cffi/functions.py b/pymeos_cffi/pymeos_cffi/functions.py index 20e2daa6..15c511d3 100644 --- a/pymeos_cffi/pymeos_cffi/functions.py +++ b/pymeos_cffi/pymeos_cffi/functions.py @@ -9050,16 +9050,6 @@ def teq_tbool_bool(temp: "const Temporal *", b: bool) -> "Temporal *": return result if result != _ffi.NULL else None -def teq_tbool_tbool( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - result = _lib.teq_tbool_tbool(temp1_converted, temp2_converted) - _check_error() - return result if result != _ffi.NULL else None - - def teq_temporal_temporal( temp1: "const Temporal *", temp2: "const Temporal *" ) -> "Temporal *": @@ -9085,16 +9075,6 @@ def teq_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": return result if result != _ffi.NULL else None -def teq_tfloat_tfloat( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - result = _lib.teq_tfloat_tfloat(temp1_converted, temp2_converted) - _check_error() - return result if result != _ffi.NULL else None - - def teq_tpoint_point( temp: "const Temporal *", gs: "const GSERIALIZED *" ) -> "Temporal *": @@ -9105,16 +9085,6 @@ def teq_tpoint_point( return result if result != _ffi.NULL else None -def teq_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - result = _lib.teq_tpoint_tpoint(temp1_converted, temp2_converted) - _check_error() - return result if result != _ffi.NULL else None - - def teq_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.teq_tint_int(temp_converted, i) @@ -9122,14 +9092,6 @@ def teq_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": return result if result != _ffi.NULL else None -def teq_tint_tint(temp1: "const Temporal *", temp2: "const Temporal *") -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - result = _lib.teq_tint_tint(temp1_converted, temp2_converted) - _check_error() - return result if result != _ffi.NULL else None - - def teq_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) @@ -9138,16 +9100,6 @@ def teq_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": return result if result != _ffi.NULL else None -def teq_ttext_ttext( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - result = _lib.teq_ttext_ttext(temp1_converted, temp2_converted) - _check_error() - return result if result != _ffi.NULL else None - - def tge_float_tfloat(d: float, temp: "const Temporal *") -> "Temporal *": temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tge_float_tfloat(d, temp_converted) @@ -9402,16 +9354,6 @@ def tne_tbool_bool(temp: "const Temporal *", b: bool) -> "Temporal *": return result if result != _ffi.NULL else None -def tne_tbool_tbool( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - result = _lib.tne_tbool_tbool(temp1_converted, temp2_converted) - _check_error() - return result if result != _ffi.NULL else None - - def tne_temporal_temporal( temp1: "const Temporal *", temp2: "const Temporal *" ) -> "Temporal *": @@ -9437,16 +9379,6 @@ def tne_tfloat_float(temp: "const Temporal *", d: float) -> "Temporal *": return result if result != _ffi.NULL else None -def tne_tfloat_tfloat( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - result = _lib.tne_tfloat_tfloat(temp1_converted, temp2_converted) - _check_error() - return result if result != _ffi.NULL else None - - def tne_tpoint_point( temp: "const Temporal *", gs: "const GSERIALIZED *" ) -> "Temporal *": @@ -9457,16 +9389,6 @@ def tne_tpoint_point( return result if result != _ffi.NULL else None -def tne_tpoint_tpoint( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - result = _lib.tne_tpoint_tpoint(temp1_converted, temp2_converted) - _check_error() - return result if result != _ffi.NULL else None - - def tne_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": temp_converted = _ffi.cast("const Temporal *", temp) result = _lib.tne_tint_int(temp_converted, i) @@ -9474,14 +9396,6 @@ def tne_tint_int(temp: "const Temporal *", i: int) -> "Temporal *": return result if result != _ffi.NULL else None -def tne_tint_tint(temp1: "const Temporal *", temp2: "const Temporal *") -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - result = _lib.tne_tint_tint(temp1_converted, temp2_converted) - _check_error() - return result if result != _ffi.NULL else None - - def tne_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": temp_converted = _ffi.cast("const Temporal *", temp) txt_converted = cstring2text(txt) @@ -9490,16 +9404,6 @@ def tne_ttext_text(temp: "const Temporal *", txt: str) -> "Temporal *": return result if result != _ffi.NULL else None -def tne_ttext_ttext( - temp1: "const Temporal *", temp2: "const Temporal *" -) -> "Temporal *": - temp1_converted = _ffi.cast("const Temporal *", temp1) - temp2_converted = _ffi.cast("const Temporal *", temp2) - result = _lib.tne_ttext_ttext(temp1_converted, temp2_converted) - _check_error() - return result if result != _ffi.NULL else None - - def adjacent_numspan_tnumber(s: "const Span *", temp: "const Temporal *") -> "bool": s_converted = _ffi.cast("const Span *", s) temp_converted = _ffi.cast("const Temporal *", temp) @@ -12397,6 +12301,35 @@ def tintbox_tile_list( return result if result != _ffi.NULL else None, count[0] +def tpoint_space_split( + temp: "Temporal *", + xsize: "float", + ysize: "float", + zsize: "float", + sorigin: "GSERIALIZED *", + bitmatrix: bool, +) -> "Tuple['Temporal **', 'GSERIALIZED ***', 'int']": + temp_converted = _ffi.cast("Temporal *", temp) + xsize_converted = _ffi.cast("float", xsize) + ysize_converted = _ffi.cast("float", ysize) + zsize_converted = _ffi.cast("float", zsize) + sorigin_converted = _ffi.cast("GSERIALIZED *", sorigin) + space_buckets = _ffi.new("GSERIALIZED ***") + count = _ffi.new("int *") + result = _lib.tpoint_space_split( + temp_converted, + xsize_converted, + ysize_converted, + zsize_converted, + sorigin_converted, + bitmatrix, + space_buckets, + count, + ) + _check_error() + return result if result != _ffi.NULL else None, space_buckets[0], count[0] + + def tpoint_space_time_split( temp: "Temporal *", xsize: "float", From 9703ed380898b23a537567567e3f2a212131a58e Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sat, 3 Feb 2024 19:35:29 +0100 Subject: [PATCH 36/37] Sync with meos, use MobilityDB/MobilityDB to build package, and bump version to rc1 --- pymeos/pymeos/__init__.py | 2 +- pymeos/pyproject.toml | 2 +- pymeos_cffi/docker/MEOS.Dockerfile | 2 +- pymeos_cffi/pymeos_cffi/__init__.py | 3 +- pymeos_cffi/pymeos_cffi/builder/meos.h | 3 +- .../pymeos_cffi/builder/templates/init.py | 2 +- pymeos_cffi/pymeos_cffi/functions.py | 29 ------------------- 7 files changed, 6 insertions(+), 37 deletions(-) diff --git a/pymeos/pymeos/__init__.py b/pymeos/pymeos/__init__.py index fd49e03a..9189d196 100644 --- a/pymeos/pymeos/__init__.py +++ b/pymeos/pymeos/__init__.py @@ -29,7 +29,7 @@ MeosGeoJsonOutputError, ) -__version__ = "1.1.3b5" +__version__ = "1.1.3rc1" __all__ = [ # initialization "pymeos_initialize", diff --git a/pymeos/pyproject.toml b/pymeos/pyproject.toml index 5a5062ad..8449251e 100644 --- a/pymeos/pyproject.toml +++ b/pymeos/pyproject.toml @@ -34,7 +34,7 @@ license = { file = 'LICENSE' } requires-python = '>=3.7' dependencies = [ - 'pymeos-cffi ==1.1.0b5', + 'pymeos-cffi ==1.1.0rc1', 'python-dateutil', 'shapely', ] diff --git a/pymeos_cffi/docker/MEOS.Dockerfile b/pymeos_cffi/docker/MEOS.Dockerfile index 3b980b7d..8d4f0a61 100644 --- a/pymeos_cffi/docker/MEOS.Dockerfile +++ b/pymeos_cffi/docker/MEOS.Dockerfile @@ -3,4 +3,4 @@ FROM quay.io/pypa/manylinux2014_x86_64 RUN yum -y install https://download.postgresql.org/pub/repos/yum/reporpms/EL-7-x86_64/pgdg-redhat-repo-latest.noarch.rpm \ && yum -y update \ && yum -y install gcc gcc-c++ make cmake postgresql13-devel proj81-devel json-c-devel geos39-devel gsl-devel \ - && git clone https://github.com/Diviloper/MobilityDB + && git clone https://github.com/MobilityDB/MobilityDB diff --git a/pymeos_cffi/pymeos_cffi/__init__.py b/pymeos_cffi/pymeos_cffi/__init__.py index 15ebe9c0..fe926c5e 100644 --- a/pymeos_cffi/pymeos_cffi/__init__.py +++ b/pymeos_cffi/pymeos_cffi/__init__.py @@ -2,7 +2,7 @@ from .enums import * from .errors import * -__version__ = "1.1.0b6" +__version__ = "1.1.0rc1" __all__ = [ # Exceptions "MeosException", @@ -1515,7 +1515,6 @@ "temporal_time_split", "tfloat_value_split", "tfloat_value_time_split", - "tpoint_space_split", "tfloatbox_tile", "tfloatbox_tile_list", "timestamptz_bucket", diff --git a/pymeos_cffi/pymeos_cffi/builder/meos.h b/pymeos_cffi/pymeos_cffi/builder/meos.h index b4006898..fdd030fe 100644 --- a/pymeos_cffi/pymeos_cffi/builder/meos.h +++ b/pymeos_cffi/pymeos_cffi/builder/meos.h @@ -2045,7 +2045,6 @@ extern STBox *stbox_tile_list(const STBox *bounds, double xsize, double ysize, d extern Temporal **temporal_time_split(Temporal *temp, Interval *duration, TimestampTz torigin, TimestampTz **time_buckets, int *count); extern Temporal **tfloat_value_split(Temporal *temp, double size, double origin, double **value_buckets, int *count); extern Temporal **tfloat_value_time_split(Temporal *temp, double size, Interval *duration, double vorigin, TimestampTz torigin, double **value_buckets, TimestampTz **time_buckets, int *count); -extern Temporal **tpoint_space_split(Temporal *temp, float xsize, float ysize, float zsize, GSERIALIZED *sorigin, bool bitmatrix, GSERIALIZED ***space_buckets, int *count); extern TBox *tfloatbox_tile(double value, TimestampTz t, double vsize, Interval *duration, double vorigin, TimestampTz torigin); extern TBox *tfloatbox_tile_list(const TBox *box, double xsize, const Interval *duration, double xorigin, TimestampTz torigin, int *count); extern TimestampTz timestamptz_bucket(TimestampTz timestamp, const Interval *duration, TimestampTz origin); @@ -2053,7 +2052,7 @@ extern Temporal **tint_value_split(Temporal *temp, int size, int origin, int **v extern Temporal **tint_value_time_split(Temporal *temp, int size, Interval *duration, int vorigin, TimestampTz torigin, int **value_buckets, TimestampTz **time_buckets, int *count); extern TBox *tintbox_tile(int value, TimestampTz t, int vsize, Interval *duration, int vorigin, TimestampTz torigin); extern TBox *tintbox_tile_list(const TBox *box, int xsize, const Interval *duration, int xorigin, TimestampTz torigin, int *count); -/* extern Temporal **tpoint_space_split(Temporal *temp, float xsize, float ysize, float zsize, GSERIALIZED *sorigin, bool bitmatrix, GSERIALIZED ***space_buckets, int *count); (repeated) */ +extern Temporal **tpoint_space_split(Temporal *temp, float xsize, float ysize, float zsize, GSERIALIZED *sorigin, bool bitmatrix, GSERIALIZED ***space_buckets, int *count); extern Temporal **tpoint_space_time_split(Temporal *temp, float xsize, float ysize, float zsize, Interval *duration, GSERIALIZED *sorigin, TimestampTz torigin, bool bitmatrix, GSERIALIZED ***space_buckets, TimestampTz **time_buckets, int *count); extern Span *tstzspan_bucket_list(const Span *bounds, const Interval *duration, TimestampTz origin, int *count); diff --git a/pymeos_cffi/pymeos_cffi/builder/templates/init.py b/pymeos_cffi/pymeos_cffi/builder/templates/init.py index 33bc56e6..1879f495 100644 --- a/pymeos_cffi/pymeos_cffi/builder/templates/init.py +++ b/pymeos_cffi/pymeos_cffi/builder/templates/init.py @@ -2,7 +2,7 @@ from .enums import * from .errors import * -__version__ = "1.1.0b6" +__version__ = "1.1.0rc1" __all__ = [ # Exceptions "MeosException", diff --git a/pymeos_cffi/pymeos_cffi/functions.py b/pymeos_cffi/pymeos_cffi/functions.py index 15c511d3..e05b5b71 100644 --- a/pymeos_cffi/pymeos_cffi/functions.py +++ b/pymeos_cffi/pymeos_cffi/functions.py @@ -12137,35 +12137,6 @@ def tfloat_value_time_split( ) -def tpoint_space_split( - temp: "Temporal *", - xsize: "float", - ysize: "float", - zsize: "float", - sorigin: "GSERIALIZED *", - bitmatrix: bool, -) -> "Tuple['Temporal **', 'GSERIALIZED ***', 'int']": - temp_converted = _ffi.cast("Temporal *", temp) - xsize_converted = _ffi.cast("float", xsize) - ysize_converted = _ffi.cast("float", ysize) - zsize_converted = _ffi.cast("float", zsize) - sorigin_converted = _ffi.cast("GSERIALIZED *", sorigin) - space_buckets = _ffi.new("GSERIALIZED ***") - count = _ffi.new("int *") - result = _lib.tpoint_space_split( - temp_converted, - xsize_converted, - ysize_converted, - zsize_converted, - sorigin_converted, - bitmatrix, - space_buckets, - count, - ) - _check_error() - return result if result != _ffi.NULL else None, space_buckets[0], count[0] - - def tfloatbox_tile( value: float, t: int, From 5d97899ad40ee24092f7f1b3f90460aa3e5ba421 Mon Sep 17 00:00:00 2001 From: Diviloper Date: Sat, 3 Feb 2024 20:06:12 +0100 Subject: [PATCH 37/37] Run examples with new version --- pymeos_examples/PyMEOS_Examples/AIS.ipynb | 150 +++++----- .../PyMEOS_Examples/BerlinMOD.ipynb | 256 +++++++++--------- 2 files changed, 213 insertions(+), 193 deletions(-) diff --git a/pymeos_examples/PyMEOS_Examples/AIS.ipynb b/pymeos_examples/PyMEOS_Examples/AIS.ipynb index 5c590acc..8ba1b89b 100644 --- a/pymeos_examples/PyMEOS_Examples/AIS.ipynb +++ b/pymeos_examples/PyMEOS_Examples/AIS.ipynb @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 1, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -49,8 +49,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-12-11T22:36:10.601257Z", - "start_time": "2023-12-11T22:36:10.514258Z" + "end_time": "2024-02-03T18:53:15.803897500Z", + "start_time": "2024-02-03T18:53:14.766157300Z" } } }, @@ -76,14 +76,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 2, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 16.1 s, sys: 629 ms, total: 16.7 s\n", - "Wall time: 16.9 s\n" + "CPU times: user 17.3 s, sys: 861 ms, total: 18.2 s\n", + "Wall time: 18.3 s\n" ] }, { @@ -91,7 +91,7 @@ "text/plain": " t mmsi lat lon sog\n0 2023-10-19 219029699 57.137907 9.127860 0.0\n1 2023-10-19 219005827 56.803713 9.020183 0.0\n2 2023-10-19 219006283 56.764315 8.863167 0.0\n3 2023-10-19 220466000 56.970548 9.257460 0.1\n4 2023-10-19 210731000 54.220680 11.386588 7.5", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
tmmsilatlonsog
02023-10-1921902969957.1379079.1278600.0
12023-10-1921900582756.8037139.0201830.0
22023-10-1921900628356.7643158.8631670.0
32023-10-1922046600056.9705489.2574600.1
42023-10-1921073100054.22068011.3865887.5
\n
" }, - "execution_count": 13, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -116,8 +116,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-12-11T22:36:27.399785700Z", - "start_time": "2023-12-11T22:36:10.523258200Z" + "end_time": "2024-02-03T18:53:35.800662100Z", + "start_time": "2024-02-03T18:53:17.511652900Z" } } }, @@ -132,7 +132,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 3, "outputs": [ { "data": { @@ -140,7 +140,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "7f3ec97608a7476994446d596aa61c10" + "model_id": "663c5d7a4d3947dea8f37761252906b5" } }, "metadata": {}, @@ -152,7 +152,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "4ebde883cc524aa79ecb413414bb169e" + "model_id": "4e595601ce0d48eeb2c3adcd81e1556f" } }, "metadata": {}, @@ -171,21 +171,21 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-12-11T22:42:17.997080400Z", - "start_time": "2023-12-11T22:36:27.395783800Z" + "end_time": "2024-02-03T18:59:47.396491100Z", + "start_time": "2024-02-03T18:53:35.791660600Z" } } }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 4, "outputs": [ { "data": { "text/plain": " t mmsi sog \\\n0 2023-10-19 219029699 0@2023-10-19 00:00:00+02 \n1 2023-10-19 219005827 0@2023-10-19 00:00:00+02 \n2 2023-10-19 219006283 0@2023-10-19 00:00:00+02 \n3 2023-10-19 220466000 0.1@2023-10-19 00:00:00+02 \n4 2023-10-19 210731000 7.5@2023-10-19 00:00:00+02 \n\n instant \n0 POINT(9.12786 57.137907)@2023-10-19 00:00:00+02 \n1 POINT(9.020183 56.803713)@2023-10-19 00:00:00+02 \n2 POINT(8.863167 56.764315)@2023-10-19 00:00:00+02 \n3 POINT(9.25746 56.970548)@2023-10-19 00:00:00+02 \n4 POINT(11.386588 54.22068)@2023-10-19 00:00:00+02 ", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
tmmsisoginstant
02023-10-192190296990@2023-10-19 00:00:00+02POINT(9.12786 57.137907)@2023-10-19 00:00:00+02
12023-10-192190058270@2023-10-19 00:00:00+02POINT(9.020183 56.803713)@2023-10-19 00:00:00+02
22023-10-192190062830@2023-10-19 00:00:00+02POINT(8.863167 56.764315)@2023-10-19 00:00:00+02
32023-10-192204660000.1@2023-10-19 00:00:00+02POINT(9.25746 56.970548)@2023-10-19 00:00:00+02
42023-10-192107310007.5@2023-10-19 00:00:00+02POINT(11.386588 54.22068)@2023-10-19 00:00:00+02
\n
" }, - "execution_count": 15, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -197,8 +197,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-12-11T22:42:18.378503800Z", - "start_time": "2023-12-11T22:42:17.996081200Z" + "end_time": "2024-02-03T18:59:47.787830600Z", + "start_time": "2024-02-03T18:59:47.395489200Z" } } }, @@ -215,14 +215,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 5, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 32.1 s, sys: 188 ms, total: 32.3 s\n", - "Wall time: 32.3 s\n" + "CPU times: user 30.2 s, sys: 333 ms, total: 30.6 s\n", + "Wall time: 30.6 s\n" ] }, { @@ -230,7 +230,7 @@ "text/plain": " trajectory \\\nmmsi \n2190045 [POINT(8.44805 55.464272)@2023-10-19 00:00:10+... \n9109416 [POINT(9.785182 54.909655)@2023-10-19 05:21:13... \n111219504 [POINT(9.838743 57.103408)@2023-10-19 07:32:04... \n111219508 [POINT(12.121327 55.591252)@2023-10-19 11:52:4... \n111219512 [POINT(9.286713 55.220503)@2023-10-19 09:44:07... \n\n sog distance \nmmsi \n2190045 [0@2023-10-19 00:00:10+02, 0.1@2023-10-19 00:0... 4196.237335 \n9109416 [1.4@2023-10-19 05:21:13+02, 0.2@2023-10-19 05... 48.376014 \n111219504 [0@2023-10-19 07:32:04+02, 0@2023-10-19 07:34:... 249300.505518 \n111219508 [1.7@2023-10-19 11:52:43+02, 7.5@2023-10-19 11... 463414.183253 \n111219512 [16.9@2023-10-19 09:44:07+02, 54.2@2023-10-19 ... 122854.298352 ", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
trajectorysogdistance
mmsi
2190045[POINT(8.44805 55.464272)@2023-10-19 00:00:10+...[0@2023-10-19 00:00:10+02, 0.1@2023-10-19 00:0...4196.237335
9109416[POINT(9.785182 54.909655)@2023-10-19 05:21:13...[1.4@2023-10-19 05:21:13+02, 0.2@2023-10-19 05...48.376014
111219504[POINT(9.838743 57.103408)@2023-10-19 07:32:04...[0@2023-10-19 07:32:04+02, 0@2023-10-19 07:34:...249300.505518
111219508[POINT(12.121327 55.591252)@2023-10-19 11:52:4...[1.7@2023-10-19 11:52:43+02, 7.5@2023-10-19 11...463414.183253
111219512[POINT(9.286713 55.220503)@2023-10-19 09:44:07...[16.9@2023-10-19 09:44:07+02, 54.2@2023-10-19 ...122854.298352
\n
" }, - "execution_count": 16, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -253,8 +253,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-12-11T22:42:50.706548900Z", - "start_time": "2023-12-11T22:42:18.371504800Z" + "end_time": "2024-02-03T19:00:18.427946600Z", + "start_time": "2024-02-03T18:59:47.786832800Z" } } }, @@ -269,14 +269,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 6, "outputs": [ { "data": { "text/plain": " original #points PyMEOS #points Points kept (%)\nmmsi \n2190045 8849 7180 81.139112\n9109416 63 58 92.063492\n111219504 3162 3058 96.710942\n111219508 5830 5760 98.799314\n111219512 799 773 96.745932\n... ... ... ...\n677064088 696 636 91.379310\n826500702 370 286 77.297297\n887222300 867 548 63.206459\n912190064 85 83 97.647059\n912191373 750 2 0.266667\n\n[2884 rows x 3 columns]", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
original #pointsPyMEOS #pointsPoints kept (%)
mmsi
21900458849718081.139112
9109416635892.063492
1112195043162305896.710942
1112195085830576098.799314
11121951279977396.745932
............
67706408869663691.379310
82650070237028677.297297
88722230086754863.206459
912190064858397.647059
91219137375020.266667
\n

2884 rows × 3 columns

\n
" }, - "execution_count": 17, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -299,8 +299,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-12-11T22:42:50.865103300Z", - "start_time": "2023-12-11T22:42:50.698549500Z" + "end_time": "2024-02-03T19:01:16.569003700Z", + "start_time": "2024-02-03T19:01:16.409027Z" } } }, @@ -315,7 +315,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 7, "outputs": [ { "data": { @@ -337,8 +337,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-12-11T22:43:00.690388300Z", - "start_time": "2023-12-11T22:42:50.818102100Z" + "end_time": "2024-02-03T19:01:27.858702300Z", + "start_time": "2024-02-03T19:01:17.861083800Z" } } }, @@ -365,22 +365,8 @@ }, { "cell_type": "code", - "execution_count": 19, - "outputs": [ - { - "ename": "OperationalError", - "evalue": "connection failed: Connection refused\n\tIs the server running on that host and accepting TCP/IP connections?", - "output_type": "error", - "traceback": [ - "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mOperationalError\u001B[0m Traceback (most recent call last)", - "Cell \u001B[0;32mIn[19], line 9\u001B[0m\n\u001B[1;32m 6\u001B[0m user \u001B[38;5;241m=\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mdocker\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 7\u001B[0m password \u001B[38;5;241m=\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mdocker\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m----> 9\u001B[0m connection \u001B[38;5;241m=\u001B[39m \u001B[43mMobilityDB\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mconnect\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 10\u001B[0m \u001B[43m \u001B[49m\u001B[43mhost\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mhost\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mport\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mport\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mdbname\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdb\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43muser\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43muser\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mpassword\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mpassword\u001B[49m\n\u001B[1;32m 11\u001B[0m \u001B[43m)\u001B[49m\n\u001B[1;32m 12\u001B[0m cursor \u001B[38;5;241m=\u001B[39m connection\u001B[38;5;241m.\u001B[39mcursor()\n", - "File \u001B[0;32m~/.virtualenvs/pymeos_examples/lib/python3.10/site-packages/pymeos/db/psycopg.py:46\u001B[0m, in \u001B[0;36mMobilityDB.connect\u001B[0;34m(cls, *args, **kwargs)\u001B[0m\n\u001B[1;32m 29\u001B[0m \u001B[38;5;129m@classmethod\u001B[39m\n\u001B[1;32m 30\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mconnect\u001B[39m(\u001B[38;5;28mcls\u001B[39m, \u001B[38;5;241m*\u001B[39margs, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs):\n\u001B[1;32m 31\u001B[0m \u001B[38;5;250m \u001B[39m\u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 32\u001B[0m \u001B[38;5;124;03m Establishes a connection to a MobilityDB server.\u001B[39;00m\n\u001B[1;32m 33\u001B[0m \n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 44\u001B[0m \n\u001B[1;32m 45\u001B[0m \u001B[38;5;124;03m \"\"\"\u001B[39;00m\n\u001B[0;32m---> 46\u001B[0m connection \u001B[38;5;241m=\u001B[39m \u001B[43mconnect\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 47\u001B[0m \u001B[38;5;28mcls\u001B[39m\u001B[38;5;241m.\u001B[39mregister(connection)\n\u001B[1;32m 48\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m connection\n", - "File \u001B[0;32m~/.virtualenvs/pymeos_examples/lib/python3.10/site-packages/psycopg/connection.py:729\u001B[0m, in \u001B[0;36mConnection.connect\u001B[0;34m(cls, conninfo, autocommit, prepare_threshold, row_factory, cursor_factory, context, **kwargs)\u001B[0m\n\u001B[1;32m 724\u001B[0m rv \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mcls\u001B[39m\u001B[38;5;241m.\u001B[39m_wait_conn(\n\u001B[1;32m 725\u001B[0m \u001B[38;5;28mcls\u001B[39m\u001B[38;5;241m.\u001B[39m_connect_gen(conninfo, autocommit\u001B[38;5;241m=\u001B[39mautocommit),\n\u001B[1;32m 726\u001B[0m timeout\u001B[38;5;241m=\u001B[39mparams[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mconnect_timeout\u001B[39m\u001B[38;5;124m\"\u001B[39m],\n\u001B[1;32m 727\u001B[0m )\n\u001B[1;32m 728\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m e\u001B[38;5;241m.\u001B[39m_NO_TRACEBACK \u001B[38;5;28;01mas\u001B[39;00m ex:\n\u001B[0;32m--> 729\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m ex\u001B[38;5;241m.\u001B[39mwith_traceback(\u001B[38;5;28;01mNone\u001B[39;00m)\n\u001B[1;32m 731\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m row_factory:\n\u001B[1;32m 732\u001B[0m rv\u001B[38;5;241m.\u001B[39mrow_factory \u001B[38;5;241m=\u001B[39m row_factory\n", - "\u001B[0;31mOperationalError\u001B[0m: connection failed: Connection refused\n\tIs the server running on that host and accepting TCP/IP connections?" - ] - } - ], + "execution_count": 8, + "outputs": [], "source": [ "from pymeos.db.psycopg import MobilityDB\n", "\n", @@ -398,8 +384,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-12-11T22:43:00.810387100Z", - "start_time": "2023-12-11T22:43:00.689387900Z" + "end_time": "2024-02-03T19:01:31.835316300Z", + "start_time": "2024-02-03T19:01:31.716322500Z" } } }, @@ -414,7 +400,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "outputs": [], "source": [ "cursor.execute(\"DROP TABLE IF EXISTS public.PyMEOS_demo;\")\n", @@ -427,8 +413,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-12-11T22:43:00.827387900Z", - "start_time": "2023-12-11T22:43:00.814386700Z" + "end_time": "2024-02-03T19:01:33.640159400Z", + "start_time": "2024-02-03T19:01:33.607158500Z" } } }, @@ -443,7 +429,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "outputs": [], "source": [ "query = \"INSERT INTO public.PyMEOS_demo(MMSI, trajectory, SOG) VALUES\"\n", @@ -454,14 +440,24 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "start_time": "2023-12-11T22:43:00.816386300Z" + "end_time": "2024-02-03T19:01:42.605529200Z", + "start_time": "2024-02-03T19:01:35.004396600Z" } } }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 11, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 3.13 s, sys: 331 ms, total: 3.46 s\n", + "Wall time: 48.9 s\n" + ] + } + ], "source": [ "%%time\n", "cursor.execute(query)\n", @@ -470,7 +466,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "start_time": "2023-12-11T22:43:00.818386900Z" + "end_time": "2024-02-03T19:02:31.561016100Z", + "start_time": "2024-02-03T19:01:42.608530900Z" } } }, @@ -485,8 +482,17 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 12, + "outputs": [ + { + "data": { + "text/plain": "2884" + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "cursor.execute(\"SELECT COUNT(*) FROM public.PyMEOS_demo;\")\n", "cursor.fetchone()[0]" @@ -494,7 +500,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "start_time": "2023-12-11T22:43:00.822386300Z" + "end_time": "2024-02-03T19:02:31.570017700Z", + "start_time": "2024-02-03T19:02:31.555016400Z" } } }, @@ -509,8 +516,20 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 13, + "outputs": [ + { + "ename": "TypeError", + "evalue": "cannot unpack non-iterable NoneType object", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mTypeError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[13], line 2\u001B[0m\n\u001B[1;32m 1\u001B[0m cursor\u001B[38;5;241m.\u001B[39mexecute(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mSELECT * FROM public.PyMEOS_demo WHERE MMSI = 97000050;\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[0;32m----> 2\u001B[0m mmsi, trajectory, sog \u001B[38;5;241m=\u001B[39m cursor\u001B[38;5;241m.\u001B[39mfetchone()\n", + "\u001B[0;31mTypeError\u001B[0m: cannot unpack non-iterable NoneType object" + ] + } + ], "source": [ "cursor.execute(\"SELECT * FROM public.PyMEOS_demo WHERE MMSI = 97000050;\")\n", "mmsi, trajectory, sog = cursor.fetchone()" @@ -518,7 +537,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "start_time": "2023-12-11T22:43:00.823388100Z" + "end_time": "2024-02-03T19:02:31.613014400Z", + "start_time": "2024-02-03T19:02:31.567018600Z" } } }, @@ -536,7 +556,7 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "start_time": "2023-12-11T22:43:00.824386700Z" + "start_time": "2024-02-03T19:02:31.584019200Z" } } }, @@ -561,7 +581,7 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "start_time": "2023-12-11T22:43:00.824386700Z" + "start_time": "2024-02-03T19:02:31.585019Z" } } } diff --git a/pymeos_examples/PyMEOS_Examples/BerlinMOD.ipynb b/pymeos_examples/PyMEOS_Examples/BerlinMOD.ipynb index d5542a4e..0f9733be 100644 --- a/pymeos_examples/PyMEOS_Examples/BerlinMOD.ipynb +++ b/pymeos_examples/PyMEOS_Examples/BerlinMOD.ipynb @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "outputs": [], "source": [ "from datetime import timedelta\n", @@ -48,8 +48,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:44:44.684913600Z", - "start_time": "2023-10-27T22:44:43.815923100Z" + "end_time": "2024-02-03T18:57:34.491632500Z", + "start_time": "2024-02-03T18:57:33.735855600Z" } } }, @@ -64,14 +64,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "outputs": [ { "data": { "text/plain": " vehicle day seq trip\n0 1 2020-06-01 1 [POINT(496253.84080706234 6601691.244869352)@2...\n1 1 2020-06-01 2 [POINT(481241.17182724166 6588272.126511315)@2...\n2 1 2020-06-02 1 [POINT(496253.84080706234 6601691.244869352)@2...\n3 1 2020-06-02 2 [POINT(481241.17182724166 6588272.126511315)@2...\n4 1 2020-06-03 1 [POINT(496253.84080706234 6601691.244869352)@2...", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
vehicledayseqtrip
012020-06-011[POINT(496253.84080706234 6601691.244869352)@2...
112020-06-012[POINT(481241.17182724166 6588272.126511315)@2...
212020-06-021[POINT(496253.84080706234 6601691.244869352)@2...
312020-06-022[POINT(481241.17182724166 6588272.126511315)@2...
412020-06-031[POINT(496253.84080706234 6601691.244869352)@2...
\n
" }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -88,8 +88,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:44:45.085524100Z", - "start_time": "2023-10-27T22:44:44.508912500Z" + "end_time": "2024-02-03T18:57:35.065197200Z", + "start_time": "2024-02-03T18:57:34.495631900Z" } } }, @@ -115,14 +115,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "outputs": [ { "data": { "text/plain": " vehicle day seq \\\n0 1 2020-06-01 1 \n1 1 2020-06-01 2 \n2 1 2020-06-02 1 \n3 1 2020-06-02 2 \n4 1 2020-06-03 1 \n\n geom \\\n0 [POINT (496253.84080706234 6601691.244869352),... \n1 [POINT (481241.17182724166 6588272.126511315),... \n2 [POINT (496253.84080706234 6601691.244869352),... \n3 [POINT (481241.17182724166 6588272.126511315),... \n4 [POINT (496253.84080706234 6601691.244869352),... \n\n t \n0 [2020-06-01 11:48:50.886000+02:00, 2020-06-01 ... \n1 [2020-06-01 18:00:27.208000+02:00, 2020-06-01 ... \n2 [2020-06-02 11:31:07.888000+02:00, 2020-06-02 ... \n3 [2020-06-02 18:47:26.738000+02:00, 2020-06-02 ... \n4 [2020-06-03 11:30:29.334000+02:00, 2020-06-03 ... ", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
vehicledayseqgeomt
012020-06-011[POINT (496253.84080706234 6601691.244869352),...[2020-06-01 11:48:50.886000+02:00, 2020-06-01 ...
112020-06-012[POINT (481241.17182724166 6588272.126511315),...[2020-06-01 18:00:27.208000+02:00, 2020-06-01 ...
212020-06-021[POINT (496253.84080706234 6601691.244869352),...[2020-06-02 11:31:07.888000+02:00, 2020-06-02 ...
312020-06-022[POINT (481241.17182724166 6588272.126511315),...[2020-06-02 18:47:26.738000+02:00, 2020-06-02 ...
412020-06-031[POINT (496253.84080706234 6601691.244869352),...[2020-06-03 11:30:29.334000+02:00, 2020-06-03 ...
\n
" }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -136,8 +136,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:44:55.025667500Z", - "start_time": "2023-10-27T22:44:45.081523700Z" + "end_time": "2024-02-03T18:57:45.352272600Z", + "start_time": "2024-02-03T18:57:35.073682300Z" } } }, @@ -152,14 +152,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "outputs": [ { "data": { "text/plain": " vehicle day seq geom \\\n110254 8 2020-06-01 1 POINT (493442.7231019071 6595901.46838472) \n110255 8 2020-06-01 1 POINT (493443.8028284878 6595906.350412016) \n110256 8 2020-06-01 1 POINT (493444.404026218 6595909.068751807) \n110257 8 2020-06-01 1 POINT (493441.7878750556 6595913.329708636) \n110258 8 2020-06-01 1 POINT (493428.7071192439 6595934.634492779) \n\n t \n110254 2020-06-01 10:22:51.025000+02:00 \n110255 2020-06-01 10:22:52.525000+02:00 \n110256 2020-06-01 10:22:54.574117+02:00 \n110257 2020-06-01 10:22:55.639765+02:00 \n110258 2020-06-01 10:23:00.139765+02:00 ", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
vehicledayseqgeomt
11025482020-06-011POINT (493442.7231019071 6595901.46838472)2020-06-01 10:22:51.025000+02:00
11025582020-06-011POINT (493443.8028284878 6595906.350412016)2020-06-01 10:22:52.525000+02:00
11025682020-06-011POINT (493444.404026218 6595909.068751807)2020-06-01 10:22:54.574117+02:00
11025782020-06-011POINT (493441.7878750556 6595913.329708636)2020-06-01 10:22:55.639765+02:00
11025882020-06-011POINT (493428.7071192439 6595934.634492779)2020-06-01 10:23:00.139765+02:00
\n
" }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -172,8 +172,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:44:55.715679900Z", - "start_time": "2023-10-27T22:44:55.014668200Z" + "end_time": "2024-02-03T18:57:46.135336900Z", + "start_time": "2024-02-03T18:57:45.349272800Z" } } }, @@ -188,14 +188,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "outputs": [ { "data": { "text/plain": " vehicle day seq geom \\\n110254 8 2020-06-01 1 01010000008BD374E40A1E1E41E803FA5D4F295941 \n110255 8 2020-06-01 1 0101000000CEAB18360F1E1E4185266D9650295941 \n110256 8 2020-06-01 1 0101000000840CB99D111E1E41FB6D664451295941 \n110257 8 2020-06-01 1 0101000000F5B7C826071E1E4140F2195552295941 \n110258 8 2020-06-01 1 01010000002C1117D4D21D1E419A879BA857295941 \n\n t \n110254 2020-06-01 10:22:51.025000+02:00 \n110255 2020-06-01 10:22:52.525000+02:00 \n110256 2020-06-01 10:22:54.574117+02:00 \n110257 2020-06-01 10:22:55.639765+02:00 \n110258 2020-06-01 10:23:00.139765+02:00 ", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
vehicledayseqgeomt
11025482020-06-01101010000008BD374E40A1E1E41E803FA5D4F2959412020-06-01 10:22:51.025000+02:00
11025582020-06-0110101000000CEAB18360F1E1E4185266D96502959412020-06-01 10:22:52.525000+02:00
11025682020-06-0110101000000840CB99D111E1E41FB6D6644512959412020-06-01 10:22:54.574117+02:00
11025782020-06-0110101000000F5B7C826071E1E4140F21955522959412020-06-01 10:22:55.639765+02:00
11025882020-06-01101010000002C1117D4D21D1E419A879BA8572959412020-06-01 10:23:00.139765+02:00
\n
" }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -207,14 +207,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:44:57.215322200Z", - "start_time": "2023-10-27T22:44:55.707677300Z" + "end_time": "2024-02-03T18:57:47.737059400Z", + "start_time": "2024-02-03T18:57:46.107335700Z" } } }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "outputs": [], "source": [ "records.to_csv(\"./data/trip_instants.csv\", index=False)" @@ -222,8 +222,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:44:58.446872100Z", - "start_time": "2023-10-27T22:44:57.203320Z" + "end_time": "2024-02-03T18:57:49.143794300Z", + "start_time": "2024-02-03T18:57:47.735060Z" } } }, @@ -249,14 +249,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "outputs": [ { "data": { "text/plain": " name \\\n0 Région de Bruxelles-Capitale - Brussels Hoofds... \n\n geom \n0 POLYGON ((472413.848 6589441.686, 472482.354 6... ", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
namegeom
0Région de Bruxelles-Capitale - Brussels Hoofds...POLYGON ((472413.848 6589441.686, 472482.354 6...
\n
" }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -272,21 +272,21 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:44:58.485871800Z", - "start_time": "2023-10-27T22:44:58.448872600Z" + "end_time": "2024-02-03T18:57:49.186792800Z", + "start_time": "2024-02-03T18:57:49.156795Z" } } }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "outputs": [ { "data": { "text/plain": " id name population \\\n0 1 Anderlecht 118241 \n1 2 Auderghem - Oudergem 33313 \n2 3 Berchem-Sainte-Agathe - Sint-Agatha-Berchem 24701 \n3 4 Etterbeek 176545 \n4 5 Evere 47414 \n5 6 Forest - Vorst 40394 \n6 7 Ganshoren 55746 \n7 8 Ixelles - Elsene 24596 \n8 9 Jette 86244 \n9 10 Koekelberg 51933 \n10 11 Molenbeek-Saint-Jean - Sint-Jans-Molenbeek 21609 \n11 12 Saint-Gilles - Sint-Gillis 96629 \n12 13 Saint-Josse-ten-Noode - Sint-Joost-ten-Node 50471 \n13 14 Schaerbeek - Schaarbeek 27115 \n14 15 Uccle - Ukkel 133042 \n15 16 Ville de Bruxelles - Stad Brussel 82307 \n16 17 Watermael-Boitsfort - Watermaal-Bosvoorde 24871 \n17 18 Woluwe-Saint-Lambert - Sint-Lambrechts-Woluwe 55216 \n18 19 Woluwe-Saint-Pierre - Sint-Pieters-Woluwe 41217 \n\n geom color \n0 POLYGON ((476959.746 6593981.357, 476965.401 6... #00ff00 \n1 POLYGON ((497620.844 6584185.646, 497856.652 6... #ff00ff \n2 POLYGON ((477788.720 6599192.996, 477782.631 6... #007fff \n3 POLYGON ((489804.602 6593678.230, 489685.067 6... #ff7f00 \n4 POLYGON ((492771.667 6597070.173, 492633.519 6... #7fbf7f \n5 POLYGON ((479909.268 6585570.952, 479881.003 6... #47139e \n6 POLYGON ((478477.209 6600450.089, 478499.863 6... #ad0414 \n7 MULTIPOLYGON (((487496.626 6592340.790, 487544... #d981f9 \n8 POLYGON ((481479.217 6597749.534, 481526.350 6... #138014 \n9 POLYGON ((480236.024 6597825.520, 480178.160 6... #f4fc2c \n10 POLYGON ((477542.960 6595837.350, 477533.621 6... #00ffff \n11 POLYGON ((483153.140 6593066.827, 483122.204 6... #00ff7f \n12 POLYGON ((485033.738 6596581.156, 484882.700 6... #c04d7c \n13 POLYGON ((488501.707 6600305.815, 488394.028 6... #85eaf3 \n14 POLYGON ((486268.683 6588562.809, 486253.744 6... #85d601 \n15 POLYGON ((483153.140 6593066.827, 483186.758 6... #fca880 \n16 POLYGON ((491240.935 6581131.551, 491340.822 6... #0000ff \n17 POLYGON ((496682.744 6594589.884, 496653.033 6... #019d92 \n18 POLYGON ((496135.453 6589271.827, 496258.928 6... #907817 ", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
idnamepopulationgeomcolor
01Anderlecht118241POLYGON ((476959.746 6593981.357, 476965.401 6...#00ff00
12Auderghem - Oudergem33313POLYGON ((497620.844 6584185.646, 497856.652 6...#ff00ff
23Berchem-Sainte-Agathe - Sint-Agatha-Berchem24701POLYGON ((477788.720 6599192.996, 477782.631 6...#007fff
34Etterbeek176545POLYGON ((489804.602 6593678.230, 489685.067 6...#ff7f00
45Evere47414POLYGON ((492771.667 6597070.173, 492633.519 6...#7fbf7f
56Forest - Vorst40394POLYGON ((479909.268 6585570.952, 479881.003 6...#47139e
67Ganshoren55746POLYGON ((478477.209 6600450.089, 478499.863 6...#ad0414
78Ixelles - Elsene24596MULTIPOLYGON (((487496.626 6592340.790, 487544...#d981f9
89Jette86244POLYGON ((481479.217 6597749.534, 481526.350 6...#138014
910Koekelberg51933POLYGON ((480236.024 6597825.520, 480178.160 6...#f4fc2c
1011Molenbeek-Saint-Jean - Sint-Jans-Molenbeek21609POLYGON ((477542.960 6595837.350, 477533.621 6...#00ffff
1112Saint-Gilles - Sint-Gillis96629POLYGON ((483153.140 6593066.827, 483122.204 6...#00ff7f
1213Saint-Josse-ten-Noode - Sint-Joost-ten-Node50471POLYGON ((485033.738 6596581.156, 484882.700 6...#c04d7c
1314Schaerbeek - Schaarbeek27115POLYGON ((488501.707 6600305.815, 488394.028 6...#85eaf3
1415Uccle - Ukkel133042POLYGON ((486268.683 6588562.809, 486253.744 6...#85d601
1516Ville de Bruxelles - Stad Brussel82307POLYGON ((483153.140 6593066.827, 483186.758 6...#fca880
1617Watermael-Boitsfort - Watermaal-Bosvoorde24871POLYGON ((491240.935 6581131.551, 491340.822 6...#0000ff
1718Woluwe-Saint-Lambert - Sint-Lambrechts-Woluwe55216POLYGON ((496682.744 6594589.884, 496653.033 6...#019d92
1819Woluwe-Saint-Pierre - Sint-Pieters-Woluwe41217POLYGON ((496135.453 6589271.827, 496258.928 6...#907817
\n
" }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -322,19 +322,19 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:44:58.654974500Z", - "start_time": "2023-10-27T22:44:58.470873Z" + "end_time": "2024-02-03T18:57:49.334377900Z", + "start_time": "2024-02-03T18:57:49.169795600Z" } } }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -352,8 +352,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:03.070343Z", - "start_time": "2023-10-27T22:44:58.516873400Z" + "end_time": "2024-02-03T18:57:53.785949900Z", + "start_time": "2024-02-03T18:57:49.216814Z" } } }, @@ -368,12 +368,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -399,8 +399,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:06.262881100Z", - "start_time": "2023-10-27T22:45:03.069344800Z" + "end_time": "2024-02-03T18:57:57.064662200Z", + "start_time": "2024-02-03T18:57:53.784950400Z" } } }, @@ -415,14 +415,14 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "outputs": [ { "data": { "text/plain": " vehicle day seq \\\n0 1 2020-06-01 1 \n1 1 2020-06-01 2 \n2 1 2020-06-02 1 \n3 1 2020-06-02 2 \n4 1 2020-06-03 1 \n\n trip \\\n0 [POINT(496253.84080706234 6601691.244869352)@2... \n1 [POINT(481241.17182724166 6588272.126511315)@2... \n2 [POINT(496253.84080706234 6601691.244869352)@2... \n3 [POINT(481241.17182724166 6588272.126511315)@2... \n4 [POINT(496253.84080706234 6601691.244869352)@2... \n\n inside \\\n0 {[POINT(493452.04564533016 6596592.507628961)@... \n1 {[POINT(481241.17182724166 6588272.126511315)@... \n2 {[POINT(493452.04567213746 6596592.507642428)@... \n3 {[POINT(481241.17182724166 6588272.126511315)@... \n4 {[POINT(493452.04567213746 6596592.507642428)@... \n\n outside \n0 {[POINT(496253.84080706234 6601691.244869352)@... \n1 {(POINT(493488.118266309 6596572.0201423885)@2... \n2 {[POINT(496253.84080706234 6601691.244869352)@... \n3 {(POINT(493488.118266309 6596572.0201423885)@2... \n4 {[POINT(496253.84080706234 6601691.244869352)@... ", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
vehicledayseqtripinsideoutside
012020-06-011[POINT(496253.84080706234 6601691.244869352)@2...{[POINT(493452.04564533016 6596592.507628961)@...{[POINT(496253.84080706234 6601691.244869352)@...
112020-06-012[POINT(481241.17182724166 6588272.126511315)@2...{[POINT(481241.17182724166 6588272.126511315)@...{(POINT(493488.118266309 6596572.0201423885)@2...
212020-06-021[POINT(496253.84080706234 6601691.244869352)@2...{[POINT(493452.04567213746 6596592.507642428)@...{[POINT(496253.84080706234 6601691.244869352)@...
312020-06-022[POINT(481241.17182724166 6588272.126511315)@2...{[POINT(481241.17182724166 6588272.126511315)@...{(POINT(493488.118266309 6596572.0201423885)@2...
412020-06-031[POINT(496253.84080706234 6601691.244869352)@2...{[POINT(493452.04567213746 6596592.507642428)@...{[POINT(496253.84080706234 6601691.244869352)@...
\n
" }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -440,8 +440,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:13.921644800Z", - "start_time": "2023-10-27T22:45:06.261882100Z" + "end_time": "2024-02-03T18:58:05.815000400Z", + "start_time": "2024-02-03T18:57:57.064662200Z" } } }, @@ -456,7 +456,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "outputs": [ { "data": { @@ -508,8 +508,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:15.868930200Z", - "start_time": "2023-10-27T22:45:13.925645200Z" + "end_time": "2024-02-03T18:58:07.942664200Z", + "start_time": "2024-02-03T18:58:05.820234900Z" } } }, @@ -524,14 +524,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "outputs": [ { "data": { "text/plain": " vehicle day seq \\\n0 1 2020-06-01 1 \n1 1 2020-06-01 2 \n2 1 2020-06-02 1 \n3 1 2020-06-02 2 \n4 1 2020-06-03 1 \n\n trip Anderlecht-trajectory \\\n0 [POINT(496253.84080706234 6601691.244869352)@2... None \n1 [POINT(481241.17182724166 6588272.126511315)@2... None \n2 [POINT(496253.84080706234 6601691.244869352)@2... None \n3 [POINT(481241.17182724166 6588272.126511315)@2... None \n4 [POINT(496253.84080706234 6601691.244869352)@2... None \n\n Anderlecht-distance Auderghem - Oudergem-trajectory \\\n0 0.0 None \n1 0.0 None \n2 0.0 None \n3 0.0 None \n4 0.0 None \n\n Auderghem - Oudergem-distance \\\n0 0.0 \n1 0.0 \n2 0.0 \n3 0.0 \n4 0.0 \n\n Berchem-Sainte-Agathe - Sint-Agatha-Berchem-trajectory \\\n0 None \n1 None \n2 None \n3 None \n4 None \n\n Berchem-Sainte-Agathe - Sint-Agatha-Berchem-distance ... \\\n0 0 ... \n1 0 ... \n2 0 ... \n3 0 ... \n4 0 ... \n\n Uccle - Ukkel-trajectory Uccle - Ukkel-distance \\\n0 None 0.0 \n1 None 0.0 \n2 None 0.0 \n3 None 0.0 \n4 None 0.0 \n\n Ville de Bruxelles - Stad Brussel-trajectory \\\n0 {[POINT(489089.14461377583 6594225.227862967)@... \n1 {[POINT(484373.02614611824 6591974.073148593)@... \n2 {[POINT(489089.14461377583 6594225.227862967)@... \n3 {[POINT(484373.02614611824 6591974.073148593)@... \n4 {[POINT(489089.14461377583 6594225.227862967)@... \n\n Ville de Bruxelles - Stad Brussel-distance \\\n0 6238.532446 \n1 5890.625638 \n2 6238.532450 \n3 5890.625638 \n4 6238.532450 \n\n Watermael-Boitsfort - Watermaal-Bosvoorde-trajectory \\\n0 None \n1 None \n2 None \n3 None \n4 None \n\n Watermael-Boitsfort - Watermaal-Bosvoorde-distance \\\n0 0.0 \n1 0.0 \n2 0.0 \n3 0.0 \n4 0.0 \n\n Woluwe-Saint-Lambert - Sint-Lambrechts-Woluwe-trajectory \\\n0 {[POINT(493452.04564533016 6596592.507628961)@... \n1 {[POINT(491131.62956994347 6595158.952745219)@... \n2 {[POINT(493452.04567213746 6596592.507642428)@... \n3 {[POINT(491131.62956994347 6595158.952745219)@... \n4 {[POINT(493452.04567213746 6596592.507642428)@... \n\n Woluwe-Saint-Lambert - Sint-Lambrechts-Woluwe-distance \\\n0 2743.319101 \n1 2753.083663 \n2 2743.319131 \n3 2753.083663 \n4 2743.319131 \n\n Woluwe-Saint-Pierre - Sint-Pieters-Woluwe-trajectory \\\n0 None \n1 None \n2 None \n3 None \n4 None \n\n Woluwe-Saint-Pierre - Sint-Pieters-Woluwe-distance \n0 0.0 \n1 0.0 \n2 0.0 \n3 0.0 \n4 0.0 \n\n[5 rows x 42 columns]", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
vehicledayseqtripAnderlecht-trajectoryAnderlecht-distanceAuderghem - Oudergem-trajectoryAuderghem - Oudergem-distanceBerchem-Sainte-Agathe - Sint-Agatha-Berchem-trajectoryBerchem-Sainte-Agathe - Sint-Agatha-Berchem-distance...Uccle - Ukkel-trajectoryUccle - Ukkel-distanceVille de Bruxelles - Stad Brussel-trajectoryVille de Bruxelles - Stad Brussel-distanceWatermael-Boitsfort - Watermaal-Bosvoorde-trajectoryWatermael-Boitsfort - Watermaal-Bosvoorde-distanceWoluwe-Saint-Lambert - Sint-Lambrechts-Woluwe-trajectoryWoluwe-Saint-Lambert - Sint-Lambrechts-Woluwe-distanceWoluwe-Saint-Pierre - Sint-Pieters-Woluwe-trajectoryWoluwe-Saint-Pierre - Sint-Pieters-Woluwe-distance
012020-06-011[POINT(496253.84080706234 6601691.244869352)@2...None0.0None0.0None0...None0.0{[POINT(489089.14461377583 6594225.227862967)@...6238.532446None0.0{[POINT(493452.04564533016 6596592.507628961)@...2743.319101None0.0
112020-06-012[POINT(481241.17182724166 6588272.126511315)@2...None0.0None0.0None0...None0.0{[POINT(484373.02614611824 6591974.073148593)@...5890.625638None0.0{[POINT(491131.62956994347 6595158.952745219)@...2753.083663None0.0
212020-06-021[POINT(496253.84080706234 6601691.244869352)@2...None0.0None0.0None0...None0.0{[POINT(489089.14461377583 6594225.227862967)@...6238.532450None0.0{[POINT(493452.04567213746 6596592.507642428)@...2743.319131None0.0
312020-06-022[POINT(481241.17182724166 6588272.126511315)@2...None0.0None0.0None0...None0.0{[POINT(484373.02614611824 6591974.073148593)@...5890.625638None0.0{[POINT(491131.62956994347 6595158.952745219)@...2753.083663None0.0
412020-06-031[POINT(496253.84080706234 6601691.244869352)@2...None0.0None0.0None0...None0.0{[POINT(489089.14461377583 6594225.227862967)@...6238.532450None0.0{[POINT(493452.04567213746 6596592.507642428)@...2743.319131None0.0
\n

5 rows × 42 columns

\n
" }, - "execution_count": 14, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -550,21 +550,21 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:21.206064500Z", - "start_time": "2023-10-27T22:45:15.873930500Z" + "end_time": "2024-02-03T18:58:12.663758200Z", + "start_time": "2024-02-03T18:58:07.948663100Z" } } }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "outputs": [ { "data": { "text/plain": " vehicle day seq Anderlecht-distance \\\n0 1 2020-06-01 1 0.0 \n1 1 2020-06-01 2 0.0 \n2 1 2020-06-02 1 0.0 \n3 1 2020-06-02 2 0.0 \n4 1 2020-06-03 1 0.0 \n\n Auderghem - Oudergem-distance \\\n0 0.0 \n1 0.0 \n2 0.0 \n3 0.0 \n4 0.0 \n\n Berchem-Sainte-Agathe - Sint-Agatha-Berchem-distance Etterbeek-distance \\\n0 0 0.0 \n1 0 0.0 \n2 0 0.0 \n3 0 0.0 \n4 0 0.0 \n\n Evere-distance Forest - Vorst-distance Ganshoren-distance ... \\\n0 0.0 3208.550776 0.0 ... \n1 0.0 3088.180926 0.0 ... \n2 0.0 3208.550776 0.0 ... \n3 0.0 3088.180930 0.0 ... \n4 0.0 3208.550776 0.0 ... \n\n Koekelberg-distance Molenbeek-Saint-Jean - Sint-Jans-Molenbeek-distance \\\n0 0.0 0.0 \n1 0.0 0.0 \n2 0.0 0.0 \n3 0.0 0.0 \n4 0.0 0.0 \n\n Saint-Gilles - Sint-Gillis-distance \\\n0 2082.592245 \n1 2438.565180 \n2 2082.592241 \n3 2438.565176 \n4 2082.592241 \n\n Saint-Josse-ten-Noode - Sint-Joost-ten-Node-distance \\\n0 0.0 \n1 0.0 \n2 0.0 \n3 0.0 \n4 0.0 \n\n Schaerbeek - Schaarbeek-distance Uccle - Ukkel-distance \\\n0 2241.087203 0.0 \n1 2254.134586 0.0 \n2 2241.087203 0.0 \n3 2254.134586 0.0 \n4 2241.087203 0.0 \n\n Ville de Bruxelles - Stad Brussel-distance \\\n0 6238.532446 \n1 5890.625638 \n2 6238.532450 \n3 5890.625638 \n4 6238.532450 \n\n Watermael-Boitsfort - Watermaal-Bosvoorde-distance \\\n0 0.0 \n1 0.0 \n2 0.0 \n3 0.0 \n4 0.0 \n\n Woluwe-Saint-Lambert - Sint-Lambrechts-Woluwe-distance \\\n0 2743.319101 \n1 2753.083663 \n2 2743.319131 \n3 2753.083663 \n4 2743.319131 \n\n Woluwe-Saint-Pierre - Sint-Pieters-Woluwe-distance \n0 0.0 \n1 0.0 \n2 0.0 \n3 0.0 \n4 0.0 \n\n[5 rows x 22 columns]", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
vehicledayseqAnderlecht-distanceAuderghem - Oudergem-distanceBerchem-Sainte-Agathe - Sint-Agatha-Berchem-distanceEtterbeek-distanceEvere-distanceForest - Vorst-distanceGanshoren-distance...Koekelberg-distanceMolenbeek-Saint-Jean - Sint-Jans-Molenbeek-distanceSaint-Gilles - Sint-Gillis-distanceSaint-Josse-ten-Noode - Sint-Joost-ten-Node-distanceSchaerbeek - Schaarbeek-distanceUccle - Ukkel-distanceVille de Bruxelles - Stad Brussel-distanceWatermael-Boitsfort - Watermaal-Bosvoorde-distanceWoluwe-Saint-Lambert - Sint-Lambrechts-Woluwe-distanceWoluwe-Saint-Pierre - Sint-Pieters-Woluwe-distance
012020-06-0110.00.000.00.03208.5507760.0...0.00.02082.5922450.02241.0872030.06238.5324460.02743.3191010.0
112020-06-0120.00.000.00.03088.1809260.0...0.00.02438.5651800.02254.1345860.05890.6256380.02753.0836630.0
212020-06-0210.00.000.00.03208.5507760.0...0.00.02082.5922410.02241.0872030.06238.5324500.02743.3191310.0
312020-06-0220.00.000.00.03088.1809300.0...0.00.02438.5651760.02254.1345860.05890.6256380.02753.0836630.0
412020-06-0310.00.000.00.03208.5507760.0...0.00.02082.5922410.02241.0872030.06238.5324500.02743.3191310.0
\n

5 rows × 22 columns

\n
" }, - "execution_count": 15, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -578,8 +578,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:21.222065600Z", - "start_time": "2023-10-27T22:45:21.200064200Z" + "end_time": "2024-02-03T18:58:12.690415800Z", + "start_time": "2024-02-03T18:58:12.667760800Z" } } }, @@ -594,7 +594,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "outputs": [ { "data": { @@ -635,8 +635,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:27.008853200Z", - "start_time": "2023-10-27T22:45:21.227067Z" + "end_time": "2024-02-03T18:58:18.344199200Z", + "start_time": "2024-02-03T18:58:12.708412900Z" } } }, @@ -662,7 +662,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "outputs": [], "source": [ "tolerance = 20" @@ -670,8 +670,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:27.008853200Z", - "start_time": "2023-10-27T22:45:27.007850800Z" + "end_time": "2024-02-03T18:58:18.345197700Z", + "start_time": "2024-02-03T18:58:18.338199500Z" } } }, @@ -686,14 +686,14 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "outputs": [ { "data": { "text/plain": " vehicle day seq \\\n0 1 2020-06-01 1 \n1 1 2020-06-01 2 \n2 1 2020-06-02 1 \n3 1 2020-06-02 2 \n4 1 2020-06-03 1 \n\n trip \\\n0 [POINT(496253.84080706234 6601691.244869352)@2... \n1 [POINT(481241.17182724166 6588272.126511315)@2... \n2 [POINT(496253.84080706234 6601691.244869352)@2... \n3 [POINT(481241.17182724166 6588272.126511315)@2... \n4 [POINT(496253.84080706234 6601691.244869352)@2... \n\n dp \\\n0 [POINT(496253.84080706234 6601691.244869352)@2... \n1 [POINT(481241.17182724166 6588272.126511315)@2... \n2 [POINT(496253.84080706234 6601691.244869352)@2... \n3 [POINT(481241.17182724166 6588272.126511315)@2... \n4 [POINT(496253.84080706234 6601691.244869352)@2... \n\n sed \n0 [POINT(496253.84080706234 6601691.244869352)@2... \n1 [POINT(481241.17182724166 6588272.126511315)@2... \n2 [POINT(496253.84080706234 6601691.244869352)@2... \n3 [POINT(481241.17182724166 6588272.126511315)@2... \n4 [POINT(496253.84080706234 6601691.244869352)@2... ", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
vehicledayseqtripdpsed
012020-06-011[POINT(496253.84080706234 6601691.244869352)@2...[POINT(496253.84080706234 6601691.244869352)@2...[POINT(496253.84080706234 6601691.244869352)@2...
112020-06-012[POINT(481241.17182724166 6588272.126511315)@2...[POINT(481241.17182724166 6588272.126511315)@2...[POINT(481241.17182724166 6588272.126511315)@2...
212020-06-021[POINT(496253.84080706234 6601691.244869352)@2...[POINT(496253.84080706234 6601691.244869352)@2...[POINT(496253.84080706234 6601691.244869352)@2...
312020-06-022[POINT(481241.17182724166 6588272.126511315)@2...[POINT(481241.17182724166 6588272.126511315)@2...[POINT(481241.17182724166 6588272.126511315)@2...
412020-06-031[POINT(496253.84080706234 6601691.244869352)@2...[POINT(496253.84080706234 6601691.244869352)@2...[POINT(496253.84080706234 6601691.244869352)@2...
\n
" }, - "execution_count": 18, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -711,14 +711,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:27.316251200Z", - "start_time": "2023-10-27T22:45:27.007850800Z" + "end_time": "2024-02-03T18:58:18.658701600Z", + "start_time": "2024-02-03T18:58:18.338199500Z" } } }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "outputs": [ { "data": { @@ -743,8 +743,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:32.198946700Z", - "start_time": "2023-10-27T22:45:27.300673500Z" + "end_time": "2024-02-03T18:58:23.829129Z", + "start_time": "2024-02-03T18:58:18.621700900Z" } } }, @@ -759,7 +759,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "outputs": [ { "data": { @@ -782,8 +782,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:32.374946600Z", - "start_time": "2023-10-27T22:45:32.206945600Z" + "end_time": "2024-02-03T18:58:23.995039200Z", + "start_time": "2024-02-03T18:58:23.829129Z" } } }, @@ -798,14 +798,14 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "outputs": [ { "data": { "text/plain": " vehicle day seq trip dp sed dp-delta sed-delta dp-% \\\n0 1 2020-06-01 1 2103 48 212 2055 1891 2.282454 \n1 1 2020-06-01 2 2326 65 232 2261 2094 2.794497 \n2 1 2020-06-02 1 2110 48 207 2062 1903 2.274882 \n3 1 2020-06-02 2 2308 65 235 2243 2073 2.816291 \n4 1 2020-06-03 1 2071 48 190 2023 1881 2.317721 \n\n sed-% \n0 10.080837 \n1 9.974205 \n2 9.810427 \n3 10.181976 \n4 9.174312 ", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
vehicledayseqtripdpseddp-deltased-deltadp-%sed-%
012020-06-011210348212205518912.28245410.080837
112020-06-012232665232226120942.7944979.974205
212020-06-021211048207206219032.2748829.810427
312020-06-022230865235224320732.81629110.181976
412020-06-031207148190202318812.3177219.174312
\n
" }, - "execution_count": 21, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -824,8 +824,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:32.405946700Z", - "start_time": "2023-10-27T22:45:32.373960300Z" + "end_time": "2024-02-03T18:58:24.012039100Z", + "start_time": "2024-02-03T18:58:24.000038500Z" } } }, @@ -840,14 +840,14 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "outputs": [ { "data": { "text/plain": " dp-delta dp-% sed-delta sed-%\ncount 96.000000 96.000000 96.000000 96.000000\nmean 1425.489583 2.686471 1315.750000 9.568915\nstd 718.930726 1.068704 649.342437 1.514393\nmin 98.000000 1.731844 91.000000 7.011070\n25% 923.500000 1.999928 875.250000 8.475305\n50% 1616.000000 2.367245 1471.500000 9.281897\n75% 2056.750000 2.859347 1894.000000 10.622931\nmax 3333.000000 7.547170 2990.000000 14.150943", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
dp-deltadp-%sed-deltased-%
count96.00000096.00000096.00000096.000000
mean1425.4895832.6864711315.7500009.568915
std718.9307261.068704649.3424371.514393
min98.0000001.73184491.0000007.011070
25%923.5000001.999928875.2500008.475305
50%1616.0000002.3672451471.5000009.281897
75%2056.7500002.8593471894.00000010.622931
max3333.0000007.5471702990.00000014.150943
\n
" }, - "execution_count": 22, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -858,8 +858,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:32.471945900Z", - "start_time": "2023-10-27T22:45:32.395944300Z" + "end_time": "2024-02-03T18:58:24.074039Z", + "start_time": "2024-02-03T18:58:24.015038400Z" } } }, @@ -897,7 +897,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "outputs": [], "source": [ "extent_bulk = TemporalPointExtentAggregator.aggregate(trips[\"trip\"])\n", @@ -906,14 +906,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:32.471945900Z", - "start_time": "2023-10-27T22:45:32.409944800Z" + "end_time": "2024-02-03T18:58:24.075037800Z", + "start_time": "2024-02-03T18:58:24.027039100Z" } } }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "outputs": [ { "data": { @@ -942,8 +942,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:35.199589700Z", - "start_time": "2023-10-27T22:45:32.453970Z" + "end_time": "2024-02-03T18:58:26.763975800Z", + "start_time": "2024-02-03T18:58:24.036039200Z" } } }, @@ -958,7 +958,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "outputs": [], "source": [ "day_trips = (\n", @@ -972,14 +972,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:35.215595300Z", - "start_time": "2023-10-27T22:45:35.198871500Z" + "end_time": "2024-02-03T18:58:26.765975600Z", + "start_time": "2024-02-03T18:58:26.748976200Z" } } }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "outputs": [ { "data": { @@ -1008,8 +1008,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:35.648123900Z", - "start_time": "2023-10-27T22:45:35.208594400Z" + "end_time": "2024-02-03T18:58:27.244507800Z", + "start_time": "2024-02-03T18:58:26.754976400Z" } } }, @@ -1028,7 +1028,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "outputs": [], "source": [ "extent_aggregator = TemporalPointExtentAggregator.start_aggregation()\n", @@ -1037,14 +1037,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:35.665124300Z", - "start_time": "2023-10-27T22:45:35.653125800Z" + "end_time": "2024-02-03T18:58:27.247507300Z", + "start_time": "2024-02-03T18:58:27.221977300Z" } } }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "outputs": [], "source": [ "for trip in trips[\"trip\"]:\n", @@ -1056,8 +1056,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:35.668124100Z", - "start_time": "2023-10-27T22:45:35.656124300Z" + "end_time": "2024-02-03T18:58:27.248506600Z", + "start_time": "2024-02-03T18:58:27.224507Z" } } }, @@ -1070,7 +1070,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "outputs": [ { "data": { @@ -1099,8 +1099,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:38.170575400Z", - "start_time": "2023-10-27T22:45:35.667124100Z" + "end_time": "2024-02-03T18:58:30.549692100Z", + "start_time": "2024-02-03T18:58:27.236509200Z" } } }, @@ -1115,7 +1115,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 29, "outputs": [ { "data": { @@ -1149,8 +1149,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:40.291650700Z", - "start_time": "2023-10-27T22:45:38.173573300Z" + "end_time": "2024-02-03T18:58:32.420742400Z", + "start_time": "2024-02-03T18:58:30.546357400Z" } } }, @@ -1176,7 +1176,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 30, "outputs": [], "source": [ "tiled_trips = trips[\"trip\"].apply(lambda tr: tr.tile(5e3, remove_empty=True))\n", @@ -1188,14 +1188,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:45:40.489164200Z", - "start_time": "2023-10-27T22:45:40.293649Z" + "end_time": "2024-02-03T18:58:32.654624700Z", + "start_time": "2024-02-03T18:58:32.415661200Z" } } }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 31, "outputs": [ { "data": { @@ -1223,8 +1223,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:46:24.706923100Z", - "start_time": "2023-10-27T22:45:40.502164800Z" + "end_time": "2024-02-03T18:59:14.195918700Z", + "start_time": "2024-02-03T18:58:32.667977500Z" } } }, @@ -1239,7 +1239,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 32, "outputs": [], "source": [ "extent_tiles = extent_bulk.tile(5e3)\n", @@ -1249,19 +1249,19 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:46:24.728929800Z", - "start_time": "2023-10-27T22:46:24.711925400Z" + "end_time": "2024-02-03T18:59:14.208918100Z", + "start_time": "2024-02-03T18:59:14.199918600Z" } } }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 33, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -1290,8 +1290,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:47:08.900081Z", - "start_time": "2023-10-27T22:46:24.717927100Z" + "end_time": "2024-02-03T18:59:58.269327800Z", + "start_time": "2024-02-03T18:59:14.205347Z" } } }, @@ -1307,7 +1307,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 34, "outputs": [], "source": [ "extent_tiles = extent_bulk.tile(5e3)\n", @@ -1328,21 +1328,21 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:47:09.003083200Z", - "start_time": "2023-10-27T22:47:08.904084800Z" + "end_time": "2024-02-03T18:59:58.379338700Z", + "start_time": "2024-02-03T18:59:58.274324900Z" } } }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 35, "outputs": [ { "data": { "text/plain": " tile count \\\n0 SRID=3857;STBOX X((475000,6580000),(480000,658... 10 \n1 SRID=3857;STBOX X((480000,6580000),(485000,658... 8 \n2 SRID=3857;STBOX X((495000,6580000),(500000,658... 8 \n3 SRID=3857;STBOX X((475000,6585000),(480000,659... 13 \n4 SRID=3857;STBOX X((480000,6585000),(485000,659... 20 \n5 SRID=3857;STBOX X((485000,6585000),(490000,659... 12 \n6 SRID=3857;STBOX X((490000,6585000),(495000,659... 6 \n7 SRID=3857;STBOX X((495000,6585000),(500000,659... 8 \n8 SRID=3857;STBOX X((475000,6590000),(480000,659... 8 \n9 SRID=3857;STBOX X((480000,6590000),(485000,659... 10 \n10 SRID=3857;STBOX X((485000,6590000),(490000,659... 37 \n11 SRID=3857;STBOX X((490000,6590000),(495000,659... 21 \n12 SRID=3857;STBOX X((495000,6590000),(500000,659... 4 \n13 SRID=3857;STBOX X((470000,6595000),(475000,660... 9 \n14 SRID=3857;STBOX X((475000,6595000),(480000,660... 30 \n15 SRID=3857;STBOX X((480000,6595000),(485000,660... 40 \n16 SRID=3857;STBOX X((485000,6595000),(490000,660... 18 \n17 SRID=3857;STBOX X((490000,6595000),(495000,660... 28 \n18 SRID=3857;STBOX X((495000,6595000),(500000,660... 16 \n19 SRID=3857;STBOX X((470000,6600000),(475000,660... 14 \n20 SRID=3857;STBOX X((475000,6600000),(480000,660... 11 \n21 SRID=3857;STBOX X((480000,6600000),(485000,660... 26 \n22 SRID=3857;STBOX X((485000,6600000),(490000,660... 8 \n23 SRID=3857;STBOX X((490000,6600000),(495000,660... 12 \n24 SRID=3857;STBOX X((495000,6600000),(500000,660... 14 \n25 SRID=3857;STBOX X((480000,6605000),(485000,661... 10 \n26 SRID=3857;STBOX X((485000,6605000),(490000,661... 10 \n27 SRID=3857;STBOX X((490000,6605000),(495000,661... 12 \n\n duration distance \n0 0 days 00:21:57.271928 12.715462 \n1 0 days 00:37:50.260034 15.250435 \n2 0 days 00:56:22.219006 19.807692 \n3 0 days 01:42:26.592035 59.420951 \n4 0 days 03:34:19.201837 73.582531 \n5 0 days 02:07:10.468161 52.101740 \n6 0 days 01:22:33.732748 36.422087 \n7 0 days 00:47:50.956624 42.149632 \n8 0 days 01:21:45.559201 54.962866 \n9 0 days 01:39:18.880626 35.092058 \n10 0 days 04:43:56.029545 135.629127 \n11 0 days 01:08:30.026607 27.547398 \n12 0 days 00:27:07.208503 20.924216 \n13 0 days 00:16:51.436501 10.185846 \n14 0 days 01:37:23.497930 38.060402 \n15 0 days 05:02:47.976012 127.956860 \n16 0 days 02:44:27.235479 69.741764 \n17 0 days 03:01:46.069980 113.754468 \n18 0 days 01:56:46.320943 79.532763 \n19 0 days 01:08:43.444506 23.299969 \n20 0 days 01:12:06.437047 55.651246 \n21 0 days 04:36:55.024443 145.456576 \n22 0 days 00:57:20.399942 36.388236 \n23 0 days 01:54:33.371322 58.257905 \n24 0 days 01:36:16.495602 46.346555 \n25 0 days 00:40:21.652772 22.114868 \n26 0 days 01:06:43.042539 33.102930 \n27 0 days 00:41:57.630167 22.865846 ", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
tilecountdurationdistance
0SRID=3857;STBOX X((475000,6580000),(480000,658...100 days 00:21:57.27192812.715462
1SRID=3857;STBOX X((480000,6580000),(485000,658...80 days 00:37:50.26003415.250435
2SRID=3857;STBOX X((495000,6580000),(500000,658...80 days 00:56:22.21900619.807692
3SRID=3857;STBOX X((475000,6585000),(480000,659...130 days 01:42:26.59203559.420951
4SRID=3857;STBOX X((480000,6585000),(485000,659...200 days 03:34:19.20183773.582531
5SRID=3857;STBOX X((485000,6585000),(490000,659...120 days 02:07:10.46816152.101740
6SRID=3857;STBOX X((490000,6585000),(495000,659...60 days 01:22:33.73274836.422087
7SRID=3857;STBOX X((495000,6585000),(500000,659...80 days 00:47:50.95662442.149632
8SRID=3857;STBOX X((475000,6590000),(480000,659...80 days 01:21:45.55920154.962866
9SRID=3857;STBOX X((480000,6590000),(485000,659...100 days 01:39:18.88062635.092058
10SRID=3857;STBOX X((485000,6590000),(490000,659...370 days 04:43:56.029545135.629127
11SRID=3857;STBOX X((490000,6590000),(495000,659...210 days 01:08:30.02660727.547398
12SRID=3857;STBOX X((495000,6590000),(500000,659...40 days 00:27:07.20850320.924216
13SRID=3857;STBOX X((470000,6595000),(475000,660...90 days 00:16:51.43650110.185846
14SRID=3857;STBOX X((475000,6595000),(480000,660...300 days 01:37:23.49793038.060402
15SRID=3857;STBOX X((480000,6595000),(485000,660...400 days 05:02:47.976012127.956860
16SRID=3857;STBOX X((485000,6595000),(490000,660...180 days 02:44:27.23547969.741764
17SRID=3857;STBOX X((490000,6595000),(495000,660...280 days 03:01:46.069980113.754468
18SRID=3857;STBOX X((495000,6595000),(500000,660...160 days 01:56:46.32094379.532763
19SRID=3857;STBOX X((470000,6600000),(475000,660...140 days 01:08:43.44450623.299969
20SRID=3857;STBOX X((475000,6600000),(480000,660...110 days 01:12:06.43704755.651246
21SRID=3857;STBOX X((480000,6600000),(485000,660...260 days 04:36:55.024443145.456576
22SRID=3857;STBOX X((485000,6600000),(490000,660...80 days 00:57:20.39994236.388236
23SRID=3857;STBOX X((490000,6600000),(495000,660...120 days 01:54:33.37132258.257905
24SRID=3857;STBOX X((495000,6600000),(500000,660...140 days 01:36:16.49560246.346555
25SRID=3857;STBOX X((480000,6605000),(485000,661...100 days 00:40:21.65277222.114868
26SRID=3857;STBOX X((485000,6605000),(490000,661...100 days 01:06:43.04253933.102930
27SRID=3857;STBOX X((490000,6605000),(495000,661...120 days 00:41:57.63016722.865846
\n
" }, - "execution_count": 36, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -1353,8 +1353,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:47:09.030082200Z", - "start_time": "2023-10-27T22:47:09.006081700Z" + "end_time": "2024-02-03T18:59:58.396339100Z", + "start_time": "2024-02-03T18:59:58.384335500Z" } } }, @@ -1369,7 +1369,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 36, "outputs": [], "source": [ "speed_tiles = speed_extent.tile(10, \"1 day\", 0, \"2020-06-01\")\n", @@ -1387,21 +1387,21 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:47:09.525081100Z", - "start_time": "2023-10-27T22:47:09.011080400Z" + "end_time": "2024-02-03T18:59:58.894229300Z", + "start_time": "2024-02-03T18:59:58.391338200Z" } } }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 37, "outputs": [ { "data": { "text/plain": " tile count \\\n0 TBOXFLOAT XT([0, 10),[2020-06-01 00:00:00+02, ... 21 \n1 TBOXFLOAT XT([10, 20),[2020-06-01 00:00:00+02,... 21 \n2 TBOXFLOAT XT([20, 30),[2020-06-01 00:00:00+02,... 12 \n3 TBOXFLOAT XT([30, 40),[2020-06-01 00:00:00+02,... 11 \n4 TBOXFLOAT XT([0, 10),[2020-06-02 00:00:00+02, ... 23 \n5 TBOXFLOAT XT([10, 20),[2020-06-02 00:00:00+02,... 21 \n6 TBOXFLOAT XT([20, 30),[2020-06-02 00:00:00+02,... 12 \n7 TBOXFLOAT XT([30, 40),[2020-06-02 00:00:00+02,... 11 \n8 TBOXFLOAT XT([0, 10),[2020-06-03 00:00:00+02, ... 24 \n9 TBOXFLOAT XT([10, 20),[2020-06-03 00:00:00+02,... 22 \n10 TBOXFLOAT XT([20, 30),[2020-06-03 00:00:00+02,... 13 \n11 TBOXFLOAT XT([30, 40),[2020-06-03 00:00:00+02,... 12 \n12 TBOXFLOAT XT([0, 10),[2020-06-04 00:00:00+02, ... 28 \n13 TBOXFLOAT XT([10, 20),[2020-06-04 00:00:00+02,... 26 \n14 TBOXFLOAT XT([20, 30),[2020-06-04 00:00:00+02,... 14 \n15 TBOXFLOAT XT([30, 40),[2020-06-04 00:00:00+02,... 12 \n\n duration \n0 0 days 07:31:24.685901 \n1 0 days 03:03:36.408255 \n2 0 days 00:31:46.326571 \n3 0 days 00:12:42.223983 \n4 0 days 07:39:36.356752 \n5 0 days 03:02:29.137009 \n6 0 days 00:31:04.548691 \n7 0 days 00:14:00.514541 \n8 0 days 08:16:09.948028 \n9 0 days 03:03:03.718551 \n10 0 days 00:44:43.354712 \n11 0 days 00:12:20.122468 \n12 0 days 09:01:32.980751 \n13 0 days 03:23:41.826769 \n14 0 days 00:38:43.298191 \n15 0 days 00:10:49.332312 ", "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
tilecountduration
0TBOXFLOAT XT([0, 10),[2020-06-01 00:00:00+02, ...210 days 07:31:24.685901
1TBOXFLOAT XT([10, 20),[2020-06-01 00:00:00+02,...210 days 03:03:36.408255
2TBOXFLOAT XT([20, 30),[2020-06-01 00:00:00+02,...120 days 00:31:46.326571
3TBOXFLOAT XT([30, 40),[2020-06-01 00:00:00+02,...110 days 00:12:42.223983
4TBOXFLOAT XT([0, 10),[2020-06-02 00:00:00+02, ...230 days 07:39:36.356752
5TBOXFLOAT XT([10, 20),[2020-06-02 00:00:00+02,...210 days 03:02:29.137009
6TBOXFLOAT XT([20, 30),[2020-06-02 00:00:00+02,...120 days 00:31:04.548691
7TBOXFLOAT XT([30, 40),[2020-06-02 00:00:00+02,...110 days 00:14:00.514541
8TBOXFLOAT XT([0, 10),[2020-06-03 00:00:00+02, ...240 days 08:16:09.948028
9TBOXFLOAT XT([10, 20),[2020-06-03 00:00:00+02,...220 days 03:03:03.718551
10TBOXFLOAT XT([20, 30),[2020-06-03 00:00:00+02,...130 days 00:44:43.354712
11TBOXFLOAT XT([30, 40),[2020-06-03 00:00:00+02,...120 days 00:12:20.122468
12TBOXFLOAT XT([0, 10),[2020-06-04 00:00:00+02, ...280 days 09:01:32.980751
13TBOXFLOAT XT([10, 20),[2020-06-04 00:00:00+02,...260 days 03:23:41.826769
14TBOXFLOAT XT([20, 30),[2020-06-04 00:00:00+02,...140 days 00:38:43.298191
15TBOXFLOAT XT([30, 40),[2020-06-04 00:00:00+02,...120 days 00:10:49.332312
\n
" }, - "execution_count": 38, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -1412,8 +1412,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-10-27T22:47:09.526081400Z", - "start_time": "2023-10-27T22:47:09.145081800Z" + "end_time": "2024-02-03T18:59:59.005139300Z", + "start_time": "2024-02-03T18:59:58.553532800Z" } } }